@loonylabs/create-game 0.1.0

package/template/apps/game-data/src/rooms/room_basecamp.json

@@ -0,0 +1,16 @@
+{
+  "id": "room_basecamp",
+  "ascii": [
+    "WWWWWWWWWWWWWWWWWWWWW",
+    "W...................W",
+    "W...................W",
+    "W.....NNNNN.........W",
+    "W..........S........W",
+    "W....SSSSSSSSS......W",
+    "W.........F.........W",
+    "W...................W",
+    "W...................W",
+    "WWWWWWWWWWW>WWWWWWWWW"
+  ],
+  "tags": ["basecamp", "safe"]
+}

package/template/apps/game-data/src/rooms/room_corridor_ew.json

@@ -0,0 +1,9 @@
+{
+  "id": "room_corridor_ew",
+  "ascii": [
+    "WWWWW",
+    "D...D",
+    "WWWWW"
+  ],
+  "tags": ["standard", "corridor"]
+}

package/template/apps/game-data/src/rooms/room_corridor_ns.json

@@ -0,0 +1,11 @@
+{
+  "id": "room_corridor_ns",
+  "ascii": [
+    "WWDWW",
+    "W...W",
+    "W...W",
+    "W...W",
+    "WWDWW"
+  ],
+  "tags": ["standard", "corridor"]
+}

package/template/apps/game-data/src/rooms/room_crossroads.json

@@ -0,0 +1,11 @@
+{
+  "id": "room_crossroads",
+  "ascii": [
+    "WWDWW",
+    "W...W",
+    "D...D",
+    "W...W",
+    "WWDWW"
+  ],
+  "tags": ["standard"]
+}

package/template/apps/game-data/src/rooms/room_dead_end.json

@@ -0,0 +1,10 @@
+{
+  "id": "room_dead_end",
+  "ascii": [
+    "WWWWWW",
+    "D....W",
+    "W....W",
+    "WWWWWW"
+  ],
+  "tags": ["dead_end"]
+}

package/template/apps/game-data/src/rooms/room_staircase.json

@@ -0,0 +1,12 @@
+{
+  "id": "room_staircase",
+  "ascii": [
+    "WWWWWWWWW",
+    "W.......W",
+    "W....1..W",
+    "W...222.W",
+    "D...222.W",
+    "WWWWWWWWW"
+  ],
+  "tags": ["staircase"]
+}

package/template/apps/game-data/src/rooms/room_start.json

@@ -0,0 +1,11 @@
+{
+  "id": "room_start",
+  "ascii": [
+    "WWWWWWWW",
+    "W......W",
+    "W..S...W",
+    "W......D",
+    "WWWWWWWW"
+  ],
+  "tags": ["start"]
+}

package/template/apps/game-data/src/skills/skill-book.json

@@ -0,0 +1,20 @@
+{
+  "basic-shot": {
+    "name": "Basic Shot",
+    "actionType": "raycast",
+    "cooldown": 500,
+    "stats": { "damage": 10, "range": 20 }
+  },
+  "heavy-slam": {
+    "name": "Heavy Slam",
+    "actionType": "melee",
+    "cooldown": 3000,
+    "stats": { "damage": 40, "range": 3 }
+  },
+  "burst-heal": {
+    "name": "Burst Heal",
+    "actionType": "self_heal",
+    "cooldown": 15000,
+    "stats": { "value": 30 }
+  }
+}

package/template/apps/game-data/src/voxel/biome-terrain.ts

@@ -0,0 +1,76 @@
+import type { VoxelTerrainOptions } from '@loonylabs/gamedev-core';
+import { VOXEL_MATERIALS } from './materials.js';
+
+/** Terrain generation presets per biome. */
+export const BIOME_TERRAIN_OPTIONS: Record<string, VoxelTerrainOptions> = {
+  plains: {
+    baseHeight: 32,
+    amplitude: 8,
+    frequency: 0.015,
+    octaves: 4,
+    caveThreshold: 0.2,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.GRASS, maxDepthBelowSurface: 2 },
+      { material: VOXEL_MATERIALS.DIRT,  maxDepthBelowSurface: 6 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+  basecamp: {
+    baseHeight: 34,
+    amplitude: 1,
+    frequency: 0.005,
+    octaves: 2,
+    caveThreshold: 0,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.GRASS, maxDepthBelowSurface: 2 },
+      { material: VOXEL_MATERIALS.DIRT,  maxDepthBelowSurface: 6 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+  wall: {
+    baseHeight: 60,
+    amplitude: 15,
+    frequency: 0.03,
+    octaves: 5,
+    caveThreshold: 0,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.SNOW,  maxDepthBelowSurface: 0 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+  swamp: {
+    baseHeight: 30,
+    amplitude: 1.5,
+    frequency: 0.02,
+    octaves: 3,
+    caveThreshold: 0,
+    waterLevel: 31,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.DIRT,  maxDepthBelowSurface: 2 },
+      { material: VOXEL_MATERIALS.DIRT,  maxDepthBelowSurface: 5 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+  mountains: {
+    baseHeight: 40,
+    amplitude: 20,
+    frequency: 0.025,
+    octaves: 6,
+    caveThreshold: 0.4,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.SNOW,  maxDepthBelowSurface: 0 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+  desert: {
+    baseHeight: 30,
+    amplitude: 5,
+    frequency: 0.01,
+    octaves: 3,
+    caveThreshold: 0.1,
+    materialLayers: [
+      { material: VOXEL_MATERIALS.SAND,  maxDepthBelowSurface: 3 },
+      { material: VOXEL_MATERIALS.STONE, maxDepthBelowSurface: Infinity },
+    ],
+  },
+};

package/template/apps/game-data/src/voxel/materials.ts

@@ -0,0 +1,45 @@
+/** Voxel material indices — must match what the shader expects. */
+export const VOXEL_MATERIALS = {
+  AIR:   0,
+  GRASS: 1,
+  DIRT:  2,
+  STONE: 3,
+  SAND:  4,
+  SNOW:  5,
+  WATER: 6,
+} as const;
+
+export type VoxelMaterialName = keyof typeof VOXEL_MATERIALS;
+
+/** Visual properties per material (for the terrain shader). */
+export const VOXEL_MATERIAL_COLORS: Record<number, number> = {
+  [VOXEL_MATERIALS.GRASS]: 0x4a8c3f,
+  [VOXEL_MATERIALS.DIRT]:  0x8b6914,
+  [VOXEL_MATERIALS.STONE]: 0x808080,
+  [VOXEL_MATERIALS.SAND]:  0xc2b280,
+  [VOXEL_MATERIALS.SNOW]:  0xf0f0f0,
+  [VOXEL_MATERIALS.WATER]: 0x3366aa,
+};
+
+/** Extended visual properties for the procedural terrain shader. */
+export interface VoxelMaterialVisual {
+  color: [number, number, number]; // RGB 0-1
+  noiseScale: number;
+  noiseStrength: number;
+  noiseType: 'fbm' | 'cellular' | 'ridged';
+  fbmOctaves: number;      // 2-6
+  fbmLacunarity: number;   // frequency multiplier per octave (typically 2.0)
+  fbmGain: number;         // amplitude multiplier per octave (typically 0.5)
+  heightTintLow: [number, number, number];   // RGB offset at low altitude
+  heightTintHigh: [number, number, number];  // RGB offset at high altitude
+  bumpStrength: number;  // 0.0 (flat) to 1.0 (very bumpy) — controls normal perturbation
+}
+
+export const VOXEL_MATERIAL_VISUALS: Record<number, VoxelMaterialVisual> = {
+  [VOXEL_MATERIALS.GRASS]: { color: [0.29, 0.55, 0.25], noiseScale: 3.0,  noiseStrength: 0.45, noiseType: 'fbm',      fbmOctaves: 5, fbmLacunarity: 2.0, fbmGain: 0.5,  heightTintLow: [0.0, 0.03, 0.0],    heightTintHigh: [-0.06, 0.03, 0.02],  bumpStrength: 0.4 },
+  [VOXEL_MATERIALS.DIRT]:  { color: [0.55, 0.41, 0.08], noiseScale: 4.0,  noiseStrength: 0.50, noiseType: 'fbm',      fbmOctaves: 4, fbmLacunarity: 2.2, fbmGain: 0.45, heightTintLow: [-0.02, -0.01, 0.0], heightTintHigh: [0.03, 0.02, 0.01],   bumpStrength: 0.5 },
+  [VOXEL_MATERIALS.STONE]: { color: [0.50, 0.50, 0.50], noiseScale: 1.5,  noiseStrength: 0.50, noiseType: 'cellular', fbmOctaves: 3, fbmLacunarity: 2.0, fbmGain: 0.5,  heightTintLow: [-0.04, -0.02, 0.0], heightTintHigh: [0.06, 0.06, 0.06],   bumpStrength: 0.8 },
+  [VOXEL_MATERIALS.SAND]:  { color: [0.76, 0.70, 0.50], noiseScale: 2.0,  noiseStrength: 0.12, noiseType: 'fbm',      fbmOctaves: 2, fbmLacunarity: 2.0, fbmGain: 0.5,  heightTintLow: [0.0, 0.0, 0.0],     heightTintHigh: [0.02, 0.01, -0.02],  bumpStrength: 0.2 },
+  [VOXEL_MATERIALS.SNOW]:  { color: [0.94, 0.94, 0.94], noiseScale: 1.0,  noiseStrength: 0.06, noiseType: 'fbm',      fbmOctaves: 2, fbmLacunarity: 2.0, fbmGain: 0.5,  heightTintLow: [-0.02, -0.02, 0.0], heightTintHigh: [0.0, 0.0, 0.02],     bumpStrength: 0.1 },
+  [VOXEL_MATERIALS.WATER]: { color: [0.20, 0.40, 0.67], noiseScale: 0.8,  noiseStrength: 0.20, noiseType: 'ridged',   fbmOctaves: 3, fbmLacunarity: 2.0, fbmGain: 0.5,  heightTintLow: [0.0, 0.0, 0.0],     heightTintHigh: [0.0, 0.0, 0.0],      bumpStrength: 0.0 },
+};

package/template/apps/game-data/src/voxel/sandbox-terrain-config.ts

@@ -0,0 +1,19 @@
+import type { VoxelTerrainOptions } from '@loonylabs/gamedev-core';
+import type { PhysicsConfig } from '@loonylabs/gamedev-core';
+import { BIOME_TERRAIN_OPTIONS } from './biome-terrain.js';
+
+/** Terrain generation options for the voxel sandbox area. */
+export const SANDBOX_TERRAIN_OPTIONS: VoxelTerrainOptions = {
+  ...BIOME_TERRAIN_OPTIONS.plains,
+  caveThreshold: 0, // no caves for sandbox — keep it simple
+};
+
+/** Physics config for the voxel sandbox. */
+export const SANDBOX_PHYSICS_CONFIG: PhysicsConfig = {
+  gravity: -20,
+  terminalVelocity: -50,
+  groundSnapThreshold: 0.5,
+};
+
+/** Spawn position (world coordinates, center of chunk 0,0). */
+export const SANDBOX_SPAWN = { x: 16, z: 16 };

package/template/apps/game-data/src/world/area-config.ts

@@ -0,0 +1,33 @@
+import type { SafePoint, BorderConfig } from '@loonylabs/gamedev-core';
+
+/** Safe points per area — positions that must remain obstacle-free. */
+export const AREA_SAFE_POINTS: Record<string, SafePoint[]> = {
+  ow1: [{ wx: 2, wy: 5 }],   // OW1 basecamp spawn
+  ow2: [{ wx: 2, wy: 47 }],  // OW2 west-corridor spawn (zone 0,1 row 15 = world y 47)
+};
+
+/** Border configurations per area. */
+export const AREA_BORDER_CONFIGS: Record<string, BorderConfig> = {
+  ow1: {
+    gridSize: 3,
+    borderCellType: 'wall',
+    borderObstacleType: 'rock',
+    corridors: [{
+      edge: 'east',
+      zoneIndex: 1,      // ty === 1
+      cellPositions: [15, 16],
+      cellType: 'transition',
+    }],
+  },
+  ow2: {
+    gridSize: 3,
+    borderCellType: 'wall',
+    borderObstacleType: 'rock',
+    corridors: [{
+      edge: 'west',
+      zoneIndex: 1,
+      cellPositions: [15, 16],
+      cellType: 'transition',
+    }],
+  },
+};

package/template/apps/game-data/src/world/biome-def.ts

@@ -0,0 +1,15 @@
+/**
+ * Game-specific biome definition for the dungeon-crawler reference implementation.
+ * Extends core's minimal BiomeDef with rendering and gameplay fields.
+ */
+export interface GameBiomeDef {
+  id: string;
+  groundColor: string;   // CSS hex color for floor tiles
+  heightScale: number;   // max height generated by noise (0 = flat)
+  noiseFrequency: number; // noise input scale
+  fogColor: string;      // scene fog color
+  fogDensity: number;    // THREE.FogExp2 density
+  mobs: string[];        // mob type IDs spawnable in this biome
+  obstacleDensity: number; // probability (0.0 - 1.0) of a floor tile having an obstacle
+  obstacleTypes: string[]; // obstacle IDs spawnable in this biome
+}

package/template/apps/game-data/src/world/biomes.json

@@ -0,0 +1,57 @@
+{
+  "grasslands": {
+    "id": "grasslands",
+    "groundColor": "#3a5a1a",
+    "heightScale": 2.0,
+    "noiseFrequency": 0.05,
+    "fogColor": "#a0b080",
+    "fogDensity": 0.018,
+    "mobs": ["wolf", "bandit", "slime"],
+    "obstacleDensity": 0.12,
+    "obstacleTypes": ["tree", "rock", "bush"]
+  },
+  "mountains": {
+    "id": "mountains",
+    "groundColor": "#888888",
+    "heightScale": 8.0,
+    "noiseFrequency": 0.1,
+    "fogColor": "#d0d8e0",
+    "fogDensity": 0.025,
+    "mobs": ["harpy", "golem"],
+    "obstacleDensity": 0.08,
+    "obstacleTypes": ["rock"]
+  },
+  "dungeon": {
+    "id": "dungeon",
+    "groundColor": "#2a1a0a",
+    "heightScale": 0.0,
+    "noiseFrequency": 0.0,
+    "fogColor": "#110800",
+    "fogDensity": 0.04,
+    "mobs": ["grunt", "skeleton"],
+    "obstacleDensity": 0.0,
+    "obstacleTypes": []
+  },
+  "desert": {
+    "id": "desert",
+    "groundColor": "#c8a050",
+    "heightScale": 3.0,
+    "noiseFrequency": 0.04,
+    "fogColor": "#e8c880",
+    "fogDensity": 0.015,
+    "mobs": ["scorpion", "bandit"],
+    "obstacleDensity": 0.05,
+    "obstacleTypes": ["rock", "bush"]
+  },
+  "swamp": {
+    "id": "swamp",
+    "groundColor": "#1a2b1a",
+    "heightScale": 1.5,
+    "noiseFrequency": 0.08,
+    "fogColor": "#2a3a1a",
+    "fogDensity": 0.045,
+    "mobs": ["skeleton", "golem"],
+    "obstacleDensity": 0.18,
+    "obstacleTypes": ["dead_tree", "bog_stone"]
+  }
+}

package/template/apps/game-data/src/world/movement.ts

@@ -0,0 +1,2 @@
+/** Player movement speed in cells per second. */
+export const PLAYER_SPEED = 3;

package/template/apps/game-data/src/world/overworld-layout.test.ts

@@ -0,0 +1,93 @@
+import { describe, test, expect } from 'vitest';
+import {
+  parseOverworldLayout,
+  getTileAt,
+  getBiomeTerrainOptions,
+  OVERWORLD_ASCII,
+  TILE_LEGEND,
+} from './overworld-layout.js';
+
+describe('parseOverworldLayout', () => {
+  const layout = parseOverworldLayout();
+
+  test('parses correct dimensions', () => {
+    expect(layout.width).toBe(8);
+    expect(layout.height).toBe(6);
+  });
+
+  test('all tiles have valid definitions', () => {
+    for (const row of layout.tiles) {
+      for (const tile of row) {
+        expect(tile.def).toBeDefined();
+        expect(tile.def.biomeId).toBeTruthy();
+      }
+    }
+  });
+
+  test('corners are walls', () => {
+    expect(getTileAt(layout, 0, 0)?.def.type).toBe('W');
+    expect(getTileAt(layout, 7, 0)?.def.type).toBe('W');
+    expect(getTileAt(layout, 0, 5)?.def.type).toBe('W');
+    expect(getTileAt(layout, 7, 5)?.def.type).toBe('W');
+  });
+
+  test('basecamp tiles at expected position', () => {
+    expect(getTileAt(layout, 1, 1)?.def.type).toBe('B');
+    expect(getTileAt(layout, 2, 1)?.def.type).toBe('B');
+    expect(getTileAt(layout, 1, 1)?.def.biomeId).toBe('basecamp');
+  });
+
+  test('dungeon entrance exists', () => {
+    const dungeon = getTileAt(layout, 5, 4);
+    expect(dungeon?.def.type).toBe('D');
+    expect(dungeon?.def.biomeId).toBe('swamp');
+  });
+
+  test('passage tile exists', () => {
+    const passage = getTileAt(layout, 4, 1);
+    expect(passage?.def.type).toBe('T');
+  });
+
+  test('wilderness tiles spawn mobs', () => {
+    const grassTile = getTileAt(layout, 3, 2);
+    expect(grassTile?.def.spawnsMobs).toBe(true);
+  });
+
+  test('wall tiles do not spawn mobs', () => {
+    const wallTile = getTileAt(layout, 0, 0);
+    expect(wallTile?.def.spawnsMobs).toBe(false);
+  });
+
+  test('out of bounds returns undefined', () => {
+    expect(getTileAt(layout, -1, 0)).toBeUndefined();
+    expect(getTileAt(layout, 8, 0)).toBeUndefined();
+  });
+
+  test('throws on unknown char', () => {
+    expect(() => parseOverworldLayout('X')).toThrow('Unknown tile char');
+  });
+});
+
+describe('getBiomeTerrainOptions', () => {
+  test('returns options for all biomes used in layout', () => {
+    const biomeIds = new Set<string>();
+    for (const def of Object.values(TILE_LEGEND)) {
+      biomeIds.add(def.biomeId);
+    }
+    for (const id of biomeIds) {
+      const opts = getBiomeTerrainOptions(id);
+      expect(opts).toBeDefined();
+      expect(opts.baseHeight).toBeGreaterThan(0);
+    }
+  });
+
+  test('wall terrain is significantly higher than plains', () => {
+    const wall = getBiomeTerrainOptions('wall');
+    const plains = getBiomeTerrainOptions('plains');
+    expect(wall.baseHeight! - plains.baseHeight!).toBeGreaterThanOrEqual(20);
+  });
+
+  test('throws for unknown biome', () => {
+    expect(() => getBiomeTerrainOptions('nonexistent')).toThrow('Unknown biome');
+  });
+});

package/template/apps/game-data/src/world/overworld-layout.ts

@@ -0,0 +1,127 @@
+import type { VoxelTerrainOptions, FlatZone } from '@loonylabs/gamedev-core';
+import { BIOME_TERRAIN_OPTIONS } from '../voxel/biome-terrain.js';
+
+/** Tile types in the overworld ASCII layout. */
+export type OverworldTileType = 'B' | '.' | 'W' | 'D' | 'T';
+
+export interface OverworldTileDef {
+  type: OverworldTileType;
+  biomeId: string;
+  spawnsMobs: boolean;
+  label?: string;
+}
+
+/** Legend mapping ASCII chars to tile definitions. */
+export const TILE_LEGEND: Record<string, OverworldTileDef> = {
+  'B': { type: 'B', biomeId: 'basecamp',   spawnsMobs: false, label: 'Basecamp' },
+  'g': { type: '.', biomeId: 'plains',     spawnsMobs: true,  label: 'Grasslands' },
+  's': { type: '.', biomeId: 'swamp',      spawnsMobs: true,  label: 'Swamp' },
+  'W': { type: 'W', biomeId: 'wall',       spawnsMobs: false, label: 'Wall' },
+  'D': { type: 'D', biomeId: 'swamp',      spawnsMobs: false, label: 'Dungeon Entrance' },
+  'T': { type: 'T', biomeId: 'plains',     spawnsMobs: false, label: 'Passage' },
+};
+
+/**
+ * 8×6 overworld layout.
+ * Grasslands (g) on the left, swamp (s) on the right.
+ * Wall mountains (W) surround the map, with a passage (T) between biomes.
+ */
+export const OVERWORLD_ASCII = [
+  'WWWWWWWW',
+  'WBBgTssW',
+  'WggggssW',
+  'WggggssW',
+  'WgggsDsW',
+  'WWWWWWWW',
+].join('\n');
+
+export interface ParsedTile {
+  col: number;
+  row: number;
+  char: string;
+  def: OverworldTileDef;
+}
+
+export interface OverworldLayout {
+  width: number;
+  height: number;
+  tiles: ParsedTile[][];  // [row][col]
+}
+
+/** Parse the ASCII layout into a structured grid. */
+export function parseOverworldLayout(ascii: string = OVERWORLD_ASCII): OverworldLayout {
+  const rows = ascii.split('\n').filter(r => r.length > 0);
+  const height = rows.length;
+  const width = rows[0].length;
+  const tiles: ParsedTile[][] = [];
+
+  for (let row = 0; row < height; row++) {
+    const tileRow: ParsedTile[] = [];
+    for (let col = 0; col < width; col++) {
+      const char = rows[row][col];
+      const def = TILE_LEGEND[char];
+      if (!def) {
+        throw new Error(`Unknown tile char '${char}' at (${col}, ${row})`);
+      }
+      tileRow.push({ col, row, char, def });
+    }
+    tiles.push(tileRow);
+  }
+
+  return { width, height, tiles };
+}
+
+/** Get the tile definition at a tile coordinate, or undefined if out of bounds. */
+export function getTileAt(layout: OverworldLayout, col: number, row: number): ParsedTile | undefined {
+  if (row < 0 || row >= layout.height || col < 0 || col >= layout.width) return undefined;
+  return layout.tiles[row][col];
+}
+
+/** Get the VoxelTerrainOptions for a biome ID. */
+export function getBiomeTerrainOptions(biomeId: string): VoxelTerrainOptions {
+  const options = BIOME_TERRAIN_OPTIONS[biomeId];
+  if (!options) throw new Error(`Unknown biome '${biomeId}'`);
+  return options;
+}
+
+/** World units per tile (= one voxel chunk width). */
+export const TILE_SIZE = 32;
+
+/**
+ * Compute flat zones for structure placement from the tile layout.
+ * Basecamp tiles get a large flat zone, dungeon entrance gets a smaller one.
+ */
+export function getStructureFlatZones(layout: OverworldLayout): FlatZone[] {
+  const zones: FlatZone[] = [];
+  const basecampHeight = BIOME_TERRAIN_OPTIONS.basecamp.baseHeight ?? 34;
+
+  // Basecamp: one big flat zone covering all B tiles
+  const basecampTiles = layout.tiles.flat().filter(t => t.def.type === 'B');
+  if (basecampTiles.length > 0) {
+    const cx = basecampTiles.reduce((s, t) => s + (t.col + 0.5) * TILE_SIZE, 0) / basecampTiles.length;
+    const cz = basecampTiles.reduce((s, t) => s + (t.row + 0.5) * TILE_SIZE, 0) / basecampTiles.length;
+    // Flat radius covers all basecamp tiles + some margin
+    const flatRadius = Math.max(basecampTiles.length, 2) * TILE_SIZE * 0.5;
+    zones.push({ x: cx, z: cz, flatRadius, falloffRadius: 10, height: basecampHeight });
+  }
+
+  // Dungeon entrance: small flat zone around portal
+  const dungeonTile = layout.tiles.flat().find(t => t.def.type === 'D');
+  if (dungeonTile) {
+    const px = (dungeonTile.col + 0.5) * TILE_SIZE;
+    const pz = (dungeonTile.row + 0.5) * TILE_SIZE;
+    const portalHeight = BIOME_TERRAIN_OPTIONS[dungeonTile.def.biomeId]?.baseHeight ?? 30;
+    zones.push({ x: px, z: pz, flatRadius: 5, falloffRadius: 8, height: portalHeight });
+  }
+
+  return zones;
+}
+
+/**
+ * Maps tile biome IDs to the mob list biome keys from biomes.json.
+ * Only biomes that spawn mobs need an entry.
+ */
+export const BIOME_MOB_MAPPING: Record<string, string> = {
+  plains: 'grasslands',
+  swamp: 'swamp',
+};

package/template/apps/server/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "gamedev-server",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx watch --clear-screen=false src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@loonylabs/game-data": "workspace:*",
+    "@loonylabs/gamedev-core": "workspace:*",
+    "@loonylabs/gamedev-server": "workspace:*",
+    "@loonylabs/gamedev-protocol": "workspace:*",
+    "better-sqlite3": "^12.8.0",
+    "drizzle-orm": "^0.45.2",
+    "socket.io": "^4.7.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^20.0.0",
+    "drizzle-kit": "^0.31.10",
+    "socket.io-client": "^4.7.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}