@loonylabs/create-game 0.1.0

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

@@ -0,0 +1,135 @@
+import { eq } from 'drizzle-orm';
+import type { Db } from './db/client.js';
+import { players as playersTable, items as itemsTable, inventories as inventoriesTable, equipped as equippedTable } from './db/schema.js';
+import type { PlayerState } from './gameState.js';
+import type { GameSession } from './gameState.js';
+import type { InventoryItem } from '@loonylabs/gamedev-protocol';
+
+export function toInventoryItems(inventory: Array<{ id: string; name: string; rarity: string; statBonus: Record<string, number> }>): InventoryItem[] {
+  return inventory.map((item, slot) => ({
+    id: item.id,
+    name: item.name,
+    rarity: item.rarity as 'common' | 'rare' | 'unique',
+    gridW: 1,
+    gridH: 1,
+    slot,
+    statBonus: item.statBonus,
+  }));
+}
+
+/**
+ * Load persisted player state from DB into the given PlayerState.
+ * Returns true if a saved state was found.
+ */
+export function loadPlayerState(db: Db, session: GameSession, player: PlayerState, playerId: string): boolean {
+  player.playerId = playerId;
+
+  const saved = db.select().from(playersTable).where(eq(playersTable.id, playerId)).get();
+  if (!saved) return false;
+
+  // Only restore position if it's walkable in the current area
+  if (session.isWalkable(saved.x, saved.y)) {
+    player.x = saved.x;
+    player.y = saved.y;
+  } else {
+    console.log(`[db] Saved position (${saved.x.toFixed(1)}, ${saved.y.toFixed(1)}) is not walkable, resetting to spawn`);
+  }
+  player.hp = saved.hp;
+
+  // Load inventory
+  const savedInventory = db
+    .select()
+    .from(inventoriesTable)
+    .where(eq(inventoriesTable.playerId, playerId))
+    .all();
+
+  player.inventory = [];
+  for (const row of savedInventory) {
+    const itemRow = db.select().from(itemsTable).where(eq(itemsTable.id, row.itemId)).get();
+    if (itemRow) {
+      player.inventory.push({
+        id: itemRow.id,
+        name: itemRow.name,
+        rarity: itemRow.rarity as 'common' | 'rare' | 'unique',
+        statBonus: JSON.parse(itemRow.statBonusJson),
+      });
+    }
+  }
+
+  // Load equipped items
+  const savedEquipped = db
+    .select()
+    .from(equippedTable)
+    .where(eq(equippedTable.playerId, playerId))
+    .all();
+
+  player.equipped = {};
+  for (const row of savedEquipped) {
+    const itemRow = db.select().from(itemsTable).where(eq(itemsTable.id, row.itemId)).get();
+    if (itemRow) {
+      player.equipped[row.slotId] = {
+        id: itemRow.id,
+        name: itemRow.name,
+        rarity: itemRow.rarity as 'common' | 'rare' | 'unique',
+        statBonus: JSON.parse(itemRow.statBonusJson),
+      };
+    }
+  }
+
+  console.log(`[db] Loaded player ${playerId} (hp:${player.hp}, items:${player.inventory.length}, equipped:${Object.keys(player.equipped).length})`);
+  return true;
+}
+
+/**
+ * Persist player state to DB on disconnect.
+ */
+export function savePlayerState(db: Db, player: PlayerState): void {
+  const pid = player.playerId;
+
+  db.insert(playersTable).values({
+    id: pid,
+    name: `Player_${player.entityId}`,
+    hp: player.hp,
+    x: player.x,
+    y: player.y,
+  }).onConflictDoUpdate({
+    target: playersTable.id,
+    set: { hp: player.hp, x: player.x, y: player.y },
+  }).run();
+
+  db.delete(inventoriesTable).where(eq(inventoriesTable.playerId, pid)).run();
+  player.inventory.forEach((item, slot) => {
+    db.insert(itemsTable).values({
+      id: item.id,
+      name: item.name,
+      rarity: item.rarity,
+      statBonusJson: JSON.stringify(item.statBonus),
+    }).onConflictDoNothing().run();
+
+    db.insert(inventoriesTable).values({
+      playerId: pid,
+      itemId: item.id,
+      slot,
+    }).run();
+  });
+
+  // Persist equipped items
+  db.delete(equippedTable).where(eq(equippedTable.playerId, pid)).run();
+  for (const [slotId, item] of Object.entries(player.equipped)) {
+    if (!item) continue;
+    db.insert(itemsTable).values({
+      id: item.id,
+      name: item.name,
+      rarity: item.rarity,
+      statBonusJson: JSON.stringify(item.statBonus),
+    }).onConflictDoNothing().run();
+
+    db.insert(equippedTable).values({
+      playerId: pid,
+      slotId,
+      itemId: item.id,
+    }).run();
+  }
+
+  console.log(`[db] Saved player ${pid} (hp:${player.hp}, items:${player.inventory.length}, equipped:${Object.keys(player.equipped).length})`);
+}

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

@@ -0,0 +1,20 @@
+import { loadRooms as genericLoadRooms } from '@loonylabs/gamedev-server';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { RoomDef } from '@loonylabs/gamedev-core';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOMS_DIR = resolve(__dirname, '../../game-data/src/rooms');
+
+const ROOM_FILES = [
+  'room_start.json',
+  'room_corridor_ew.json',
+  'room_corridor_ns.json',
+  'room_crossroads.json',
+  'room_dead_end.json',
+  'room_staircase.json',
+];
+
+export function loadRooms(): RoomDef[] {
+  return genericLoadRooms(ROOMS_DIR, ROOM_FILES);
+}

package/template/apps/server/src/systems/dungeonPhysics.test.ts

@@ -0,0 +1,32 @@
+import { describe, test, expect } from 'vitest';
+import { getDungeonGroundY } from './dungeonPhysics.js';
+import { DUNGEON_WALL_Y } from '../../../game-data/src/physics/dungeon-physics-config.js';
+import { GameSession } from '@loonylabs/gamedev-server';
+import { loadRooms } from '../rooms.js';
+
+describe('getDungeonGroundY', () => {
+  const rooms = loadRooms();
+  const session = new GameSession('test-dungeon', rooms, 42);
+
+  test('returns cell height for floor/spawn cells', () => {
+    const spawn = session.state.dungeon.spawnPosition;
+    const y = getDungeonGroundY(session, spawn.x, spawn.y);
+    // Spawn cell height matches grid cell.height (typically 0)
+    const cell = session.getCell(Math.round(spawn.x), Math.round(spawn.y));
+    expect(y).toBe(cell?.height ?? 0);
+  });
+
+  test('returns wall height for wall cells', () => {
+    const y = getDungeonGroundY(session, 0, 0);
+    expect(y).toBe(DUNGEON_WALL_Y);
+  });
+
+  test('returns wall height for out of bounds', () => {
+    const y = getDungeonGroundY(session, -100, -100);
+    expect(y).toBe(DUNGEON_WALL_Y);
+  });
+
+  test('wall height is significantly higher than floor', () => {
+    expect(DUNGEON_WALL_Y).toBeGreaterThanOrEqual(5);
+  });
+});

package/template/apps/server/src/systems/dungeonPhysics.ts

@@ -0,0 +1,16 @@
+import type { GameSession } from '@loonylabs/gamedev-server';
+import { DUNGEON_WALL_Y } from '../../../game-data/src/physics/dungeon-physics-config.js';
+
+/**
+ * Ground height lookup for dungeon grid.
+ * Floor/spawn cells -> cell.height (matches mesh geometry), walls -> tall barrier, OOB -> wall.
+ */
+export function getDungeonGroundY(session: GameSession, worldX: number, worldZ: number): number {
+  const cx = Math.round(worldX);
+  const cz = Math.round(worldZ);
+  const cell = session.getCell(cx, cz);
+
+  if (!cell) return DUNGEON_WALL_Y;
+  if (cell.type === 'wall' || cell.type === 'obstacle') return DUNGEON_WALL_Y;
+  return cell.height ?? 0;
+}

package/template/apps/server/src/systems/enemyAI.ts

@@ -0,0 +1,129 @@
+import { findPath, meleeAttack, aggregateStats } from '@loonylabs/gamedev-core';
+import type { GameSession, EnemyState, PlayerState } from '../gameState.js';
+
+const GRUNT_SPEED = 3; // cells/second
+const ATTACK_RANGE = 2; // cells
+const ATTACK_RETURN_RANGE = 4; // cells — return to patrol beyond this
+const ATTACK_INTERVAL = 1.5; // seconds between attacks
+const GRUNT_DAMAGE = 10;
+
+function dist(ax: number, ay: number, bx: number, by: number): number {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+export function updateEnemyAI(session: GameSession, dt: number): void {
+  // In voxel overworld (skipWalkCheck), use direct movement instead of grid pathfinding
+  const usePathfinding = !session.skipWalkCheck;
+
+  for (const enemy of session.state.enemies) {
+    if (!enemy.alive) continue;
+
+    // Find nearest player
+    let nearestPlayer: PlayerState | null = null;
+    let nearestDist = Infinity;
+    for (const player of session.state.players.values()) {
+      const d = dist(enemy.x, enemy.y, player.x, player.y);
+      if (d < nearestDist) {
+        nearestDist = d;
+        nearestPlayer = player;
+      }
+    }
+
+    if (enemy.aiState === 'idle') continue;
+
+    // In grid-based areas, enemies use pathfinding. In voxel areas (skipWalkCheck),
+    // enemies use direct waypoint movement — no basecamp safe zone check needed
+    // since enemies are only spawned on wilderness tiles.
+
+    if (nearestPlayer && nearestDist <= ATTACK_RANGE) {
+      // Attack state
+      enemy.aiState = 'attack';
+      enemy.path = [];
+
+      enemy.attackCooldown -= dt;
+      if (enemy.attackCooldown <= 0) {
+        enemy.attackCooldown = ATTACK_INTERVAL;
+        const results = meleeAttack(
+          { x: enemy.x, y: enemy.y },
+          [{ entityId: nearestPlayer.entityId, x: nearestPlayer.x, y: nearestPlayer.y, health: nearestPlayer.hp }],
+          ATTACK_RANGE,
+          GRUNT_DAMAGE,
+        );
+        const playerStats = aggregateStats(nearestPlayer.equipped);
+        for (const result of results) {
+          if (result.hit) {
+            const actualDamage = Math.max(1, result.damage - (playerStats.defense ?? 0));
+            nearestPlayer.hp -= actualDamage;
+            console.log(`[AI] Enemy ${enemy.entityId} (${enemy.enemyDefId}) attacks player ${result.targetId} for ${actualDamage} dmg (hp: ${nearestPlayer.hp})`);
+            if (nearestPlayer.hp <= 0) {
+              // Respawn player at spawn with 50% HP
+              nearestPlayer.hp = Math.ceil(nearestPlayer.maxHp / 2);
+              nearestPlayer.x = session.state.dungeon.spawnPosition.x;
+              nearestPlayer.y = session.state.dungeon.spawnPosition.y;
+              nearestPlayer.path = [];
+              console.log(`[AI] Player ${result.targetId} died — respawning at spawn`);
+            }
+          }
+        }
+      }
+    } else if (nearestPlayer && nearestDist <= ATTACK_RETURN_RANGE && enemy.aiState === 'attack') {
+      // Stay in attack state, move toward player
+      if (enemy.path.length === 0) {
+        if (usePathfinding) {
+          const path = findPath(session.state.dungeon, { x: enemy.x, y: enemy.y }, { x: nearestPlayer.x, y: nearestPlayer.y });
+          if (path && path.length > 0) enemy.path = path;
+        } else {
+          // Direct movement toward player
+          enemy.path = [{ x: nearestPlayer.x, y: nearestPlayer.y }];
+        }
+      }
+      moveAlongPath(enemy, dt, GRUNT_SPEED);
+    } else {
+      // Patrol state
+      if (enemy.aiState === 'attack' && nearestDist > ATTACK_RETURN_RANGE) {
+        enemy.aiState = 'patrol';
+        enemy.path = [];
+      }
+
+      if (enemy.path.length === 0) {
+        const target = enemy.aiState === 'patrol'
+          ? enemy.waypointIndex === 0 ? enemy.waypoints[1] : enemy.waypoints[0]
+          : enemy.waypoints[enemy.waypointIndex];
+        enemy.waypointIndex = enemy.waypointIndex === 0 ? 1 : 0;
+        if (usePathfinding) {
+          const path = findPath(session.state.dungeon, { x: enemy.x, y: enemy.y }, target);
+          if (path && path.length > 0) enemy.path = path;
+        } else {
+          enemy.path = [target];
+        }
+      }
+
+      moveAlongPath(enemy, dt, GRUNT_SPEED);
+    }
+  }
+}
+
+function moveAlongPath(entity: { x: number; y: number; path: Array<{ x: number; y: number }> }, dt: number, speed: number): void {
+  let remaining = speed * dt;
+
+  while (remaining > 0 && entity.path.length > 0) {
+    const next = entity.path[0];
+    const dx = next.x - entity.x;
+    const dy = next.y - entity.y;
+    const d = Math.sqrt(dx * dx + dy * dy);
+
+    if (d <= remaining) {
+      entity.x = next.x;
+      entity.y = next.y;
+      entity.path.shift();
+      remaining -= d;
+    } else {
+      const ratio = remaining / d;
+      entity.x += dx * ratio;
+      entity.y += dy * ratio;
+      remaining = 0;
+    }
+  }
+}

package/template/apps/server/src/systems/itemPickup.ts

@@ -0,0 +1,31 @@
+import type { GameSession, WorldItem } from '../gameState.js';
+
+const PICKUP_RANGE = 0.5; // cells
+
+function dist(ax: number, ay: number, bx: number, by: number): number {
+  const dx = ax - bx;
+  const dy = ay - by;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+export function updateItemPickup(session: GameSession): void {
+  for (const player of session.state.players.values()) {
+    const toRemove: WorldItem[] = [];
+
+    for (const worldItem of session.state.worldItems) {
+      if (dist(player.x, player.y, worldItem.x, worldItem.y) <= PICKUP_RANGE) {
+        toRemove.push(worldItem);
+        player.inventory.push(worldItem.item);
+        console.log(`[pickup] Player ${player.entityId} picked up "${worldItem.item.name}"`);
+      }
+    }
+
+    if (toRemove.length > 0) {
+      for (const item of toRemove) {
+        const idx = session.state.worldItems.indexOf(item);
+        if (idx >= 0) session.state.worldItems.splice(idx, 1);
+      }
+      session.onItemPickup?.(player.socketId, player.inventory);
+    }
+  }
+}

package/template/apps/server/src/tests/areaManager.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { AreaManager } from '../areaManager.js';
+import { loadRooms } from '../rooms.js';
+import { TILE_SIZE } from '../../../game-data/src/world/overworld-layout.js';
+
+describe('AreaManager', () => {
+  const rooms = loadRooms();
+  const manager = new AreaManager(rooms, 42);
+
+  it('creates overworld area with voxel type', () => {
+    const ow = manager.getAreaSession('overworld');
+    expect(ow).toBeDefined();
+    expect(ow!.areaType).toBe('voxel');
+    expect(ow!.chunkCache).toBeDefined();
+  });
+
+  it('does not create old ow1/ow2/sandbox areas', () => {
+    expect(manager.getAreaSession('ow1')).toBeUndefined();
+    expect(manager.getAreaSession('ow2')).toBeUndefined();
+    expect(manager.getAreaSession('voxel-sandbox')).toBeUndefined();
+  });
+
+  it('creates dungeon area', () => {
+    const dungeon = manager.getAreaSession('dungeon');
+    expect(dungeon).toBeDefined();
+    expect(dungeon!.areaType).toBe('dungeon');
+  });
+
+  it('overworld has spawn position in basecamp area', () => {
+    const session = manager.getSession('overworld')!;
+    const spawn = session.state.dungeon.spawnPosition;
+    expect(spawn).toBeDefined();
+    // Basecamp tiles are at cols 1-2, row 1 in the layout
+    // Center should be around (1.5+0.5)*32 = 64, (1+0.5)*32 = 48
+    expect(spawn.x).toBeGreaterThan(0);
+    expect(spawn.y).toBeGreaterThan(0);
+  });
+
+  it('addPlayerToArea registers player in overworld', () => {
+    const player = manager.addPlayerToArea('socket-1', 'player-1', 'overworld');
+    expect(player).toBeDefined();
+    expect(player.socketId).toBe('socket-1');
+    expect(manager.getPlayerArea('socket-1')).toBe('overworld');
+  });
+
+  it('removePlayerFromArea cleans up', () => {
+    manager.addPlayerToArea('socket-2', 'player-2', 'dungeon');
+    expect(manager.getPlayerArea('socket-2')).toBe('dungeon');
+    manager.removePlayerFromArea('socket-2');
+    expect(manager.getPlayerArea('socket-2')).toBe('overworld'); // default fallback
+  });
+
+  it('spawns enemies only on wilderness tiles', () => {
+    const session = manager.getSession('overworld')!;
+    const layout = manager.layout;
+    expect(session.state.enemies.length).toBeGreaterThan(0);
+
+    for (const enemy of session.state.enemies) {
+      const col = Math.floor(enemy.x / TILE_SIZE);
+      const row = Math.floor(enemy.y / TILE_SIZE);
+      const tile = layout.tiles[row]?.[col];
+      expect(tile).toBeDefined();
+      expect(tile.def.spawnsMobs).toBe(true);
+    }
+  });
+
+  it('dungeon session spawns enemies', () => {
+    const session = manager.getSession('dungeon')!;
+    expect(Array.isArray(session.state.enemies)).toBe(true);
+  });
+
+  it('getDungeonEntrancePos returns valid position', () => {
+    const pos = manager.getDungeonEntrancePos();
+    expect(pos.x).toBeGreaterThan(0);
+    expect(pos.z).toBeGreaterThan(0);
+  });
+});

package/template/apps/server/src/tests/diablo-experience.test.ts

@@ -0,0 +1,60 @@
+import { describe, test, expect } from 'vitest';
+import { DiabloExperience, createDiabloAreaSystems } from '../../../experiences/diablo/index.js';
+
+describe('DiabloExperience', () => {
+  test('implements ExperienceDefinition with correct metadata', () => {
+    const exp = new DiabloExperience();
+    expect(exp.id).toBe('diablo');
+    expect(exp.name).toContain('Diablo');
+    expect(exp.description).toBeTruthy();
+    expect(exp.defaultCameraMode).toBe('orbit');
+    expect(exp.physicsConfig).toBeDefined();
+  });
+
+  test('createSystems returns empty (systems created per-area)', () => {
+    const exp = new DiabloExperience();
+    expect(exp.createSystems()).toHaveLength(0);
+  });
+});
+
+describe('createDiabloAreaSystems', () => {
+  test('creates 7 systems for a dungeon area', () => {
+    // Minimal mock area session
+    const mockAreaSession = { session: {}, areaType: 'dungeon' as const };
+    const mockAreaManager = { layout: { tiles: [] } } as any;
+    const systems = createDiabloAreaSystems({
+      areaId: 'dungeon',
+      areaSession: mockAreaSession as any,
+      areaManager: mockAreaManager,
+      physicsConfig: { gravity: -20, terminalVelocity: -50, groundSnapThreshold: 0.3 },
+      jumpConfig: { jumpVelocity: 10, coyoteTime: 0.1, jumpBuffer: 0.1, allowDoubleJump: false },
+      transitions: [],
+    });
+    expect(systems).toHaveLength(7);
+    const ids = systems.map(s => s.id);
+    expect(new Set(ids).size).toBe(ids.length); // all unique
+    expect(ids).toContain('diablo-movement');
+    expect(ids).toContain('diablo-enemy-ai');
+    expect(ids).toContain('diablo-item-pickup');
+    expect(ids).toContain('diablo-physics');
+    expect(ids).toContain('diablo-transition');
+    expect(ids).toContain('diablo-dungeon-clear');
+    expect(ids).toContain('diablo-entity-sync');
+  });
+
+  test('systems have unique ids for voxel area too', () => {
+    const mockAreaSession = { session: {}, areaType: 'voxel' as const };
+    const mockAreaManager = { layout: { tiles: [] } } as any;
+    const systems = createDiabloAreaSystems({
+      areaId: 'overworld',
+      areaSession: mockAreaSession as any,
+      areaManager: mockAreaManager,
+      physicsConfig: { gravity: -20, terminalVelocity: -50, groundSnapThreshold: 0.5 },
+      jumpConfig: { jumpVelocity: 10, coyoteTime: 0.1, jumpBuffer: 0.1, allowDoubleJump: false },
+      transitions: [{ tileType: 'D', targetArea: 'dungeon', spawnX: -1, spawnY: -1 }],
+    });
+    expect(systems).toHaveLength(7);
+    const ids = systems.map(s => s.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});