Refactor codebase

src/engine/world/generator.ts

@@ -0,0 +1,164 @@
+import { type World, type EntityId, type RunState, type Tile, type Actor, type Vec2 } from "../../core/types";
+import { idx } from "./world-logic";
+import { GAME_CONFIG } from "../../core/config/GameConfig";
+import { seededRandom } from "../../core/math";
+
+interface Room {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * Generates a procedural dungeon world with rooms and corridors
+ * @param level The level number (affects difficulty and randomness seed)
+ * @param runState Player's persistent state across levels
+ * @returns Generated world and player ID
+ */
+export function generateWorld(level: number, runState: RunState): { world: World; playerId: EntityId } {
+  const width = GAME_CONFIG.map.width;
+  const height = GAME_CONFIG.map.height;
+  const tiles: Tile[] = new Array(width * height).fill(1); // Start with all walls
+
+  const random = seededRandom(level * 12345);
+  
+  const rooms = generateRooms(width, height, tiles, random);
+  
+  // Place player in first room
+  const firstRoom = rooms[0];
+  const playerX = firstRoom.x + Math.floor(firstRoom.width / 2);
+  const playerY = firstRoom.y + Math.floor(firstRoom.height / 2);
+
+  // Place exit in last room
+  const lastRoom = rooms[rooms.length - 1];
+  const exitX = lastRoom.x + Math.floor(lastRoom.width / 2);
+  const exitY = lastRoom.y + Math.floor(lastRoom.height / 2);
+  const exit: Vec2 = { x: exitX, y: exitY };
+
+  const actors = new Map<EntityId, Actor>();
+
+  const playerId = 1;
+  actors.set(playerId, {
+    id: playerId,
+    isPlayer: true,
+    type: "player",
+    pos: { x: playerX, y: playerY },
+    speed: GAME_CONFIG.player.speed,
+    energy: 0,
+    stats: { ...runState.stats },
+    inventory: { gold: runState.inventory.gold, items: [...runState.inventory.items] }
+  });
+
+  placeEnemies(level, rooms, actors, random);
+
+  return { world: { width, height, tiles, actors, exit }, playerId };
+}
+
+function generateRooms(width: number, height: number, tiles: Tile[], random: () => number): Room[] {
+  const rooms: Room[] = [];
+  const numRooms = GAME_CONFIG.map.minRooms + Math.floor(random() * (GAME_CONFIG.map.maxRooms - GAME_CONFIG.map.minRooms + 1));
+  
+  const fakeWorldForIdx = { width, height };
+
+  for (let i = 0; i < numRooms; i++) {
+    const roomWidth = GAME_CONFIG.map.roomMinWidth + Math.floor(random() * (GAME_CONFIG.map.roomMaxWidth - GAME_CONFIG.map.roomMinWidth + 1));
+    const roomHeight = GAME_CONFIG.map.roomMinHeight + Math.floor(random() * (GAME_CONFIG.map.roomMaxHeight - GAME_CONFIG.map.roomMinHeight + 1));
+    const roomX = 1 + Math.floor(random() * (width - roomWidth - 2));
+    const roomY = 1 + Math.floor(random() * (height - roomHeight - 2));
+    
+    const newRoom: Room = { x: roomX, y: roomY, width: roomWidth, height: roomHeight };
+    
+    if (!doesOverlap(newRoom, rooms)) {
+      carveRoom(newRoom, tiles, fakeWorldForIdx);
+      
+      if (rooms.length > 0) {
+        carveCorridor(rooms[rooms.length - 1], newRoom, tiles, fakeWorldForIdx, random);
+      }
+      
+      rooms.push(newRoom);
+    }
+  }
+  return rooms;
+}
+
+function doesOverlap(newRoom: Room, rooms: Room[]): boolean {
+  for (const room of rooms) {
+    if (
+      newRoom.x < room.x + room.width + 1 &&
+      newRoom.x + newRoom.width + 1 > room.x &&
+      newRoom.y < room.y + room.height + 1 &&
+      newRoom.y + newRoom.height + 1 > room.y
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function carveRoom(room: Room, tiles: Tile[], world: any): void {
+  for (let x = room.x; x < room.x + room.width; x++) {
+    for (let y = room.y; y < room.y + room.height; y++) {
+      tiles[idx(world, x, y)] = 0;
+    }
+  }
+}
+
+function carveCorridor(room1: Room, room2: Room, tiles: Tile[], world: any, random: () => number): void {
+  const x1 = Math.floor(room1.x + room1.width / 2);
+  const y1 = Math.floor(room1.y + room1.height / 2);
+  const x2 = Math.floor(room2.x + room2.width / 2);
+  const y2 = Math.floor(room2.y + room2.height / 2);
+
+  if (random() < 0.5) {
+    // Horizontal then vertical
+    for (let x = Math.min(x1, x2); x <= Math.max(x1, x2); x++) {
+      tiles[idx(world, x, y1)] = 0;
+    }
+    for (let y = Math.min(y1, y2); y <= Math.max(y1, y2); y++) {
+      tiles[idx(world, x2, y)] = 0;
+    }
+  } else {
+    // Vertical then horizontal
+    for (let y = Math.min(y1, y2); y <= Math.max(y1, y2); y++) {
+      tiles[idx(world, x1, y)] = 0;
+    }
+    for (let x = Math.min(x1, x2); x <= Math.max(x1, x2); x++) {
+      tiles[idx(world, x, y2)] = 0;
+    }
+  }
+}
+
+function placeEnemies(level: number, rooms: Room[], actors: Map<EntityId, Actor>, random: () => number): void {
+  let enemyId = 2;
+  const numEnemies = GAME_CONFIG.enemy.baseCount + level * GAME_CONFIG.enemy.baseCountPerLevel + Math.floor(random() * GAME_CONFIG.enemy.randomBonus);
+  
+  for (let i = 0; i < numEnemies && i < rooms.length - 1; i++) {
+    const roomIdx = 1 + Math.floor(random() * (rooms.length - 1));
+    const room = rooms[roomIdx];
+    
+    const enemyX = room.x + 1 + Math.floor(random() * (room.width - 2));
+    const enemyY = room.y + 1 + Math.floor(random() * (room.height - 2));
+    
+    const baseHp = GAME_CONFIG.enemy.baseHp + level * GAME_CONFIG.enemy.baseHpPerLevel;
+    const baseAttack = GAME_CONFIG.enemy.baseAttack + Math.floor(level / 2) * GAME_CONFIG.enemy.attackPerTwoLevels;
+    
+    actors.set(enemyId, {
+      id: enemyId,
+      isPlayer: false,
+      type: random() < 0.5 ? "rat" : "bat",
+      pos: { x: enemyX, y: enemyY },
+      speed: GAME_CONFIG.enemy.minSpeed + Math.floor(random() * (GAME_CONFIG.enemy.maxSpeed - GAME_CONFIG.enemy.minSpeed)),
+      energy: 0,
+      stats: {
+        maxHp: baseHp + Math.floor(random() * 4),
+        hp: baseHp + Math.floor(random() * 4),
+        attack: baseAttack + Math.floor(random() * 2),
+        defense: Math.floor(random() * (GAME_CONFIG.enemy.maxDefense + 1))
+      }
+    });
+    enemyId++;
+  }
+}
+
+export const makeTestWorld = generateWorld;