@loonylabs/create-game 0.1.0

package/template/apps/experiences/shooter/ai/lineOfSight.ts

@@ -0,0 +1,32 @@
+/**
+ * Line of Sight check — reuses hitscan raycast against arena obstacles.
+ */
+
+import type { AABB, Vec3 } from '../arena/arenaTypes.js';
+import { hitscanRaycast } from '../arena/hitscan.js';
+
+/**
+ * Check if there is a clear line of sight between two points.
+ * Returns true if no obstacle blocks the path.
+ */
+export function hasLineOfSight(from: Vec3, to: Vec3, obstacles: AABB[]): boolean {
+  const dx = to.x - from.x;
+  const dy = to.y - from.y;
+  const dz = to.z - from.z;
+  const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+  if (dist < 0.001) return true;
+
+  const dir = { x: dx / dist, y: dy / dist, z: dz / dist };
+  const hit = hitscanRaycast(from, dir, dist, obstacles, []);
+  return hit === null;
+}
+
+/**
+ * Get the distance between two Vec3 points.
+ */
+export function distance3D(a: Vec3, b: Vec3): number {
+  const dx = a.x - b.x;
+  const dy = a.y - b.y;
+  const dz = a.z - b.z;
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}

package/template/apps/experiences/shooter/arena/arenaGenerator.ts

@@ -0,0 +1,101 @@
+/**
+ * Procedural arena generation for the Shooter experience.
+ * Seed-based — same seed produces the same arena layout.
+ */
+
+import { mulberry32 } from '../../../../packages/core/src/dungeon/prng.js';
+import type { Arena, ArenaConfig, AABB, CoverBlock, Vec3 } from './arenaTypes.js';
+import { DEFAULT_ARENA_CONFIG } from './arenaTypes.js';
+
+/**
+ * Generate a shooter arena with outer walls, cover blocks, and spawn points.
+ */
+export function generateArena(seed: number, config: ArenaConfig = DEFAULT_ARENA_CONFIG): Arena {
+  const rng = mulberry32(seed);
+  const { width, depth, wallHeight, coverCount, coverMinSize, coverMaxSize } = config;
+  const hw = width / 2;
+  const hd = depth / 2;
+
+  // Outer walls (4 sides)
+  const wallThickness = 0.5;
+  const walls: AABB[] = [
+    // North wall (-Z)
+    { min: { x: -hw - wallThickness, y: 0, z: -hd - wallThickness }, max: { x: hw + wallThickness, y: wallHeight, z: -hd } },
+    // South wall (+Z)
+    { min: { x: -hw - wallThickness, y: 0, z: hd }, max: { x: hw + wallThickness, y: wallHeight, z: hd + wallThickness } },
+    // West wall (-X)
+    { min: { x: -hw - wallThickness, y: 0, z: -hd }, max: { x: -hw, y: wallHeight, z: hd } },
+    // East wall (+X)
+    { min: { x: hw, y: 0, z: -hd }, max: { x: hw + wallThickness, y: wallHeight, z: hd } },
+  ];
+
+  // Spawn points in corners (inset by 3 units)
+  const inset = 3;
+  const spawnPoints: Vec3[] = [
+    { x: -hw + inset, y: 0, z: -hd + inset },
+    { x: hw - inset, y: 0, z: -hd + inset },
+    { x: -hw + inset, y: 0, z: hd - inset },
+    { x: hw - inset, y: 0, z: hd - inset },
+  ];
+
+  // Generate cover blocks
+  const covers: CoverBlock[] = [];
+  const spawnClearRadius = 5; // Keep covers away from spawn points
+  let attempts = 0;
+  const maxAttempts = coverCount * 10;
+
+  while (covers.length < coverCount && attempts < maxAttempts) {
+    attempts++;
+
+    const w = coverMinSize + rng() * (coverMaxSize - coverMinSize);
+    const d = coverMinSize + rng() * (coverMaxSize - coverMinSize);
+    const h = 1.5 + rng() * 1.5; // Height 1.5-3
+
+    // Random position within arena bounds (inset by cover size)
+    const cx = -hw + w + rng() * (width - 2 * w);
+    const cz = -hd + d + rng() * (depth - 2 * d);
+
+    // Check distance from spawn points
+    const tooCloseToSpawn = spawnPoints.some(sp => {
+      const dx = sp.x - cx;
+      const dz = sp.z - cz;
+      return Math.sqrt(dx * dx + dz * dz) < spawnClearRadius;
+    });
+    if (tooCloseToSpawn) continue;
+
+    // Check overlap with existing covers (with gap)
+    const gap = 2;
+    const overlaps = covers.some(c => {
+      return Math.abs(c.position.x - cx) < (c.width + w) / 2 + gap &&
+             Math.abs(c.position.z - cz) < (c.depth + d) / 2 + gap;
+    });
+    if (overlaps) continue;
+
+    const aabb: AABB = {
+      min: { x: cx - w / 2, y: 0, z: cz - d / 2 },
+      max: { x: cx + w / 2, y: h, z: cz + d / 2 },
+    };
+
+    covers.push({ position: { x: cx, y: 0, z: cz }, width: w, depth: d, height: h, aabb });
+  }
+
+  return { width, depth, walls, covers, spawnPoints, seed };
+}
+
+/**
+ * Get all collidable AABBs in the arena (walls + covers).
+ */
+export function getArenaObstacles(arena: Arena): AABB[] {
+  return [...arena.walls, ...arena.covers.map(c => c.aabb)];
+}
+
+/**
+ * Get the ground height at a position in the arena.
+ * Returns 0 (flat floor) if inside arena, null if outside.
+ */
+export function getArenaGroundHeight(arena: Arena, x: number, z: number): number | null {
+  const hw = arena.width / 2;
+  const hd = arena.depth / 2;
+  if (x < -hw || x > hw || z < -hd || z > hd) return null;
+  return 0; // Flat arena floor
+}

package/template/apps/experiences/shooter/arena/arenaTypes.ts

@@ -0,0 +1,49 @@
+/**
+ * Shooter Arena — type definitions.
+ */
+
+export interface Vec3 {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface AABB {
+  min: Vec3;
+  max: Vec3;
+}
+
+export interface CoverBlock {
+  position: Vec3;
+  width: number;
+  depth: number;
+  height: number;
+  aabb: AABB;
+}
+
+export interface Arena {
+  width: number;
+  depth: number;
+  walls: AABB[];
+  covers: CoverBlock[];
+  spawnPoints: Vec3[];
+  seed: number;
+}
+
+export interface ArenaConfig {
+  width: number;
+  depth: number;
+  wallHeight: number;
+  coverCount: number;
+  coverMinSize: number;
+  coverMaxSize: number;
+}
+
+export const DEFAULT_ARENA_CONFIG: ArenaConfig = {
+  width: 40,
+  depth: 40,
+  wallHeight: 4,
+  coverCount: 12,
+  coverMinSize: 1.5,
+  coverMaxSize: 3,
+};

package/template/apps/experiences/shooter/arena/hitscan.ts

@@ -0,0 +1,101 @@
+/**
+ * Hitscan raycast — ray vs AABBs + spheres for the Shooter experience.
+ */
+
+import { intersectRayAABB } from '../../../../packages/core/src/combat/raycast.js';
+import type { AABB, Vec3 } from './arenaTypes.js';
+
+export interface HitscanTarget {
+  entityId: number;
+  position: Vec3;
+  radius: number;
+}
+
+export interface HitscanResult {
+  hitPoint: Vec3;
+  distance: number;
+  /** null if hit geometry, entityId if hit an entity */
+  entityId: number | null;
+}
+
+/**
+ * Cast a ray against arena obstacles and entity spheres.
+ * Returns the closest hit, or null if nothing was hit within maxDistance.
+ */
+export function hitscanRaycast(
+  origin: Vec3,
+  direction: Vec3,
+  maxDistance: number,
+  obstacles: AABB[],
+  entities: HitscanTarget[],
+): HitscanResult | null {
+  let closest: HitscanResult | null = null;
+
+  // Check obstacles (AABB)
+  for (const obs of obstacles) {
+    const dist = intersectRayAABB(origin, direction, obs.min, obs.max);
+    if (dist !== null && dist <= maxDistance) {
+      if (!closest || dist < closest.distance) {
+        closest = {
+          hitPoint: {
+            x: origin.x + direction.x * dist,
+            y: origin.y + direction.y * dist,
+            z: origin.z + direction.z * dist,
+          },
+          distance: dist,
+          entityId: null,
+        };
+      }
+    }
+  }
+
+  // Check entities (sphere intersection)
+  for (const entity of entities) {
+    const dist = intersectRaySphere(origin, direction, entity.position, entity.radius);
+    if (dist !== null && dist <= maxDistance && dist >= 0) {
+      if (!closest || dist < closest.distance) {
+        closest = {
+          hitPoint: {
+            x: origin.x + direction.x * dist,
+            y: origin.y + direction.y * dist,
+            z: origin.z + direction.z * dist,
+          },
+          distance: dist,
+          entityId: entity.entityId,
+        };
+      }
+    }
+  }
+
+  return closest;
+}
+
+/**
+ * Ray-sphere intersection. Returns distance to hit or null.
+ */
+function intersectRaySphere(
+  origin: Vec3,
+  direction: Vec3,
+  center: Vec3,
+  radius: number,
+): number | null {
+  const ox = origin.x - center.x;
+  const oy = origin.y - center.y;
+  const oz = origin.z - center.z;
+
+  const a = direction.x * direction.x + direction.y * direction.y + direction.z * direction.z;
+  const b = 2 * (ox * direction.x + oy * direction.y + oz * direction.z);
+  const c = ox * ox + oy * oy + oz * oz - radius * radius;
+
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0) return null;
+
+  const sqrtDisc = Math.sqrt(discriminant);
+  const t1 = (-b - sqrtDisc) / (2 * a);
+  const t2 = (-b + sqrtDisc) / (2 * a);
+
+  // Return the nearest positive intersection
+  if (t1 >= 0) return t1;
+  if (t2 >= 0) return t2;
+  return null;
+}

package/template/apps/experiences/shooter/data/enemy-types.ts

@@ -0,0 +1,108 @@
+/**
+ * Enemy type definitions for the Shooter experience.
+ */
+
+import type { CharacterConfig } from '../../../../packages/core/src/physics/characterController.js';
+import { DEFAULT_CHARACTER_CONFIG } from '../../../../packages/core/src/physics/characterController.js';
+import type { WeaponConfig } from './weapon-config.js';
+
+export type EnemyType = 'rusher' | 'patrol' | 'sniper';
+
+export interface EnemyTypeConfig {
+  type: EnemyType;
+  health: number;
+  detectionRadius: number;
+  attackRange: number;
+  /** Radians of random aim deviation */
+  accuracySpread: number;
+  /** Seconds of reaction delay after detection */
+  reactionTime: number;
+  /** HP threshold (fraction) to trigger retreat */
+  retreatThreshold: number;
+  characterConfig: CharacterConfig;
+  weaponConfig: WeaponConfig;
+}
+
+export const RUSHER_CONFIG: EnemyTypeConfig = {
+  type: 'rusher',
+  health: 30,
+  detectionRadius: 15,
+  attackRange: 6,
+  accuracySpread: 0.15,
+  reactionTime: 0.3,
+  retreatThreshold: 0, // Rushers never retreat
+  characterConfig: {
+    ...DEFAULT_CHARACTER_CONFIG,
+    walkSpeed: 5,
+    sprintMultiplier: 1.5,
+    maxSpeed: 10,
+    friction: 20,
+    airControl: 0.2,
+    acceleration: 30,
+  },
+  weaponConfig: {
+    damage: 8,
+    fireRate: 3,
+    maxAmmo: 999, // Unlimited
+    reloadTime: 0,
+    range: 10,
+  },
+};
+
+export const PATROL_CONFIG: EnemyTypeConfig = {
+  type: 'patrol',
+  health: 60,
+  detectionRadius: 20,
+  attackRange: 15,
+  accuracySpread: 0.08,
+  reactionTime: 0.5,
+  retreatThreshold: 0.2,
+  characterConfig: {
+    ...DEFAULT_CHARACTER_CONFIG,
+    walkSpeed: 3,
+    sprintMultiplier: 1.3,
+    maxSpeed: 6,
+    friction: 25,
+    airControl: 0.2,
+    acceleration: 25,
+  },
+  weaponConfig: {
+    damage: 12,
+    fireRate: 2,
+    maxAmmo: 999,
+    reloadTime: 0,
+    range: 20,
+  },
+};
+
+export const SNIPER_CONFIG: EnemyTypeConfig = {
+  type: 'sniper',
+  health: 40,
+  detectionRadius: 35,
+  attackRange: 30,
+  accuracySpread: 0.03,
+  reactionTime: 0.8,
+  retreatThreshold: 0.3,
+  characterConfig: {
+    ...DEFAULT_CHARACTER_CONFIG,
+    walkSpeed: 1.5,
+    sprintMultiplier: 1.2,
+    maxSpeed: 3,
+    friction: 30,
+    airControl: 0.1,
+    acceleration: 15,
+  },
+  weaponConfig: {
+    damage: 30,
+    fireRate: 0.5,
+    maxAmmo: 999,
+    reloadTime: 0,
+    range: 40,
+  },
+};
+
+export const ENEMY_CONFIGS: Record<EnemyType, EnemyTypeConfig> = {
+  rusher: RUSHER_CONFIG,
+  patrol: PATROL_CONFIG,
+  sniper: SNIPER_CONFIG,
+};

package/template/apps/experiences/shooter/data/wave-definitions.ts

@@ -0,0 +1,40 @@
+/**
+ * Wave definitions for the Shooter experience.
+ */
+
+import type { EnemyType } from './enemy-types.js';
+
+export interface WaveEntry {
+  type: EnemyType;
+  count: number;
+}
+
+export interface WaveDefinition {
+  enemies: WaveEntry[];
+  /** Seconds to wait after clearing before spawning next wave */
+  delayAfterClear: number;
+}
+
+export const WAVE_DEFINITIONS: WaveDefinition[] = [
+  { enemies: [{ type: 'rusher', count: 3 }], delayAfterClear: 3 },
+  { enemies: [{ type: 'patrol', count: 2 }, { type: 'rusher', count: 1 }], delayAfterClear: 3 },
+  { enemies: [{ type: 'sniper', count: 1 }, { type: 'patrol', count: 2 }, { type: 'rusher', count: 2 }], delayAfterClear: 3 },
+  { enemies: [{ type: 'sniper', count: 2 }, { type: 'patrol', count: 3 }, { type: 'rusher', count: 3 }], delayAfterClear: 3 },
+  { enemies: [{ type: 'sniper', count: 2 }, { type: 'patrol', count: 4 }, { type: 'rusher', count: 4 }], delayAfterClear: 3 },
+];
+
+/**
+ * Get wave definition. After defined waves, scales up the last wave.
+ */
+export function getWaveDefinition(waveIndex: number): WaveDefinition {
+  if (waveIndex < WAVE_DEFINITIONS.length) {
+    return WAVE_DEFINITIONS[waveIndex];
+  }
+  // Scale up: add more enemies per wave beyond defined ones
+  const base = WAVE_DEFINITIONS[WAVE_DEFINITIONS.length - 1];
+  const extra = waveIndex - WAVE_DEFINITIONS.length + 1;
+  return {
+    enemies: base.enemies.map(e => ({ ...e, count: e.count + extra })),
+    delayAfterClear: 3,
+  };
+}

package/template/apps/experiences/shooter/data/weapon-config.ts

@@ -0,0 +1,80 @@
+/**
+ * Weapon configuration for the Shooter experience.
+ */
+
+export interface WeaponConfig {
+  damage: number;
+  /** Shots per second */
+  fireRate: number;
+  /** Magazine size */
+  maxAmmo: number;
+  /** Seconds to reload */
+  reloadTime: number;
+  /** Max hitscan distance */
+  range: number;
+}
+
+export const DEFAULT_WEAPON_CONFIG: WeaponConfig = {
+  damage: 25,
+  fireRate: 4,
+  maxAmmo: 12,
+  reloadTime: 1.5,
+  range: 100,
+};
+
+export interface WeaponState {
+  currentAmmo: number;
+  isReloading: boolean;
+  reloadTimer: number;
+  fireCooldown: number;
+}
+
+export function createWeaponState(config: WeaponConfig): WeaponState {
+  return {
+    currentAmmo: config.maxAmmo,
+    isReloading: false,
+    reloadTimer: 0,
+    fireCooldown: 0,
+  };
+}
+
+/**
+ * Attempt to fire. Returns true if shot was fired.
+ */
+export function processShoot(state: WeaponState, config: WeaponConfig): boolean {
+  if (state.isReloading) return false;
+  if (state.fireCooldown > 0) return false;
+  if (state.currentAmmo <= 0) return false;
+
+  state.currentAmmo--;
+  state.fireCooldown = 1 / config.fireRate;
+  return true;
+}
+
+/**
+ * Start reloading.
+ */
+export function startReload(state: WeaponState, config: WeaponConfig): void {
+  if (state.isReloading) return;
+  if (state.currentAmmo >= config.maxAmmo) return;
+  state.isReloading = true;
+  state.reloadTimer = config.reloadTime;
+}
+
+/**
+ * Tick the weapon state (cooldown + reload timer).
+ */
+export function updateWeaponState(state: WeaponState, dt: number, config: WeaponConfig): void {
+  if (state.fireCooldown > 0) {
+    state.fireCooldown = Math.max(0, state.fireCooldown - dt);
+  }
+
+  if (state.isReloading) {
+    state.reloadTimer -= dt;
+    if (state.reloadTimer <= 0) {
+      state.isReloading = false;
+      state.reloadTimer = 0;
+      state.currentAmmo = config.maxAmmo;
+    }
+  }
+}

package/template/apps/experiences/shooter/index.ts

@@ -0,0 +1,127 @@
+/**
+ * Shooter Experience — FPS/TPS arena combat.
+ *
+ * Provides:
+ * - ShooterExperience: ExperienceDefinition for hub registration
+ * - ShooterSession: custom session state for shooter gameplay
+ * - ShooterPlayer: per-player state including physics body, weapon, input
+ */
+
+import type { ExperienceDefinition, ExperienceSystem, PhysicsBody, MovementInput } from '../../../packages/core/src/index.js';
+import { DEFAULT_PHYSICS_CONFIG, createPhysicsBody } from '../../../packages/core/src/index.js';
+import type { Arena } from './arena/arenaTypes.js';
+import type { Vec3 } from './arena/arenaTypes.js';
+import type { WeaponState } from './data/weapon-config.js';
+import { createWeaponState, DEFAULT_WEAPON_CONFIG } from './data/weapon-config.js';
+import { generateArena } from './arena/arenaGenerator.js';
+import { ShooterPhysicsSystem } from './systems/shooterPhysicsSystem.js';
+import { WeaponSystem } from './systems/weaponSystem.js';
+import { ShooterEntitySyncSystem } from './systems/entitySyncSystem.js';
+import { EnemyAISystem } from './systems/enemyAISystem.js';
+import { WaveSpawnerSystem } from './systems/waveSpawnerSystem.js';
+import type { ShooterEnemy } from './ai/aiStateMachine.js';
+
+// ---------------------------------------------------------------------------
+// Shooter-specific session & player state
+// ---------------------------------------------------------------------------
+
+export interface ShootIntent {
+  origin: Vec3;
+  direction: Vec3;
+}
+
+export interface ShooterPlayer {
+  socketId: string;
+  playerId: string;
+  entityId: number;
+  body: PhysicsBody;
+  hp: number;
+  maxHp: number;
+  weapon: WeaponState;
+  input: MovementInput;
+  facingAngle: number;
+  shootQueue: ShootIntent[];
+  wantsReload: boolean;
+}
+
+export interface ShooterSession {
+  arena: Arena;
+  players: Map<string, ShooterPlayer>;
+  nextEntityId: number;
+}
+
+export interface WaveState {
+  currentWave: number;
+  waveActive: boolean;
+  delayTimer: number;
+}
+
+/** Extended session with enemy support (Story 60). */
+export interface ShooterSessionWithEnemies extends ShooterSession {
+  enemies: ShooterEnemy[];
+  waveState: WaveState;
+}
+
+export function createShooterSession(seed: number): ShooterSessionWithEnemies {
+  const arena = generateArena(seed);
+  return {
+    arena,
+    players: new Map(),
+    nextEntityId: 1,
+    enemies: [],
+    waveState: {
+      currentWave: 0,
+      waveActive: false,
+      delayTimer: 2, // 2 second delay before first wave
+    },
+  };
+}
+
+export function addShooterPlayer(session: ShooterSession, socketId: string, playerId: string): ShooterPlayer {
+  const entityId = session.nextEntityId++;
+  const spawnIdx = session.players.size % session.arena.spawnPoints.length;
+  const spawn = session.arena.spawnPoints[spawnIdx];
+
+  const player: ShooterPlayer = {
+    socketId,
+    playerId,
+    entityId,
+    body: createPhysicsBody(spawn.x, spawn.y, spawn.z),
+    hp: 100,
+    maxHp: 100,
+    weapon: createWeaponState(DEFAULT_WEAPON_CONFIG),
+    input: { x: 0, z: 0, sprint: false, glide: false },
+    facingAngle: 0,
+    shootQueue: [],
+    wantsReload: false,
+  };
+
+  session.players.set(socketId, player);
+  return player;
+}
+
+export function removeShooterPlayer(session: ShooterSession, socketId: string): void {
+  session.players.delete(socketId);
+}
+
+// ---------------------------------------------------------------------------
+// Experience Definition
+// ---------------------------------------------------------------------------
+
+export class ShooterExperience implements ExperienceDefinition {
+  readonly id = 'shooter';
+  readonly name = 'Shooter Arena';
+  readonly description = 'Fast-paced arena combat with hitscan weapons. Run, jump, sprint, and shoot.';
+  readonly defaultCameraMode = 'third-person' as const;
+  readonly physicsConfig = DEFAULT_PHYSICS_CONFIG;
+
+  createSystems(): ExperienceSystem[] {
+    return [
+      new WaveSpawnerSystem(),
+      new EnemyAISystem(),
+      new ShooterPhysicsSystem(),
+      new WeaponSystem(),
+      new ShooterEntitySyncSystem(),
+    ];
+  }
+}