Another refactor

src/engine/world/generator.ts

@@ -214,54 +214,68 @@ function placeEnemies(floor: number, rooms: Room[], actors: Map<EntityId, Actor>
   const numEnemies = GAME_CONFIG.enemyScaling.baseCount + floor * GAME_CONFIG.enemyScaling.baseCountPerFloor; 
   
   const enemyTypes = Object.keys(GAME_CONFIG.enemies);
+  const occupiedPositions = new Set<string>();
 
-  for (let i = 0; i < numEnemies && i < rooms.length - 1; i++) {
+  for (let i = 0; i < numEnemies; i++) {
+    // Pick a random room (not the starting room 0)
     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 type = enemyTypes[Math.floor(random() * enemyTypes.length)] as keyof typeof GAME_CONFIG.enemies;
-    const enemyDef = GAME_CONFIG.enemies[type];
+    // Try to find an empty spot in the room
+    for (let attempts = 0; attempts < 5; attempts++) {
 
-    const scaledHp = enemyDef.baseHp + floor * GAME_CONFIG.enemyScaling.hpPerFloor;
-    const scaledAttack = enemyDef.baseAttack + Math.floor(floor / 2) * GAME_CONFIG.enemyScaling.attackPerTwoFloors;
-    
-    actors.set(enemyId, {
-      id: enemyId,
-      category: "combatant",
-      isPlayer: false,
-      type,
-      pos: { x: enemyX, y: enemyY },
-      speed: enemyDef.minSpeed + Math.floor(random() * (enemyDef.maxSpeed - enemyDef.minSpeed)),
-      energy: 0,
-      stats: {
-        maxHp: scaledHp + Math.floor(random() * 4),
-        hp: scaledHp + Math.floor(random() * 4),
-        attack: scaledAttack + Math.floor(random() * 2),
-        defense: enemyDef.baseDefense,
-        level: 0,
-        exp: 0,
-        expToNextLevel: 0,
-        statPoints: 0,
-        skillPoints: 0,
-        strength: 0,
-        dexterity: 0,
-        intelligence: 0,
-        critChance: 0,
-        critMultiplier: 100,
-        accuracy: 80,
-        lifesteal: 0,
-        evasion: 0,
-        blockChance: 0,
-        luck: 0,
-        passiveNodes: []
+      const ex = room.x + 1 + Math.floor(random() * (room.width - 2));
+      const ey = room.y + 1 + Math.floor(random() * (room.height - 2));
+      const k = `${ex},${ey}`;
+
+      if (!occupiedPositions.has(k)) {
+        const type = enemyTypes[Math.floor(random() * enemyTypes.length)] as keyof typeof GAME_CONFIG.enemies;
+        const enemyDef = GAME_CONFIG.enemies[type];
+
+        const scaledHp = enemyDef.baseHp + floor * GAME_CONFIG.enemyScaling.hpPerFloor;
+        const scaledAttack = enemyDef.baseAttack + Math.floor(floor / 2) * GAME_CONFIG.enemyScaling.attackPerTwoFloors;
+        
+        actors.set(enemyId, {
+          id: enemyId,
+          category: "combatant",
+          isPlayer: false,
+          type,
+          pos: { x: ex, y: ey },
+          speed: enemyDef.minSpeed + Math.floor(random() * (enemyDef.maxSpeed - enemyDef.minSpeed)),
+          energy: 0,
+          stats: {
+            maxHp: scaledHp + Math.floor(random() * 4),
+            hp: scaledHp + Math.floor(random() * 4),
+            attack: scaledAttack + Math.floor(random() * 2),
+            defense: enemyDef.baseDefense,
+            level: 0,
+            exp: 0,
+            expToNextLevel: 0,
+            statPoints: 0,
+            skillPoints: 0,
+            strength: 0,
+            dexterity: 0,
+            intelligence: 0,
+            critChance: 0,
+            critMultiplier: 100,
+            accuracy: 80,
+            lifesteal: 0,
+            evasion: 0,
+            blockChance: 0,
+            luck: 0,
+            passiveNodes: []
+          }
+        });
+        
+        occupiedPositions.add(k);
+        enemyId++;
+
+        break;
       }
-    });
-    enemyId++;
+    }
   }
 }
 
 
+
 export const makeTestWorld = generateWorld;

src/engine/world/pathfinding.ts

@@ -2,6 +2,7 @@ import type { World, Vec2 } from "../../core/types";
 import { key } from "../../core/utils";
 import { manhattan } from "../../core/math";
 import { inBounds, isWall, isBlocked, idx } from "./world-logic";
+import { type EntityManager } from "../EntityManager";
 
 /**
  * Simple 4-dir A* pathfinding.
@@ -11,14 +12,14 @@ import { inBounds, isWall, isBlocked, idx } from "./world-logic";
  * - You cannot path THROUGH unseen tiles.
  * - You cannot path TO an unseen target tile.
  */
-export function findPathAStar(w: World, seen: Uint8Array, start: Vec2, end: Vec2, options: { ignoreBlockedTarget?: boolean } = {}): Vec2[] {
+export function findPathAStar(w: World, seen: Uint8Array, start: Vec2, end: Vec2, options: { ignoreBlockedTarget?: boolean; ignoreSeen?: boolean; em?: EntityManager } = {}): Vec2[] {
   if (!inBounds(w, end.x, end.y)) return [];
   if (isWall(w, end.x, end.y)) return [];
   
   // If not ignoring target block, fail if blocked
-  if (!options.ignoreBlockedTarget && isBlocked(w, end.x, end.y)) return [];
+  if (!options.ignoreBlockedTarget && isBlocked(w, end.x, end.y, options.em)) return [];
   
-  if (seen[idx(w, end.x, end.y)] !== 1) return [];
+  if (!options.ignoreSeen && seen[idx(w, end.x, end.y)] !== 1) return [];
 
   const open: Vec2[] = [start];
   const cameFrom = new Map<string, string>();
@@ -76,12 +77,12 @@ export function findPathAStar(w: World, seen: Uint8Array, start: Vec2, end: Vec2
       if (!inBounds(w, nx, ny)) continue;
       if (isWall(w, nx, ny)) continue;
 
-      // Exploration rule: cannot path through unseen (except start)
-      if (!(nx === start.x && ny === start.y) && seen[idx(w, nx, ny)] !== 1) continue;
+      // Exploration rule: cannot path through unseen (except start, or if ignoreSeen is set)
+      if (!options.ignoreSeen && !(nx === start.x && ny === start.y) && seen[idx(w, nx, ny)] !== 1) continue;
 
       // Avoid walking through other actors (except standing on start, OR if it is the target and we ignore block)
       const isTarget = nx === end.x && ny === end.y;
-      if (!isTarget && !(nx === start.x && ny === start.y) && isBlocked(w, nx, ny)) continue;
+      if (!isTarget && !(nx === start.x && ny === start.y) && isBlocked(w, nx, ny, options.em)) continue;
 
       const nK = key(nx, ny);
       const tentativeG = (gScore.get(currentK) ?? Infinity) + 1;

src/engine/world/world-logic.ts

@@ -1,6 +1,8 @@
 import type { World, EntityId } from "../../core/types";
 import { GAME_CONFIG } from "../../core/config/GameConfig";
 
+import { type EntityManager } from "../EntityManager";
+
 export function inBounds(w: World, x: number, y: number): boolean {
   return x >= 0 && y >= 0 && x < w.width && y < w.height;
 }
@@ -14,10 +16,14 @@ export function isWall(w: World, x: number, y: number): boolean {
   return tile === GAME_CONFIG.terrain.wall || tile === GAME_CONFIG.terrain.wallDeco;
 }
 
-export function isBlocked(w: World, x: number, y: number): boolean {
+export function isBlocked(w: World, x: number, y: number, em?: EntityManager): boolean {
   if (!inBounds(w, x, y)) return true;
   if (isWall(w, x, y)) return true;
 
+  if (em) {
+    return em.isOccupied(x, y, "exp_orb");
+  }
+
   for (const a of w.actors.values()) {
     if (a.pos.x === x && a.pos.y === y && a.type !== "exp_orb") return true;
   }
@@ -25,6 +31,7 @@ export function isBlocked(w: World, x: number, y: number): boolean {
 }
 
 
+
 export function isPlayerOnExit(w: World, playerId: EntityId): boolean {
   const p = w.actors.get(playerId);
   if (!p) return false;