@loonylabs/create-game 0.1.0

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

@@ -0,0 +1,94 @@
+/**
+ * Diablo Experience — wraps the existing Diablo-like game as an ExperienceDefinition.
+ *
+ * Each area (overworld, dungeon) gets its own game loop with its own system set.
+ * This module provides:
+ * - DiabloExperience: the ExperienceDefinition for hub registration
+ * - createDiabloAreaSystems(): creates the system array for a specific area
+ */
+
+import type { ExperienceDefinition, ExperienceSystem, PhysicsConfig, JumpConfig } from '../../../packages/core/src/index.js';
+import { DEFAULT_PHYSICS_CONFIG } from '../../../packages/core/src/index.js';
+import type { AreaManager, AreaSession } from '../../server/src/areaManager.js';
+import { MovementSystem } from './systems/movementSystem.js';
+import { EnemyAISystem } from './systems/enemyAISystem.js';
+import { ItemPickupSystem } from './systems/itemPickupSystem.js';
+import { PhysicsSystem, type PhysicsSystemConfig } from './systems/physicsSystem.js';
+import { TransitionSystem, type TransitionSystemConfig } from './systems/transitionSystem.js';
+import { DungeonClearSystem } from './systems/dungeonClearSystem.js';
+import { EntitySyncSystem } from './systems/entitySyncSystem.js';
+
+interface TransitionDef {
+  cellType?: string;
+  tileType?: string;
+  targetArea: string;
+  spawnX: number;
+  spawnY: number;
+  minX?: number;
+  maxX?: number;
+  minY?: number;
+  maxY?: number;
+}
+
+export interface DiabloAreaSystemsConfig {
+  areaId: string;
+  areaSession: AreaSession;
+  areaManager: AreaManager;
+  physicsConfig: PhysicsConfig;
+  jumpConfig: JumpConfig;
+  transitions: TransitionDef[];
+}
+
+/**
+ * Create the ordered system array for a Diablo area.
+ * Each area gets its own set of systems — the order matches the original game loop.
+ */
+export function createDiabloAreaSystems(config: DiabloAreaSystemsConfig): ExperienceSystem[] {
+  const { areaId, areaSession, areaManager, physicsConfig, jumpConfig, transitions } = config;
+
+  const physicsSystem = new PhysicsSystem({
+    areaType: areaSession.areaType as 'voxel' | 'dungeon' | 'room',
+    areaId,
+    physicsConfig,
+    jumpConfig,
+    chunkCache: areaSession.chunkCache,
+  });
+
+  return [
+    new MovementSystem(),
+    new EnemyAISystem(),
+    new ItemPickupSystem(),
+    physicsSystem,
+    new TransitionSystem({
+      areaId,
+      areaType: areaSession.areaType as 'voxel' | 'dungeon' | 'room',
+      transitions,
+      areaManager,
+    }),
+    new DungeonClearSystem({ areaId, areaManager }),
+    new EntitySyncSystem({
+      areaType: areaSession.areaType as 'voxel' | 'dungeon' | 'room',
+      chunkCache: areaSession.chunkCache,
+      physicsSystem,
+    }),
+  ];
+}
+
+/**
+ * DiabloExperience definition — used for hub registration.
+ * The actual systems are created per-area via createDiabloAreaSystems().
+ * createSystems() returns an empty list because the Diablo experience
+ * uses multiple areas, each with its own game loop and system set.
+ */
+export class DiabloExperience implements ExperienceDefinition {
+  readonly id = 'diablo';
+  readonly name = 'Diablo — Overworld & Dungeon';
+  readonly description = 'Explore the voxel overworld, enter dungeons, fight enemies, collect loot.';
+  readonly defaultCameraMode = 'orbit' as const;
+  readonly physicsConfig = DEFAULT_PHYSICS_CONFIG;
+
+  createSystems(): ExperienceSystem[] {
+    // Systems are created per-area via createDiabloAreaSystems()
+    return [];
+  }
+}

package/template/apps/experiences/diablo/systems/dungeonClearSystem.ts

@@ -0,0 +1,60 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import { isDungeonCleared } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import type { Server } from 'socket.io';
+import type { AreaManager } from '../../../server/src/areaManager.js';
+
+export interface DungeonClearSystemConfig {
+  areaId: string;
+  areaManager: AreaManager;
+}
+
+/**
+ * Checks dungeon clearance and triggers countdown + teleport to overworld.
+ * Only active for the dungeon area.
+ */
+export class DungeonClearSystem implements ExperienceSystem {
+  readonly id = 'diablo-dungeon-clear';
+  private config: DungeonClearSystemConfig;
+
+  constructor(config: DungeonClearSystemConfig) {
+    this.config = config;
+  }
+
+  update(session: unknown, _dt: number, context: SystemContext): void {
+    const sess = session as GameSession;
+    const io = context.io as Server;
+    const { areaId, areaManager } = this.config;
+
+    if (areaId !== 'dungeon') return;
+    if (sess.state.enemies.length === 0 || sess.clearedAt) return;
+
+    if (!isDungeonCleared(sess.state)) return;
+
+    sess.clearedAt = Date.now();
+    for (const player of sess.state.players.values()) {
+      io.sockets.sockets.get(player.socketId)?.emit('message', {
+        type: 'DUNGEON_CLEAR',
+        countdownSeconds: 10,
+      });
+    }
+
+    let remaining = 10;
+    const countdown = setInterval(() => {
+      remaining--;
+      for (const player of sess.state.players.values()) {
+        io.sockets.sockets.get(player.socketId)?.emit('message', {
+          type: 'COUNTDOWN_TICK',
+          secondsRemaining: remaining,
+        });
+      }
+      if (remaining <= 0) {
+        clearInterval(countdown);
+        const playerIds = [...sess.state.players.keys()];
+        for (const socketId of playerIds) {
+          areaManager.movePlayer(io, socketId, 'overworld', -1, -1);
+        }
+      }
+    }, 1000);
+  }
+}

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

@@ -0,0 +1,11 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import { updateEnemyAI } from '../../../server/src/systems/enemyAI.js';
+
+export class EnemyAISystem implements ExperienceSystem {
+  readonly id = 'diablo-enemy-ai';
+
+  update(session: unknown, dt: number, _context: SystemContext): void {
+    updateEnemyAI(session as GameSession, dt);
+  }
+}

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

@@ -0,0 +1,80 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import { getTerrainHeight } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import type { Server } from 'socket.io';
+import type { VoxelPhysicsMap } from '../../../server/src/voxelPlayerState.js';
+import type { VoxelChunkCache } from '../../../server/src/voxelChunkCache.js';
+import type { PhysicsSystem } from './physicsSystem.js';
+
+export interface EntitySyncSystemConfig {
+  areaType: 'voxel' | 'dungeon' | 'room';
+  chunkCache?: VoxelChunkCache;
+  /** Reference to the physics system to get the physics map. */
+  physicsSystem?: PhysicsSystem;
+}
+
+/**
+ * Broadcasts entity snapshots to all players in the session.
+ * Overrides Y positions with physics body data for areas with physics.
+ */
+export class EntitySyncSystem implements ExperienceSystem {
+  readonly id = 'diablo-entity-sync';
+  private config: EntitySyncSystemConfig;
+
+  constructor(config: EntitySyncSystemConfig) {
+    this.config = config;
+  }
+
+  update(session: unknown, _dt: number, context: SystemContext): void {
+    const sess = session as GameSession;
+    const io = context.io as Server;
+    const { areaType, chunkCache, physicsSystem } = this.config;
+    const tick = context.tick;
+
+    const runPhysics = areaType === 'voxel' || areaType === 'dungeon';
+    const physicsMap = physicsSystem?.getPhysicsMap();
+    let entities = sess.getEntitySnapshots();
+
+    // For areas with physics, override positions with PhysicsBody data
+    if (runPhysics && physicsMap) {
+      const isVoxelArea = areaType === 'voxel';
+      const getGroundYForSync = isVoxelArea && chunkCache
+        ? (x: number, z: number) => getTerrainHeight(chunkCache.getChunkFn, x, z) ?? 0
+        : null;
+
+      entities = entities.map(e => {
+        // Players: use physics body Y
+        for (const [socketId, physics] of physicsMap) {
+          const p = sess.state.players.get(socketId);
+          if (p && p.entityId === e.entityId) {
+            return { ...e, x: physics.body.x, y: physics.body.z, z: physics.body.z, worldY: physics.body.y };
+          }
+        }
+        // Non-player entities in voxel areas: compute terrain height
+        if (getGroundYForSync && e.type !== 'player') {
+          return { ...e, worldY: getGroundYForSync(e.x, e.y) };
+        }
+        return e;
+      });
+    }
+
+    // Emit to players in this session
+    for (const player of sess.state.players.values()) {
+      const sock = io.sockets.sockets.get(player.socketId);
+      sock?.emit('message', { type: 'ENTITY_SYNC', entities, tick });
+    }
+
+    // Per-socket INPUT_ACK so each WASD client can reconcile predictions
+    for (const player of sess.state.players.values()) {
+      if (player.lastProcessedInputId >= 0) {
+        const sock = io.sockets.sockets.get(player.socketId);
+        sock?.emit('message', {
+          type: 'INPUT_ACK',
+          lastProcessedInputId: player.lastProcessedInputId,
+          x: player.x,
+          y: player.y,
+        });
+      }
+    }
+  }
+}

package/template/apps/experiences/diablo/systems/itemPickupSystem.ts

@@ -0,0 +1,11 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import { updateItemPickup } from '../../../server/src/systems/itemPickup.js';
+
+export class ItemPickupSystem implements ExperienceSystem {
+  readonly id = 'diablo-item-pickup';
+
+  update(session: unknown, _dt: number, _context: SystemContext): void {
+    updateItemPickup(session as GameSession);
+  }
+}

package/template/apps/experiences/diablo/systems/movementSystem.ts

@@ -0,0 +1,13 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+
+/**
+ * Wraps session.updateMovement() — moves players along their path each tick.
+ */
+export class MovementSystem implements ExperienceSystem {
+  readonly id = 'diablo-movement';
+
+  update(session: unknown, dt: number, _context: SystemContext): void {
+    (session as GameSession).updateMovement(dt);
+  }
+}

package/template/apps/experiences/diablo/systems/physicsSystem.ts

@@ -0,0 +1,92 @@
+import type { ExperienceSystem, SystemContext, PhysicsConfig, JumpConfig } from '../../../../packages/core/src/index.js';
+import { getTerrainHeight, updatePhysicsBody, updateJumpState, snapToGround, consumeJumpBuffer } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import { createVoxelPlayerPhysics, type VoxelPhysicsMap, voxelPhysicsRegistry } from '../../../server/src/voxelPlayerState.js';
+import type { VoxelChunkCache } from '../../../server/src/voxelChunkCache.js';
+import { getDungeonGroundY } from '../../../server/src/systems/dungeonPhysics.js';
+
+export interface PhysicsSystemConfig {
+  areaType: 'voxel' | 'dungeon' | 'room';
+  areaId: string;
+  physicsConfig: PhysicsConfig;
+  jumpConfig: JumpConfig;
+  chunkCache?: VoxelChunkCache;
+}
+
+/**
+ * Wraps the physics tick from the monolithic game loop.
+ * Handles both voxel and dungeon areas depending on config.
+ */
+export class PhysicsSystem implements ExperienceSystem {
+  readonly id = 'diablo-physics';
+  private physicsMap: VoxelPhysicsMap = new Map();
+  private config: PhysicsSystemConfig;
+
+  constructor(config: PhysicsSystemConfig) {
+    this.config = config;
+  }
+
+  init(_session: unknown, _context: SystemContext): void {
+    const runPhysics = this.config.areaType === 'voxel' || this.config.areaType === 'dungeon';
+    if (runPhysics) {
+      voxelPhysicsRegistry.set(this.config.areaId, this.physicsMap);
+    }
+  }
+
+  update(session: unknown, dt: number, _context: SystemContext): void {
+    const sess = session as GameSession;
+    const { areaType, physicsConfig, jumpConfig, chunkCache } = this.config;
+
+    if (areaType !== 'voxel' && areaType !== 'dungeon') return;
+
+    const isVoxelArea = areaType === 'voxel';
+    const getGroundY = isVoxelArea && chunkCache
+      ? (x: number, z: number) => getTerrainHeight(chunkCache.getChunkFn, x, z)
+      : (x: number, z: number) => getDungeonGroundY(sess, x, z);
+
+    for (const player of sess.state.players.values()) {
+      // Ensure physics state exists
+      if (!this.physicsMap.has(player.socketId)) {
+        const spawnHeight = getGroundY(player.x, player.y) ?? 32;
+        this.physicsMap.set(player.socketId, createVoxelPlayerPhysics(player.x, spawnHeight, player.y));
+      }
+
+      const physics = this.physicsMap.get(player.socketId)!;
+
+      // Sync horizontal position from PLAYER_MOVE_DIRECT
+      physics.body.x = player.x;
+      physics.body.z = player.y;
+
+      // Update jump timers
+      updateJumpState(physics.jumpState, physics.body, dt);
+
+      // Apply gravity + ground check
+      updatePhysicsBody(physics.body, dt, getGroundY, physicsConfig);
+
+      // Auto-jump if buffered and just landed
+      consumeJumpBuffer(physics.body, physics.jumpState, jumpConfig);
+
+      // Snap grounded entities to terrain after horizontal movement
+      if (physics.body.isGrounded) {
+        snapToGround(physics.body, getGroundY, physicsConfig);
+      }
+    }
+
+    // Clean up physics for disconnected players
+    for (const socketId of this.physicsMap.keys()) {
+      if (!sess.state.players.has(socketId)) {
+        this.physicsMap.delete(socketId);
+      }
+    }
+  }
+
+  cleanup(_session: unknown): void {
+    voxelPhysicsRegistry.delete(this.config.areaId);
+    this.physicsMap.clear();
+  }
+
+  /** Access the physics map (needed by entity sync and other systems). */
+  getPhysicsMap(): VoxelPhysicsMap {
+    return this.physicsMap;
+  }
+}

package/template/apps/experiences/diablo/systems/transitionSystem.ts

@@ -0,0 +1,105 @@
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/index.js';
+import type { GameSession } from '../../../../packages/server/src/index.js';
+import type { Server } from 'socket.io';
+import type { AreaManager } from '../../../server/src/areaManager.js';
+import { getOverworldTileType } from '../../../server/src/areaManager.js';
+import { TILE_SIZE } from '../../../game-data/src/world/overworld-layout.js';
+
+interface TransitionDef {
+  cellType?: string;
+  tileType?: string;
+  targetArea: string;
+  spawnX: number;
+  spawnY: number;
+  minX?: number;
+  maxX?: number;
+  minY?: number;
+  maxY?: number;
+}
+
+export interface TransitionSystemConfig {
+  areaId: string;
+  areaType: 'voxel' | 'dungeon' | 'room';
+  transitions: TransitionDef[];
+  areaManager: AreaManager;
+}
+
+/**
+ * Detects area transitions (overworld tile-based and dungeon cell-based).
+ * Extracted from the monolithic game loop.
+ */
+export class TransitionSystem implements ExperienceSystem {
+  readonly id = 'diablo-transition';
+  private config: TransitionSystemConfig;
+  private transitionCooldown = new Map<string, number>();
+
+  constructor(config: TransitionSystemConfig) {
+    this.config = config;
+  }
+
+  update(session: unknown, _dt: number, context: SystemContext): void {
+    const sess = session as GameSession;
+    const io = context.io as Server;
+    const { areaId, areaType, transitions, areaManager } = this.config;
+    const now = Date.now();
+    const isVoxelArea = areaType === 'voxel';
+
+    if (transitions.length === 0) return;
+
+    for (const player of sess.state.players.values()) {
+      const lastTransition = this.transitionCooldown.get(player.socketId) ?? 0;
+      if (now - lastTransition < 1000) continue;
+
+      let matched = false;
+
+      // Tile-based transition (for voxel overworld)
+      if (isVoxelArea) {
+        const tile = getOverworldTileType(areaManager.layout, player.x, player.y);
+        if (tile) {
+          const tr = transitions.find(t => t.tileType && t.tileType === tile.def.type);
+          if (tr) {
+            const tileCenterX = (tile.col + 0.5) * TILE_SIZE;
+            const tileCenterZ = (tile.row + 0.5) * TILE_SIZE;
+            const dx = player.x - tileCenterX;
+            const dz = player.y - tileCenterZ;
+            const distToCenter = Math.sqrt(dx * dx + dz * dz);
+            if (distToCenter <= 4) {
+              this.transitionCooldown.set(player.socketId, now);
+              areaManager.movePlayer(io, player.socketId, tr.targetArea, tr.spawnX, tr.spawnY);
+              matched = true;
+            }
+          }
+        }
+      }
+
+      if (matched) break;
+
+      // Cell-based transition (for dungeons with stamped cells)
+      const cx = Math.round(player.x);
+      const cy = Math.round(player.y);
+      const cell = sess.getCell(cx, cy);
+      if (cell?.type === 'transition') {
+        const tr = transitions.find(t => {
+          if (t.cellType !== 'transition' && t.cellType !== undefined) return false;
+          if (t.minX !== undefined && player.x < t.minX) return false;
+          if (t.maxX !== undefined && player.x > t.maxX) return false;
+          if (t.minY !== undefined && player.y < t.minY) return false;
+          if (t.maxY !== undefined && player.y > t.maxY) return false;
+          return true;
+        });
+        if (tr) {
+          this.transitionCooldown.set(player.socketId, now);
+          let sx = tr.spawnX;
+          let sy = tr.spawnY;
+          if (tr.targetArea === 'overworld' && sx < 0) {
+            const entrance = areaManager.getDungeonEntrancePos();
+            sx = entrance.x - TILE_SIZE * 0.5;
+            sy = entrance.z;
+          }
+          areaManager.movePlayer(io, player.socketId, tr.targetArea, sx, sy);
+          break;
+        }
+      }
+    }
+  }
+}

package/template/apps/experiences/runner/data/runner-config.ts

@@ -0,0 +1,54 @@
+/**
+ * Runner experience configuration — speed, physics, lane settings.
+ */
+
+import type { CharacterConfig } from '../../../../packages/core/src/physics/characterController.js';
+import type { PhysicsConfig } from '../../../../packages/core/src/physics/gravity.js';
+import type { JumpConfig } from '../../../../packages/core/src/physics/jump.js';
+
+/** Character controller config tuned for runner feel */
+export const RUNNER_CHARACTER_CONFIG: CharacterConfig = {
+  walkSpeed: 10,           // Base auto-run speed (overridden by speed curve)
+  sprintMultiplier: 1,     // No manual sprint in runner
+  maxSpeed: 30,            // Allows speed curve to go high
+  friction: 30,            // Snappy deceleration
+  airFriction: 3,          // Low air friction for glide momentum
+  airControl: 0.5,         // Moderate air control for lane adjustment mid-jump
+  glideGravityMultiplier: 0.25, // Reduced gravity while gliding
+  glideFriction: 1,        // Very low friction while gliding
+  acceleration: 50,        // Fast acceleration (auto-run, not manual)
+};
+
+/** Physics config for runner — slightly reduced gravity for more floaty jumps */
+export const RUNNER_PHYSICS_CONFIG: PhysicsConfig = {
+  gravity: -18,
+  terminalVelocity: -40,
+  groundSnapThreshold: 0.5,
+};
+
+/** Jump config for runner — generous coyote time, no double jump (glide instead) */
+export const RUNNER_JUMP_CONFIG: JumpConfig = {
+  jumpVelocity: 10,
+  coyoteTime: 0.15,
+  jumpBuffer: 0.15,
+  allowDoubleJump: false,
+};
+
+/** Base speed at distance 0 */
+export const BASE_SPEED = 10;
+
+/** Maximum speed cap */
+export const MAX_SPEED = 25;
+
+/** How fast speed increases with distance */
+export const SPEED_RAMP_RATE = 0.002;
+
+/** Y threshold below which player is considered dead (fell off track) */
+export const DEATH_Y_THRESHOLD = -10;
+
+/**
+ * Speed increases linearly with distance, capped at MAX_SPEED.
+ */
+export function getSpeedForDistance(distance: number): number {
+  return Math.min(BASE_SPEED + distance * SPEED_RAMP_RATE, MAX_SPEED);
+}

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

@@ -0,0 +1,143 @@
+/**
+ * Runner Experience — Infinity Runner with procedural track generation.
+ *
+ * Provides:
+ * - RunnerExperience: ExperienceDefinition for hub registration
+ * - RunnerSession: custom session state for runner gameplay
+ * - RunnerPlayer: per-player state including physics body, lane, track
+ */
+
+import type { ExperienceDefinition, ExperienceSystem, PhysicsBody } from '../../../packages/core/src/index.js';
+import { createPhysicsBody } from '../../../packages/core/src/index.js';
+import type { CharacterModifier } from '../../../packages/core/src/physics/modifiers.js';
+import type { TrackGeneratorState } from './track/trackGenerator.js';
+import { createTrackGenerator } from './track/trackGenerator.js';
+import type { LaneState } from './track/laneSystem.js';
+import { createLaneState } from './track/laneSystem.js';
+import type { JumpState } from '../../../packages/core/src/physics/jump.js';
+import { createJumpState } from '../../../packages/core/src/physics/jump.js';
+import { RUNNER_PHYSICS_CONFIG } from './data/runner-config.js';
+import { RunnerPhysicsSystem } from './systems/runnerPhysicsSystem.js';
+import { TrackStreamSystem } from './systems/trackStreamSystem.js';
+import { DeathSystem } from './systems/deathSystem.js';
+import { CollectibleSystem } from './systems/collectibleSystem.js';
+import { ObstacleSystem } from './systems/obstacleSystem.js';
+import { RunnerEntitySyncSystem } from './systems/entitySyncSystem.js';
+
+// ---------------------------------------------------------------------------
+// Runner-specific session & player state
+// ---------------------------------------------------------------------------
+
+export interface ComboState {
+  count: number;
+  /** Time remaining before combo resets (seconds) */
+  timer: number;
+}
+
+export interface RunnerPlayer {
+  socketId: string;
+  playerId: string;
+  entityId: number;
+  body: PhysicsBody;
+  jumpState: JumpState;
+  lane: LaneState;
+  track: TrackGeneratorState;
+  distanceRan: number;
+  isGliding: boolean;
+  dead: boolean;
+  /** Input flags from client */
+  input: {
+    left: boolean;
+    right: boolean;
+    jump: boolean;
+    glide: boolean;
+  };
+  /** Score state */
+  score: number;
+  coins: number;
+  gems: number;
+  bestCombo: number;
+  combo: ComboState;
+  /** Active character modifiers from powerups */
+  modifiers: CharacterModifier[];
+  /** Magnet powerup state */
+  magnetActive: boolean;
+  magnetTimer: number;
+  /** Gravity modifier from low-gravity powerup */
+  gravityModifier: { multiplier: number; remainingTime: number } | null;
+  /** Session high score */
+  highScore: number;
+  /** Next unique ID for collectibles/obstacles */
+  nextItemId: number;
+}
+
+export interface RunnerSession {
+  seed: number;
+  players: Map<string, RunnerPlayer>;
+  nextEntityId: number;
+}
+
+export function createRunnerSession(seed: number): RunnerSession {
+  return {
+    seed,
+    players: new Map(),
+    nextEntityId: 1,
+  };
+}
+
+export function addRunnerPlayer(session: RunnerSession, socketId: string, playerId: string): RunnerPlayer {
+  const entityId = session.nextEntityId++;
+  const player: RunnerPlayer = {
+    socketId,
+    playerId,
+    entityId,
+    body: createPhysicsBody(0, 0, 0), // Start at origin, center lane
+    jumpState: createJumpState(),
+    lane: createLaneState(),
+    track: createTrackGenerator(session.seed),
+    distanceRan: 0,
+    isGliding: false,
+    dead: false,
+    input: { left: false, right: false, jump: false, glide: false },
+    score: 0,
+    coins: 0,
+    gems: 0,
+    bestCombo: 0,
+    combo: { count: 0, timer: 0 },
+    modifiers: [],
+    magnetActive: false,
+    magnetTimer: 0,
+    gravityModifier: null,
+    highScore: 0,
+    nextItemId: 1,
+  };
+  session.players.set(socketId, player);
+  return player;
+}
+
+export function removeRunnerPlayer(session: RunnerSession, socketId: string): void {
+  session.players.delete(socketId);
+}
+
+// ---------------------------------------------------------------------------
+// Experience Definition
+// ---------------------------------------------------------------------------
+
+export class RunnerExperience implements ExperienceDefinition {
+  readonly id = 'runner';
+  readonly name = 'Infinity Runner';
+  readonly description = 'Run endlessly on a procedural track. Jump, glide, and dodge obstacles.';
+  readonly defaultCameraMode = 'follow' as const;
+  readonly physicsConfig = RUNNER_PHYSICS_CONFIG;
+
+  createSystems(): ExperienceSystem[] {
+    return [
+      new TrackStreamSystem(),
+      new RunnerPhysicsSystem(),
+      new CollectibleSystem(),
+      new ObstacleSystem(),
+      new DeathSystem(),
+      new RunnerEntitySyncSystem(),
+    ];
+  }
+}