@loonylabs/create-game 0.1.0

package/template/apps/experiences/shooter/systems/enemyAISystem.ts

@@ -0,0 +1,113 @@
+/**
+ * Enemy AI System — runs AI state machine for all enemies each tick.
+ * Processes enemy shots via hitscan against players.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import { updateShooterEnemyAI, type AIUpdateContext } from '../ai/aiStateMachine.js';
+import { getArenaObstacles } from '../arena/arenaGenerator.js';
+import { hitscanRaycast, type HitscanTarget } from '../arena/hitscan.js';
+import type { AABB } from '../arena/arenaTypes.js';
+import type { ShooterSessionWithEnemies } from '../index.js';
+
+export class EnemyAISystem implements ExperienceSystem {
+  readonly id = 'shooter-enemy-ai';
+
+  private obstacles: AABB[] = [];
+
+  init(session: unknown): void {
+    const s = session as ShooterSessionWithEnemies;
+    this.obstacles = getArenaObstacles(s.arena);
+  }
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as ShooterSessionWithEnemies;
+    const io = context.io as { sockets: { sockets: Map<string, { emit: (ev: string, data: unknown) => void }> } };
+
+    const aiCtx: AIUpdateContext = {
+      players: s.players,
+      obstacles: this.obstacles,
+      arena: s.arena,
+      enemyShots: [],
+    };
+
+    // Update all enemies
+    for (const enemy of s.enemies) {
+      updateShooterEnemyAI(enemy, dt, aiCtx);
+    }
+
+    // Process enemy shots — raycast against players
+    for (const shot of aiCtx.enemyShots) {
+      const playerTargets: HitscanTarget[] = [];
+      for (const player of s.players.values()) {
+        if (player.hp <= 0) continue;
+        playerTargets.push({
+          entityId: player.entityId,
+          position: { x: player.body.x, y: player.body.y + 1, z: player.body.z },
+          radius: 0.5,
+        });
+      }
+
+      const result = hitscanRaycast(
+        shot.origin,
+        shot.direction,
+        100,
+        this.obstacles,
+        playerTargets,
+      );
+
+      if (result && result.entityId !== null) {
+        // Find and damage the player
+        for (const player of s.players.values()) {
+          if (player.entityId === result.entityId) {
+            player.hp = Math.max(0, player.hp - shot.damage);
+
+            // Notify the hit player
+            const sock = io.sockets?.sockets?.get(player.socketId);
+            if (sock) {
+              sock.emit('message', {
+                type: 'PLAYER_DAMAGED',
+                damage: shot.damage,
+                hp: player.hp,
+                maxHp: player.maxHp,
+                fromEntityId: shot.enemyId,
+              });
+
+              // Player death
+              if (player.hp <= 0) {
+                sock.emit('message', {
+                  type: 'PLAYER_DEAD',
+                  waveReached: s.waveState.currentWave + 1,
+                });
+              }
+            }
+            break;
+          }
+        }
+      }
+
+      // Broadcast tracer VFX for enemy shot to all players
+      const endPoint = result
+        ? result.hitPoint
+        : {
+            x: shot.origin.x + shot.direction.x * 100,
+            y: shot.origin.y + shot.direction.y * 100,
+            z: shot.origin.z + shot.direction.z * 100,
+          };
+
+      for (const player of s.players.values()) {
+        const sock = io.sockets?.sockets?.get(player.socketId);
+        if (sock) {
+          sock.emit('message', {
+            type: 'COMBAT_VFX',
+            vfxType: 'tracer',
+            origin: shot.origin,
+            endPoint,
+            hit: result !== null && result.entityId !== null,
+            isEnemy: true,
+          });
+        }
+      }
+    }
+  }
+}

package/template/apps/experiences/shooter/systems/entitySyncSystem.ts

@@ -0,0 +1,68 @@
+/**
+ * Entity Sync System — broadcasts player positions to all connected clients.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import type { ShooterSessionWithEnemies } from '../index.js';
+
+export class ShooterEntitySyncSystem implements ExperienceSystem {
+  readonly id = 'shooter-entity-sync';
+
+  update(session: unknown, _dt: number, context: SystemContext): void {
+    const s = session as ShooterSessionWithEnemies;
+    const io = context.io as { sockets: { sockets: Map<string, { emit: (ev: string, data: unknown) => void }> } };
+
+    const entities: Array<{
+      entityId: number;
+      x: number;
+      y: number;
+      hp?: number;
+      maxHp?: number;
+      type: string;
+      z?: number;
+      worldY?: number;
+      facingAngle?: number;
+    }> = [];
+
+    for (const player of s.players.values()) {
+      entities.push({
+        entityId: player.entityId,
+        x: player.body.x,
+        y: player.body.z, // Map 3D Z to 2D Y for entity sync (convention)
+        z: player.body.y, // Height
+        worldY: player.body.y, // Three.js Y for renderer
+        hp: player.hp,
+        maxHp: player.maxHp,
+        type: 'player',
+        facingAngle: player.facingAngle,
+      });
+    }
+
+    // Add enemies
+    for (const enemy of (s.enemies ?? [])) {
+      if (!enemy.alive) continue;
+      entities.push({
+        entityId: enemy.entityId,
+        x: enemy.body.x,
+        y: enemy.body.z,
+        z: enemy.body.y,
+        worldY: enemy.body.y,
+        hp: enemy.health,
+        maxHp: enemy.maxHealth,
+        type: enemy.enemyType,
+      });
+    }
+
+    // Broadcast to all players in this session
+    for (const player of s.players.values()) {
+      const sock = io.sockets?.sockets?.get(player.socketId);
+      if (sock) {
+        sock.emit('message', {
+          type: 'ENTITY_SYNC',
+          tick: context.tick,
+          entities,
+        });
+      }
+    }
+  }
+}

package/template/apps/experiences/shooter/systems/shooterPhysicsSystem.ts

@@ -0,0 +1,89 @@
+/**
+ * Shooter Physics System — integrates Character Controller for player movement.
+ */
+
+import type { ExperienceSystem, SystemContext, CharacterConfig, PhysicsBody } from '../../../../packages/core/src/index.js';
+import { applyMovementInput, applyFriction, applyHorizontalMovement, updatePhysicsBody, snapToGround, DEFAULT_CHARACTER_CONFIG, DEFAULT_PHYSICS_CONFIG } from '../../../../packages/core/src/index.js';
+import { resolveTerrainCollision } from '../../../../packages/core/src/physics/collision.js';
+import type { Arena } from '../arena/arenaTypes.js';
+import { getArenaGroundHeight } from '../arena/arenaGenerator.js';
+import type { ShooterSessionWithEnemies } from '../index.js';
+
+/** Shooter-tuned character config — responsive, fast. */
+export const SHOOTER_CHARACTER_CONFIG: CharacterConfig = {
+  ...DEFAULT_CHARACTER_CONFIG,
+  walkSpeed: 8,
+  sprintMultiplier: 1.5,
+  maxSpeed: 15,
+  friction: 30,
+  airFriction: 5,
+  airControl: 0.3,
+  acceleration: 50,
+};
+
+export class ShooterPhysicsSystem implements ExperienceSystem {
+  readonly id = 'shooter-physics';
+
+  private arena: Arena | null = null;
+
+  init(session: unknown): void {
+    this.arena = (session as ShooterSessionWithEnemies).arena;
+  }
+
+  update(session: unknown, dt: number): void {
+    const s = session as ShooterSessionWithEnemies;
+    if (!this.arena) return;
+
+    const arena = this.arena;
+    const groundHeight = (x: number, z: number) => {
+      // Check if position is inside a cover block (acts as wall)
+      for (const cover of arena.covers) {
+        if (x >= cover.aabb.min.x && x <= cover.aabb.max.x &&
+            z >= cover.aabb.min.z && z <= cover.aabb.max.z) {
+          return cover.height; // Top of cover block
+        }
+      }
+      return getArenaGroundHeight(arena, x, z);
+    };
+
+    for (const player of s.players.values()) {
+      const input = player.input;
+
+      // Apply character controller
+      applyMovementInput(player.body, input, dt, SHOOTER_CHARACTER_CONFIG);
+      applyFriction(player.body, dt, SHOOTER_CHARACTER_CONFIG);
+      applyHorizontalMovement(player.body, dt);
+
+      // Terrain collision (walls + cover)
+      resolveTerrainCollision(player.body, groundHeight);
+
+      // Clamp to arena bounds (prevent falling through outer walls)
+      const hw = arena.width / 2;
+      const hd = arena.depth / 2;
+      const margin = player.body.radius + 0.1;
+      if (player.body.x < -hw + margin) { player.body.x = -hw + margin; player.body.velocityX = 0; }
+      if (player.body.x > hw - margin) { player.body.x = hw - margin; player.body.velocityX = 0; }
+      if (player.body.z < -hd + margin) { player.body.z = -hd + margin; player.body.velocityZ = 0; }
+      if (player.body.z > hd - margin) { player.body.z = hd - margin; player.body.velocityZ = 0; }
+
+      // Gravity + ground
+      const flatGround = (x: number, z: number) => getArenaGroundHeight(arena, x, z);
+      updatePhysicsBody(player.body, dt, flatGround, DEFAULT_PHYSICS_CONFIG);
+      if (player.body.isGrounded) {
+        snapToGround(player.body, flatGround, DEFAULT_PHYSICS_CONFIG);
+      }
+    }
+
+    // Also clamp enemies to arena bounds
+    for (const enemy of (s.enemies ?? [])) {
+      if (!enemy.alive) continue;
+      const hw = arena.width / 2;
+      const hd = arena.depth / 2;
+      const margin = enemy.body.radius + 0.1;
+      if (enemy.body.x < -hw + margin) { enemy.body.x = -hw + margin; enemy.body.velocityX = 0; }
+      if (enemy.body.x > hw - margin) { enemy.body.x = hw - margin; enemy.body.velocityX = 0; }
+      if (enemy.body.z < -hd + margin) { enemy.body.z = -hd + margin; enemy.body.velocityZ = 0; }
+      if (enemy.body.z > hd - margin) { enemy.body.z = hd - margin; enemy.body.velocityZ = 0; }
+    }
+  }
+}

package/template/apps/experiences/shooter/systems/waveSpawnerSystem.ts

@@ -0,0 +1,87 @@
+/**
+ * Wave Spawner System — spawns enemies in escalating waves.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import { createShooterEnemy, type ShooterEnemy } from '../ai/aiStateMachine.js';
+import { getWaveDefinition, type WaveDefinition } from '../data/wave-definitions.js';
+import type { ShooterSessionWithEnemies } from '../index.js';
+
+export class WaveSpawnerSystem implements ExperienceSystem {
+  readonly id = 'shooter-wave-spawner';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as ShooterSessionWithEnemies;
+
+    // Don't run if no players
+    if (s.players.size === 0) return;
+
+    const ws = s.waveState;
+
+    if (!ws.waveActive) {
+      // Between waves — count down delay
+      ws.delayTimer -= dt;
+      if (ws.delayTimer <= 0) {
+        spawnWave(s);
+      }
+      return;
+    }
+
+    // Wave active — check if all enemies are dead
+    const aliveCount = s.enemies.filter(e => e.alive).length;
+    if (aliveCount === 0) {
+      ws.waveActive = false;
+      const waveDef = getWaveDefinition(ws.currentWave);
+      ws.delayTimer = waveDef.delayAfterClear;
+      ws.currentWave++;
+
+      // Notify players
+      const io = context.io as { sockets: { sockets: Map<string, { emit: (ev: string, data: unknown) => void }> } };
+      for (const player of s.players.values()) {
+        const sock = io.sockets?.sockets?.get(player.socketId);
+        if (sock) {
+          sock.emit('message', {
+            type: 'WAVE_CLEAR',
+            waveNumber: ws.currentWave,
+            nextWaveIn: ws.delayTimer,
+          });
+        }
+      }
+    }
+  }
+}
+
+function spawnWave(s: ShooterSessionWithEnemies): void {
+  const waveDef = getWaveDefinition(s.waveState.currentWave);
+
+  // Clear dead enemies from previous wave
+  s.enemies = s.enemies.filter(e => e.alive);
+
+  // Collect spawn points — use arena spawns that are far from players
+  const spawnPoints = [...s.arena.spawnPoints];
+
+  let spawnIdx = 0;
+  for (const entry of waveDef.enemies) {
+    for (let i = 0; i < entry.count; i++) {
+      const spawn = spawnPoints[spawnIdx % spawnPoints.length];
+      // Offset slightly so enemies don't stack
+      const offset = (spawnIdx * 1.5) % 4 - 2;
+      const position = {
+        x: spawn.x + offset,
+        y: spawn.y,
+        z: spawn.z + offset,
+      };
+
+      const enemy = createShooterEnemy(
+        s.nextEntityId++,
+        entry.type,
+        position,
+        s.nextEntityId * 31337 + s.waveState.currentWave,
+      );
+      s.enemies.push(enemy);
+      spawnIdx++;
+    }
+  }
+
+  s.waveState.waveActive = true;
+}

package/template/apps/experiences/shooter/systems/weaponSystem.ts

@@ -0,0 +1,157 @@
+/**
+ * Weapon System — hitscan shooting, cooldown, ammo, reload.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import { processShoot, updateWeaponState, startReload, DEFAULT_WEAPON_CONFIG } from '../data/weapon-config.js';
+import type { WeaponConfig } from '../data/weapon-config.js';
+import { hitscanRaycast } from '../arena/hitscan.js';
+import { getArenaObstacles } from '../arena/arenaGenerator.js';
+import type { AABB } from '../arena/arenaTypes.js';
+import type { ShooterSessionWithEnemies, ShooterPlayer } from '../index.js';
+import { damageEnemy } from '../ai/aiStateMachine.js';
+import type { HitscanTarget } from '../arena/hitscan.js';
+
+export class WeaponSystem implements ExperienceSystem {
+  readonly id = 'shooter-weapon';
+
+  private obstacles: AABB[] = [];
+
+  init(session: unknown): void {
+    const s = session as ShooterSessionWithEnemies;
+    this.obstacles = getArenaObstacles(s.arena);
+  }
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as ShooterSessionWithEnemies;
+    const io = context.io as { sockets: { sockets: Map<string, { emit: (ev: string, data: unknown) => void }> } };
+
+    for (const player of s.players.values()) {
+      const wasReloading = player.weapon.isReloading;
+      const prevAmmo = player.weapon.currentAmmo;
+
+      // Tick weapon timers
+      updateWeaponState(player.weapon, dt, DEFAULT_WEAPON_CONFIG);
+
+      // Process reload request
+      if (player.wantsReload) {
+        startReload(player.weapon, DEFAULT_WEAPON_CONFIG);
+        player.wantsReload = false;
+      }
+
+      // Send WEAPON_STATE on reload start or reload completion
+      const reloadChanged = player.weapon.isReloading !== wasReloading || player.weapon.currentAmmo !== prevAmmo;
+      if (reloadChanged) {
+        const sock = io.sockets?.sockets?.get(player.socketId);
+        if (sock) {
+          sock.emit('message', {
+            type: 'WEAPON_STATE',
+            currentAmmo: player.weapon.currentAmmo,
+            maxAmmo: DEFAULT_WEAPON_CONFIG.maxAmmo,
+            isReloading: player.weapon.isReloading,
+          });
+        }
+      }
+
+      // Process shoot intents
+      while (player.shootQueue.length > 0) {
+        const intent = player.shootQueue.shift()!;
+        const fired = processShoot(player.weapon, DEFAULT_WEAPON_CONFIG);
+        if (!fired) {
+          // Auto-reload when trying to shoot with empty magazine
+          if (player.weapon.currentAmmo <= 0 && !player.weapon.isReloading) {
+            startReload(player.weapon, DEFAULT_WEAPON_CONFIG);
+          }
+          break;
+        }
+
+        // Build enemy targets for hitscan — two spheres per enemy (body + head)
+        const enemyTargets: HitscanTarget[] = [];
+        for (const e of (s.enemies ?? [])) {
+          if (!e.alive) continue;
+          // Body sphere (torso height, large radius)
+          enemyTargets.push({
+            entityId: e.entityId,
+            position: { x: e.body.x, y: e.body.y + 0.6, z: e.body.z },
+            radius: 0.8,
+          });
+          // Head sphere (higher, smaller)
+          enemyTargets.push({
+            entityId: e.entityId,
+            position: { x: e.body.x, y: e.body.y + 1.3, z: e.body.z },
+            radius: 0.5,
+          });
+        }
+
+        // Raycast
+        const result = hitscanRaycast(
+          intent.origin,
+          intent.direction,
+          DEFAULT_WEAPON_CONFIG.range,
+          this.obstacles,
+          enemyTargets,
+        );
+
+        // Send weapon state update
+        const sock = io.sockets?.sockets?.get(player.socketId);
+        if (sock) {
+          sock.emit('message', {
+            type: 'WEAPON_STATE',
+            currentAmmo: player.weapon.currentAmmo,
+            maxAmmo: DEFAULT_WEAPON_CONFIG.maxAmmo,
+            isReloading: player.weapon.isReloading,
+          });
+
+          // Send hit confirm / tracer VFX
+          const endPoint = result
+            ? result.hitPoint
+            : {
+                x: intent.origin.x + intent.direction.x * DEFAULT_WEAPON_CONFIG.range,
+                y: intent.origin.y + intent.direction.y * DEFAULT_WEAPON_CONFIG.range,
+                z: intent.origin.z + intent.direction.z * DEFAULT_WEAPON_CONFIG.range,
+              };
+
+          sock.emit('message', {
+            type: 'COMBAT_VFX',
+            vfxType: 'tracer',
+            origin: intent.origin,
+            endPoint,
+            hit: result !== null && result.entityId !== null,
+          });
+
+
+          if (result?.entityId !== null && result?.entityId !== undefined) {
+            // Apply damage to enemy
+            const hitEnemy = (s.enemies ?? []).find(e => e.entityId === result.entityId);
+            let killed = false;
+            if (hitEnemy) {
+              killed = damageEnemy(hitEnemy, DEFAULT_WEAPON_CONFIG.damage);
+            }
+
+            sock.emit('message', {
+              type: 'HIT_CONFIRM',
+              targetEntityId: result.entityId,
+              damage: DEFAULT_WEAPON_CONFIG.damage,
+              hitX: result.hitPoint.x,
+              hitY: result.hitPoint.y,
+              hitZ: result.hitPoint.z,
+            });
+
+            if (killed) {
+              // Notify all players of enemy death
+              for (const p of s.players.values()) {
+                const pSock = io.sockets?.sockets?.get(p.socketId);
+                if (pSock) {
+                  pSock.emit('message', {
+                    type: 'ENEMY_KILLED',
+                    entityId: result.entityId,
+                  });
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/template/apps/game-data/src/areas/area-manifest.json

@@ -0,0 +1,18 @@
+{
+  "areas": [
+    {
+      "id": "overworld",
+      "type": "voxel",
+      "transitions": [
+        { "tileType": "D", "targetArea": "dungeon", "spawnX": -1, "spawnY": -1 }
+      ]
+    },
+    {
+      "id": "dungeon",
+      "type": "dungeon",
+      "transitions": [
+        { "cellType": "transition", "targetArea": "overworld", "spawnX": -1, "spawnY": -1 }
+      ]
+    }
+  ]
+}