@loonylabs/create-game 0.1.0

package/template/apps/server/src/index.ts

@@ -0,0 +1,597 @@
+import { createGameServer, ExperienceManager, createExperienceGameLoop, createTickLoop } from '@loonylabs/gamedev-server';
+import { PlayerMoveSchema, PlayerMoveDirectSchema, ActionEventSchema, PlayerConnectSchema, CraftRequestSchema, EquipRequestSchema, UnequipRequestSchema, RequestNewDungeonSchema, ActionRaycastSchema, DebugSpawnSchema, UseSkillSchema, PlayerJumpSchema, ExperienceJoinSchema, ExperienceLeaveSchema, ShootIntentSchema, ReloadSchema, ShooterMoveSchema, ShooterJumpSchema, ShooterRestartSchema, RunnerInputSchema, RunnerRestartSchema } from '@loonylabs/gamedev-protocol';
+import { AreaManager } from './areaManager.js';
+import { loadRooms } from './rooms.js';
+import { db } from './db/client.js';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { handleMeleeAction } from './handlers/actionEvent.js';
+import { handleRaycastAction } from './handlers/raycastHandler.js';
+import { handleUseSkill } from './handlers/skillHandler.js';
+import { handleCraftRequest } from './handlers/craftHandler.js';
+import { handleEquipRequest, handleUnequipRequest } from './handlers/equipHandler.js';
+import { loadPlayerState, savePlayerState, toInventoryItems } from './persistence.js';
+import type { Recipe } from '@loonylabs/gamedev-core';
+import { normaliseSkillBook, tryJump, getTerrainHeight, createJumpState, createPhysicsBody } from '@loonylabs/gamedev-core';
+import type { SkillBook } from '@loonylabs/gamedev-core';
+import { voxelPhysicsRegistry } from './voxelPlayerState.js';
+import { GAME_JUMP_CONFIG } from '../../game-data/src/physics/jump-config.js';
+import { DiabloExperience, createDiabloAreaSystems } from '../../experiences/diablo/index.js';
+import { ShooterExperience, createShooterSession, addShooterPlayer, removeShooterPlayer } from '../../experiences/shooter/index.js';
+import { createWeaponState, DEFAULT_WEAPON_CONFIG } from '../../experiences/shooter/data/weapon-config.js';
+import { SANDBOX_PHYSICS_CONFIG } from '../../game-data/src/voxel/sandbox-terrain-config.js';
+import { DUNGEON_PHYSICS_CONFIG } from '../../game-data/src/physics/dungeon-physics-config.js';
+import { RunnerExperience, createRunnerSession, addRunnerPlayer, removeRunnerPlayer } from '../../experiences/runner/index.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const recipeBook: Recipe[] = JSON.parse(
+  readFileSync(resolve(__dirname, '../../game-data/src/recipes/recipe-book.json'), 'utf-8')
+);
+const skillBook: SkillBook = normaliseSkillBook(JSON.parse(
+  readFileSync(resolve(__dirname, '../../game-data/src/skills/skill-book.json'), 'utf-8')
+));
+
+const AREA_IDS = ['overworld', 'dungeon'] as const;
+
+export interface GameServer {
+  close(): Promise<void>;
+}
+
+export async function createServer(port: number, seed?: number): Promise<GameServer> {
+  const { io, addStopCallback, close } = await createGameServer({ port, cors: { origin: '*' } });
+
+  const rooms = loadRooms();
+  // db is initialized in ./db/client.ts as a singleton
+  const areaManager = new AreaManager(rooms, seed ?? Date.now());
+
+  // Register experiences
+  const experienceManager = new ExperienceManager();
+  experienceManager.register(new DiabloExperience());
+  experienceManager.register(new ShooterExperience());
+  experienceManager.register(new RunnerExperience());
+
+  // Shooter sessions — keyed by a session ID (one shared session for now)
+  const shooterSessions = new Map<string, ReturnType<typeof createShooterSession>>();
+  const playerShooterSession = new Map<string, string>(); // socketId -> sessionId
+  // Jump states for shooter players (not stored in ShooterPlayer to keep core pure)
+  const shooterJumpStates = new Map<string, ReturnType<typeof createJumpState>>();
+
+  // Runner sessions
+  const runnerSessions = new Map<string, ReturnType<typeof createRunnerSession>>();
+  const playerRunnerSession = new Map<string, string>(); // socketId -> sessionId
+
+  // Load area manifest for transitions
+  const areaManifest = JSON.parse(
+    readFileSync(resolve(__dirname, '../../game-data/src/areas/area-manifest.json'), 'utf-8')
+  );
+  const transitionsByArea = new Map<string, Array<{ cellType?: string; tileType?: string; targetArea: string; spawnX: number; spawnY: number; minX?: number; maxX?: number; minY?: number; maxY?: number }>>(
+    areaManifest.areas.map((a: { id: string; transitions: unknown[] }) => [a.id, a.transitions])
+  );
+
+  // Start game loops via experience system — one per area with extracted systems
+  for (const areaId of AREA_IDS) {
+    const areaSession = areaManager.getAreaSession(areaId);
+    if (!areaSession) continue;
+
+    const physicsConfig = areaSession.areaType === 'voxel' ? SANDBOX_PHYSICS_CONFIG : DUNGEON_PHYSICS_CONFIG;
+    const systems = createDiabloAreaSystems({
+      areaId,
+      areaSession,
+      areaManager,
+      physicsConfig,
+      jumpConfig: GAME_JUMP_CONFIG,
+      transitions: transitionsByArea.get(areaId) ?? [],
+    });
+
+    const stopLoop = createExperienceGameLoop(io, areaSession.session, systems, 'diablo');
+    addStopCallback(stopLoop);
+  }
+
+  // Wire pickup events for all sessions
+  const pickupHandler = (socketId: string, inventory: Array<{ id: string; name: string; rarity: string; statBonus: Record<string, number> }>) => {
+    const sock = io.sockets.sockets.get(socketId);
+    if (sock) sock.emit('message', { type: 'INVENTORY_UPDATE', items: toInventoryItems(inventory) });
+  };
+  for (const areaId of [...AREA_IDS]) {
+    const s = areaManager.getSession(areaId);
+    if (s) s.onItemPickup = pickupHandler;
+  }
+
+  // Convenience getter: current session for a socket
+  const getSession = (socketId: string) =>
+    areaManager.getSession(areaManager.getPlayerArea(socketId));
+
+  /** Join the Shooter experience. */
+  function joinShooterExperience(socket: import('socket.io').Socket) {
+    const sessionId = 'shooter-main';
+    let shooterSession = shooterSessions.get(sessionId);
+    if (!shooterSession) {
+      shooterSession = createShooterSession(Date.now());
+      shooterSessions.set(sessionId, shooterSession);
+
+      // Start the experience game loop with a lightweight GameSession wrapper
+      const shooterDef = experienceManager.getDefinition('shooter')!;
+      const systems = shooterDef.createSystems();
+
+      // Init all systems with the shooter session as the "session" object
+      for (const system of systems) {
+        system.init?.(shooterSession, { io, tick: 0, experienceId: 'shooter' });
+      }
+
+      // Start tick loop
+      let tick = 0;
+      const context = { io, tick: 0, experienceId: 'shooter' };
+      const stopLoop = createTickLoop(20, (dt: number) => {
+        tick++;
+        context.tick = tick;
+        for (const system of systems) {
+          system.update(shooterSession!, dt, context);
+        }
+      });
+      addStopCallback(stopLoop);
+    }
+
+    const player = addShooterPlayer(shooterSession, socket.id, socket.id);
+    playerShooterSession.set(socket.id, sessionId);
+    shooterJumpStates.set(socket.id, createJumpState());
+
+    socket.emit('message', {
+      type: 'EXPERIENCE_CHANGE',
+      experienceId: 'shooter',
+      experienceName: 'Shooter Arena',
+      cameraMode: 'third-person',
+      spawnX: player.body.x,
+      spawnY: player.body.z,
+      spawnZ: player.body.y,
+      localEntityId: player.entityId,
+      seed: shooterSession.arena.seed,
+      payload: {
+        arena: {
+          width: shooterSession.arena.width,
+          depth: shooterSession.arena.depth,
+          walls: shooterSession.arena.walls,
+          covers: shooterSession.arena.covers,
+          spawnPoints: shooterSession.arena.spawnPoints,
+        },
+      },
+    });
+
+    // Send initial weapon state so HUD has ammo info
+    socket.emit('message', {
+      type: 'WEAPON_STATE',
+      currentAmmo: player.weapon.currentAmmo,
+      maxAmmo: DEFAULT_WEAPON_CONFIG.maxAmmo,
+      isReloading: false,
+    });
+  }
+
+  /** Join the Runner experience. */
+  function joinRunnerExperience(socket: import('socket.io').Socket) {
+    const sessionId = 'runner-main';
+    let runnerSession = runnerSessions.get(sessionId);
+    if (!runnerSession) {
+      runnerSession = createRunnerSession(Date.now());
+      runnerSessions.set(sessionId, runnerSession);
+
+      // Start the experience game loop
+      const runnerDef = experienceManager.getDefinition('runner')!;
+      const systems = runnerDef.createSystems();
+
+      for (const system of systems) {
+        system.init?.(runnerSession, { io, tick: 0, experienceId: 'runner' });
+      }
+
+      let tick = 0;
+      const context = { io, tick: 0, experienceId: 'runner' };
+      const stopLoop = createTickLoop(20, (dt: number) => {
+        tick++;
+        context.tick = tick;
+        for (const system of systems) {
+          system.update(runnerSession!, dt, context);
+        }
+      });
+      addStopCallback(stopLoop);
+    }
+
+    const player = addRunnerPlayer(runnerSession, socket.id, socket.id);
+    playerRunnerSession.set(socket.id, sessionId);
+
+    // Send track data in payload for client rendering
+    socket.emit('message', {
+      type: 'EXPERIENCE_CHANGE',
+      experienceId: 'runner',
+      experienceName: 'Infinity Runner',
+      cameraMode: 'follow',
+      spawnX: 0,
+      spawnY: 0,
+      spawnZ: 0,
+      localEntityId: player.entityId,
+      seed: runnerSession.seed,
+      payload: {
+        laneWidth: 2,
+        trackWidth: 6, // 3 lanes * 2 units
+      },
+    });
+  }
+
+  /** Join the Diablo experience (legacy path — used by EXPERIENCE_JOIN and kept for now). */
+  function joinDiabloExperience(socket: import('socket.io').Socket) {
+    const player = areaManager.addPlayerToArea(socket.id, socket.id, 'overworld');
+    const session = areaManager.getSession('overworld')!;
+
+    socket.emit('message', {
+      type: 'EXPERIENCE_CHANGE',
+      experienceId: 'diablo',
+      experienceName: 'Diablo — Overworld & Dungeon',
+      cameraMode: 'orbit',
+      spawnX: session.state.dungeon.spawnPosition.x,
+      spawnY: session.state.dungeon.spawnPosition.y,
+      localEntityId: player.entityId,
+      seed: session.state.dungeon.seed,
+      payload: { voxelConfig: { terrainOptions: null, tileLayout: true }, targetArea: 'overworld' },
+    });
+
+    // Also send legacy AREA_CHANGE for backward compatibility
+    socket.emit('message', {
+      type: 'AREA_CHANGE',
+      targetArea: 'overworld',
+      spawnX: session.state.dungeon.spawnPosition.x,
+      spawnY: session.state.dungeon.spawnPosition.y,
+      localEntityId: player.entityId,
+      seed: session.state.dungeon.seed,
+      voxelConfig: { terrainOptions: null, tileLayout: true },
+    });
+  }
+
+  io.on('connection', (socket) => {
+    console.log(`[server] connect: ${socket.id}`);
+
+    // Send experience list — player starts in hub
+    socket.emit('message', {
+      type: 'EXPERIENCE_LIST',
+      experiences: experienceManager.getAvailableExperiences(),
+    });
+
+    let persistedPlayerId: string | null = null;
+    const getCurrentPlayer = () => getSession(socket.id)?.state.players.get(socket.id);
+
+    socket.on('message', (data: unknown) => {
+      // EXPERIENCE_JOIN — join an experience from hub
+      const joinResult = ExperienceJoinSchema.safeParse(data);
+      if (joinResult.success) {
+        const { experienceId } = joinResult.data;
+        if (experienceId === 'diablo') {
+          joinDiabloExperience(socket);
+          // Load persisted state if we have a playerId
+          if (persistedPlayerId) {
+            const p = getCurrentPlayer();
+            const sess = getSession(socket.id);
+            if (p && sess) {
+              loadPlayerState(db, sess, p, persistedPlayerId);
+              socket.emit('message', {
+                type: 'INVENTORY_UPDATE',
+                items: toInventoryItems(p.inventory),
+              });
+              socket.emit('message', {
+                type: 'EQUIPMENT_UPDATE',
+                equipped: Object.fromEntries(
+                  Object.entries(p.equipped).map(([slotId, item]) => [slotId, {
+                    id: item!.id, name: item!.name, rarity: item!.rarity, gridW: 1, gridH: 1, slot: 0, statBonus: item!.statBonus,
+                  }])
+                ),
+              });
+            }
+          }
+        } else if (experienceId === 'shooter') {
+          joinShooterExperience(socket);
+        } else if (experienceId === 'runner') {
+          joinRunnerExperience(socket);
+        } else {
+          console.warn(`[server] Unknown experience: ${experienceId}`);
+        }
+        return;
+      }
+
+      // EXPERIENCE_LEAVE — return to hub
+      const leaveResult = ExperienceLeaveSchema.safeParse(data);
+      if (leaveResult.success) {
+        const p = getCurrentPlayer();
+        if (p) savePlayerState(db, p);
+        areaManager.removePlayerFromArea(socket.id);
+        // Also clean up shooter session if player was in shooter
+        const shooterSessId = playerShooterSession.get(socket.id);
+        if (shooterSessId) {
+          const ss = shooterSessions.get(shooterSessId);
+          if (ss) removeShooterPlayer(ss, socket.id);
+          playerShooterSession.delete(socket.id);
+          shooterJumpStates.delete(socket.id);
+        }
+        // Clean up runner session if player was in runner
+        const runnerSessId = playerRunnerSession.get(socket.id);
+        if (runnerSessId) {
+          const rs = runnerSessions.get(runnerSessId);
+          if (rs) removeRunnerPlayer(rs, socket.id);
+          playerRunnerSession.delete(socket.id);
+        }
+        // Re-send experience list so hub is populated
+        socket.emit('message', {
+          type: 'EXPERIENCE_LIST',
+          experiences: experienceManager.getAvailableExperiences(),
+        });
+        return;
+      }
+
+      // --- Shooter-specific messages ---
+      const shooterSessId = playerShooterSession.get(socket.id);
+      if (shooterSessId) {
+        const ss = shooterSessions.get(shooterSessId);
+        if (ss) {
+          const sp = ss.players.get(socket.id);
+          if (sp) {
+            const shootResult = ShootIntentSchema.safeParse(data);
+            if (shootResult.success) {
+              sp.shootQueue.push({
+                origin: { x: shootResult.data.originX, y: shootResult.data.originY, z: shootResult.data.originZ },
+                direction: { x: shootResult.data.dirX, y: shootResult.data.dirY, z: shootResult.data.dirZ },
+              });
+              return;
+            }
+
+            const reloadResult = ReloadSchema.safeParse(data);
+            if (reloadResult.success) {
+              sp.wantsReload = true;
+              return;
+            }
+
+            const moveResult = ShooterMoveSchema.safeParse(data);
+            if (moveResult.success) {
+              sp.input.x = moveResult.data.x;
+              sp.input.z = moveResult.data.z;
+              sp.input.sprint = moveResult.data.sprint;
+              sp.facingAngle = moveResult.data.facingAngle;
+              return;
+            }
+
+            const jumpResult = ShooterJumpSchema.safeParse(data);
+            if (jumpResult.success) {
+              const jumpState = shooterJumpStates.get(socket.id);
+              if (jumpState) {
+                tryJump(sp.body, jumpState, { jumpVelocity: 8, coyoteTime: 0.1, maxJumps: 2, jumpBufferTime: 0.1 });
+              }
+              return;
+            }
+
+            const restartResult = ShooterRestartSchema.safeParse(data);
+            if (restartResult.success) {
+              // Reset player state
+              const spawnIdx = 0;
+              const spawn = ss.arena.spawnPoints[spawnIdx];
+              sp.hp = sp.maxHp;
+              sp.body = createPhysicsBody(spawn.x, spawn.y, spawn.z);
+              sp.weapon = createWeaponState(DEFAULT_WEAPON_CONFIG);
+              sp.shootQueue = [];
+              sp.wantsReload = false;
+              sp.input = { x: 0, z: 0, sprint: false, glide: false };
+
+              // Reset wave state
+              ss.enemies = [];
+              ss.waveState = { currentWave: 0, waveActive: false, delayTimer: 2 };
+
+              // Reset jump state
+              shooterJumpStates.set(socket.id, createJumpState());
+
+              socket.emit('message', {
+                type: 'SHOOTER_RESTARTED',
+                hp: sp.hp,
+                maxHp: sp.maxHp,
+                maxAmmo: DEFAULT_WEAPON_CONFIG.maxAmmo,
+              });
+              return;
+            }
+          }
+        }
+      }
+
+      // --- Runner-specific messages ---
+      const runnerSessId = playerRunnerSession.get(socket.id);
+      if (runnerSessId) {
+        const rs = runnerSessions.get(runnerSessId);
+        if (rs) {
+          const rp = rs.players.get(socket.id);
+          if (rp) {
+            const inputResult = RunnerInputSchema.safeParse(data);
+            if (inputResult.success) {
+              if (inputResult.data.left) rp.input.left = true;
+              if (inputResult.data.right) rp.input.right = true;
+              if (inputResult.data.jump) rp.input.jump = true;
+              rp.input.glide = inputResult.data.glide;
+              return;
+            }
+
+            const restartResult = RunnerRestartSchema.safeParse(data);
+            if (restartResult.success) {
+              // Reset player state
+              rp.body = createPhysicsBody(0, 0, 0);
+              rp.jumpState = createJumpState();
+              rp.lane = { currentLane: 0, targetLane: 0, laneOffset: 0, switchTimer: 0 };
+              rp.track = { seed: rs.seed, nextZ: 0, nextIndex: 0, segments: [], nextItemId: 1 };
+              rp.distanceRan = 0;
+              rp.isGliding = false;
+              rp.dead = false;
+              rp.input = { left: false, right: false, jump: false, glide: false };
+              rp.score = 0;
+              rp.coins = 0;
+              rp.gems = 0;
+              rp.bestCombo = 0;
+              rp.combo = { count: 0, timer: 0 };
+              rp.modifiers = [];
+              rp.magnetActive = false;
+              rp.magnetTimer = 0;
+              rp.gravityModifier = null;
+              rp.nextItemId = 1;
+
+              socket.emit('message', { type: 'RUNNER_RESTARTED' });
+              return;
+            }
+          }
+        }
+      }
+
+      const sess = getSession(socket.id);
+
+      // PLAYER_CONNECT — store playerId for later use (state loaded on experience join)
+      const connectResult = PlayerConnectSchema.safeParse(data);
+      if (connectResult.success) {
+        persistedPlayerId = connectResult.data.playerId;
+        // If player is already in an experience, load state now
+        const p = getCurrentPlayer();
+        if (p && sess) {
+          loadPlayerState(db, sess, p, persistedPlayerId);
+          socket.emit('message', {
+            type: 'INVENTORY_UPDATE',
+            items: toInventoryItems(p.inventory),
+          });
+          socket.emit('message', {
+            type: 'EQUIPMENT_UPDATE',
+            equipped: Object.fromEntries(
+              Object.entries(p.equipped).map(([slotId, item]) => [slotId, {
+                id: item!.id, name: item!.name, rarity: item!.rarity, gridW: 1, gridH: 1, slot: 0, statBonus: item!.statBonus,
+              }])
+            ),
+          });
+        }
+        return;
+      }
+
+      if (!sess) return;
+
+      const regenResult = RequestNewDungeonSchema.safeParse(data);
+      if (regenResult.success) {
+        const dungeonSess = areaManager.getSession('dungeon');
+        if (dungeonSess) {
+          console.log(`[server] regenerating dungeon (seed: ${regenResult.data.seed ?? 'random'})`);
+          dungeonSess.regenerateDungeon(rooms, regenResult.data.seed);
+          areaManager.spawnInitialDungeonEnemies(dungeonSess);
+          io.emit('message', {
+            type: 'WORLD_STATE',
+            dungeon: dungeonSess.state.dungeon,
+            spawnPosition: dungeonSess.state.dungeon.spawnPosition,
+          });
+        }
+        return;
+      }
+
+      const moveResult = PlayerMoveSchema.safeParse(data);
+      if (moveResult.success) { sess.setPlayerTarget(socket.id, moveResult.data.targetX, moveResult.data.targetY); return; }
+
+      const moveDirectResult = PlayerMoveDirectSchema.safeParse(data);
+      if (moveDirectResult.success) { sess.setPlayerPositionDirect(socket.id, moveDirectResult.data.x, moveDirectResult.data.y, moveDirectResult.data.inputId); return; }
+
+      const actionResult = ActionEventSchema.safeParse(data);
+      if (actionResult.success && actionResult.data.action === 'melee') { handleMeleeAction(sess, socket.id); return; }
+
+      const raycastResult = ActionRaycastSchema.safeParse(data);
+      if (raycastResult.success) {
+        const playerArea = areaManager.getPlayerArea(socket.id);
+        const areaSess = areaManager.getAreaSession(playerArea);
+        const groundYFn = areaSess?.chunkCache
+          ? (x: number, z: number) => getTerrainHeight(areaSess.chunkCache!.getChunkFn, x, z)
+          : undefined;
+        handleRaycastAction(sess, io, raycastResult.data.entityId, raycastResult.data.origin, raycastResult.data.direction, raycastResult.data.range, undefined, groundYFn);
+        return;
+      }
+
+      const useSkillResult = UseSkillSchema.safeParse(data);
+      if (useSkillResult.success) {
+        const playerArea2 = areaManager.getPlayerArea(socket.id);
+        const areaSess2 = areaManager.getAreaSession(playerArea2);
+        const groundYFn2 = areaSess2?.chunkCache
+          ? (x: number, z: number) => getTerrainHeight(areaSess2.chunkCache!.getChunkFn, x, z)
+          : undefined;
+        handleUseSkill(sess, io, socket.id, useSkillResult.data.skillId, skillBook, useSkillResult.data.origin, useSkillResult.data.direction, groundYFn2);
+        return;
+      }
+
+      const craftResult = CraftRequestSchema.safeParse(data);
+      if (craftResult.success) { handleCraftRequest(sess, socket, craftResult.data.grid, recipeBook); return; }
+
+      const equipResult = EquipRequestSchema.safeParse(data);
+      if (equipResult.success) { handleEquipRequest(sess, socket, equipResult.data.slotId, equipResult.data.itemId); return; }
+
+      const unequipResult = UnequipRequestSchema.safeParse(data);
+      if (unequipResult.success) { handleUnequipRequest(sess, socket, unequipResult.data.slotId); return; }
+
+      const jumpResult = PlayerJumpSchema.safeParse(data);
+      if (jumpResult.success) {
+        const playerArea = areaManager.getPlayerArea(socket.id);
+        const physicsMap = voxelPhysicsRegistry.get(playerArea);
+        const physics = physicsMap?.get(socket.id);
+        if (physics) {
+          tryJump(physics.body, physics.jumpState, GAME_JUMP_CONFIG);
+        }
+        return;
+      }
+
+      if (process.env.NODE_ENV !== 'production') {
+        const debugTeleportResult = (data as any)?.type === 'DEBUG_TELEPORT' && typeof (data as any)?.targetArea === 'string';
+        if (debugTeleportResult) {
+          const { targetArea } = data as { type: string; targetArea: string };
+          // Overworld: spawn at basecamp, dungeon: use natural spawn
+          const spawnLookup: Record<string, { x: number; y: number }> = {
+            overworld: { x: -1, y: -1 },
+            dungeon: { x: -1, y: -1 },
+          };
+          areaManager.movePlayer(io, socket.id, targetArea, spawnLookup[targetArea]?.x ?? -1, spawnLookup[targetArea]?.y ?? -1);
+          console.log(`[server] DEBUG_TELEPORT ${socket.id} → ${targetArea}`);
+          return;
+        }
+
+        const debugSpawnResult = DebugSpawnSchema.safeParse(data);
+        if (debugSpawnResult.success) {
+          const { x, y } = debugSpawnResult.data;
+          const grunt = sess.spawnEnemy({ enemyDefId: 'grunt', x, y, hp: 50, maxHp: 50, alive: true, aiState: 'idle', waypoints: [{ x, y }, { x, y }], waypointIndex: 0, path: [], attackCooldown: 0 });
+          console.log(`[server] DEBUG_SPAWN grunt #${grunt.entityId} at (${x}, ${y})`);
+          return;
+        }
+      }
+
+      console.log(`[server] Unhandled message type: ${(data as any)?.type}, action: ${(data as any)?.action}`);
+    });
+
+    socket.on('disconnect', () => {
+      const p = getCurrentPlayer();
+      if (p) {
+        console.log(`[server] disconnect: ${socket.id} (entity ${p.entityId})`);
+        savePlayerState(db, p);
+      }
+      areaManager.removePlayerFromArea(socket.id);
+      // Clean up shooter session
+      const shooterSessId2 = playerShooterSession.get(socket.id);
+      if (shooterSessId2) {
+        const ss2 = shooterSessions.get(shooterSessId2);
+        if (ss2) removeShooterPlayer(ss2, socket.id);
+        playerShooterSession.delete(socket.id);
+        shooterJumpStates.delete(socket.id);
+      }
+      // Clean up runner session
+      const runnerSessId2 = playerRunnerSession.get(socket.id);
+      if (runnerSessId2) {
+        const rs2 = runnerSessions.get(runnerSessId2);
+        if (rs2) removeRunnerPlayer(rs2, socket.id);
+        playerRunnerSession.delete(socket.id);
+      }
+    });
+  });
+
+  return { close };
+}
+
+// Run as standalone if invoked directly
+const isMain = process.argv[1]?.endsWith('index.ts') || process.argv[1]?.endsWith('index.js');
+if (isMain) {
+  const PORT = Number(process.env.PORT ?? 3000);
+  createServer(PORT).then(() => {
+    console.log(`[server] running on port ${PORT}`);
+  });
+}