@loonylabs/create-game 0.1.0

package/template/apps/experiences/runner/systems/collectibleSystem.ts

@@ -0,0 +1,157 @@
+/**
+ * Collectible & powerup pickup system for Runner experience.
+ * Handles coin/gem collection, powerup application, combo tracking, and score.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { CharacterModifier } from '../../../../packages/core/src/physics/modifiers.js';
+import { updateModifiers } from '../../../../packages/core/src/physics/modifiers.js';
+import type { RunnerSession, RunnerPlayer } from '../index.js';
+import type { PlacedCollectible, PlacedPowerup } from '../track/segmentTypes.js';
+import { LANE_WIDTH } from '../track/laneSystem.js';
+import { getSpeedForDistance } from '../data/runner-config.js';
+
+/** Pickup radius in world units */
+const PICKUP_RADIUS = 1.5;
+/** Magnet pickup radius */
+const MAGNET_RADIUS = 6;
+/** Combo timeout in seconds */
+const COMBO_TIMEOUT = 3;
+
+/** Get combo multiplier based on consecutive collects */
+export function getComboMultiplier(count: number): number {
+  if (count >= 20) return 5;
+  if (count >= 10) return 3;
+  if (count >= 5) return 2;
+  return 1;
+}
+
+/** Check if a collectible/powerup is in pickup range */
+export function isInPickupRange(
+  playerX: number,
+  playerZ: number,
+  itemX: number,
+  itemZ: number,
+  magnetActive: boolean,
+): boolean {
+  const dx = playerX - itemX;
+  const dz = playerZ - itemZ;
+  const dist = Math.sqrt(dx * dx + dz * dz);
+  return dist < (magnetActive ? MAGNET_RADIUS : PICKUP_RADIUS);
+}
+
+/** Apply a powerup effect to a player */
+export function applyPowerup(player: RunnerPlayer, type: string): void {
+  switch (type) {
+    case 'speed-boost':
+      player.modifiers.push({
+        id: 'speed-boost',
+        multipliers: { walkSpeed: 1.5, maxSpeed: 1.5 },
+        remainingTime: 5,
+      });
+      break;
+    case 'low-gravity':
+      player.gravityModifier = { multiplier: 0.3, remainingTime: 5 };
+      break;
+    case 'magnet':
+      player.magnetActive = true;
+      player.magnetTimer = 8;
+      break;
+  }
+}
+
+export class CollectibleSystem implements ExperienceSystem {
+  readonly id = 'runner-collectibles';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    const io = context.io as import('socket.io').Server;
+
+    for (const player of s.players.values()) {
+      if (player.dead) continue;
+
+      const playerX = player.body.x;
+      const playerZ = player.body.z;
+
+      // Check collectible pickups across all active segments
+      for (const segment of player.track.segments) {
+        for (const collectible of segment.collectibles) {
+          if (collectible.collected) continue;
+          if (isInPickupRange(playerX, playerZ, collectible.x, collectible.z, player.magnetActive)) {
+            collectible.collected = true;
+            const value = collectible.type === 'gem' ? 100 : 10;
+            const multiplier = getComboMultiplier(player.combo.count);
+            player.score += value * multiplier;
+            if (collectible.type === 'gem') player.gems++;
+            else player.coins++;
+            player.combo.count++;
+            player.combo.timer = COMBO_TIMEOUT;
+            if (player.combo.count > player.bestCombo) {
+              player.bestCombo = player.combo.count;
+            }
+
+            // Notify client
+            const sock = io.sockets.sockets.get(player.socketId);
+            if (sock) {
+              sock.emit('message', {
+                type: 'RUNNER_COLLECT',
+                collectibleType: collectible.type,
+                value,
+                multiplier,
+                combo: player.combo.count,
+              });
+            }
+          }
+        }
+
+        // Check powerup pickup
+        if (segment.powerup && !segment.powerup.collected) {
+          if (isInPickupRange(playerX, playerZ, segment.powerup.x, segment.powerup.z, false)) {
+            segment.powerup.collected = true;
+            applyPowerup(player, segment.powerup.type);
+
+            const sock = io.sockets.sockets.get(player.socketId);
+            if (sock) {
+              sock.emit('message', {
+                type: 'RUNNER_POWERUP',
+                powerupType: segment.powerup.type,
+              });
+            }
+          }
+        }
+      }
+
+      // Update combo timer
+      if (player.combo.count > 0) {
+        player.combo.timer -= dt;
+        if (player.combo.timer <= 0) {
+          player.combo.count = 0;
+          player.combo.timer = 0;
+        }
+      }
+
+      // Distance score: 1 point per unit
+      player.score += getSpeedForDistance(player.distanceRan) * dt;
+
+      // Update modifiers (expire speed boost etc.)
+      player.modifiers = updateModifiers(player.modifiers, dt);
+
+      // Update magnet timer
+      if (player.magnetActive) {
+        player.magnetTimer -= dt;
+        if (player.magnetTimer <= 0) {
+          player.magnetActive = false;
+          player.magnetTimer = 0;
+        }
+      }
+
+      // Update gravity modifier timer
+      if (player.gravityModifier) {
+        player.gravityModifier.remainingTime -= dt;
+        if (player.gravityModifier.remainingTime <= 0) {
+          player.gravityModifier = null;
+        }
+      }
+    }
+  }
+}

package/template/apps/experiences/runner/systems/deathSystem.ts

@@ -0,0 +1,42 @@
+/**
+ * Death detection system — player falls off track = death.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { RunnerSession } from '../index.js';
+import { DEATH_Y_THRESHOLD } from '../data/runner-config.js';
+
+export class DeathSystem implements ExperienceSystem {
+  readonly id = 'runner-death';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    const io = context.io as import('socket.io').Server;
+
+    for (const player of s.players.values()) {
+      if (player.dead) continue;
+
+      // Death: fell below threshold
+      if (player.body.y < DEATH_Y_THRESHOLD) {
+        player.dead = true;
+        const finalScore = Math.floor(player.score);
+        if (finalScore > player.highScore) {
+          player.highScore = finalScore;
+        }
+        const sock = io.sockets.sockets.get(player.socketId);
+        if (sock) {
+          sock.emit('message', {
+            type: 'RUNNER_DEAD',
+            distance: Math.floor(player.distanceRan),
+            score: finalScore,
+            coins: player.coins,
+            gems: player.gems,
+            bestCombo: player.bestCombo,
+            highScore: player.highScore,
+            cause: 'fall',
+          });
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Entity sync system for Runner — broadcasts player positions.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { RunnerSession } from '../index.js';
+
+export class RunnerEntitySyncSystem implements ExperienceSystem {
+  readonly id = 'runner-entity-sync';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    const io = context.io as import('socket.io').Server;
+
+    const entities: Array<{
+      entityId: number;
+      x: number;
+      y: number;
+      worldY: number;
+      type: string;
+    }> = [];
+
+    for (const player of s.players.values()) {
+      entities.push({
+        entityId: player.entityId,
+        x: player.body.x,
+        y: player.body.z,    // y in 2D = z in 3D (forward)
+        worldY: player.body.y, // vertical height
+        type: 'player',
+      });
+    }
+
+    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,
+        });
+
+        // Send runner state update
+        sock.emit('message', {
+          type: 'RUNNER_STATE',
+          distance: Math.floor(player.distanceRan),
+          speed: player.body.velocityZ,
+          lane: player.lane.currentLane,
+          isGliding: player.isGliding,
+          score: Math.floor(player.score),
+          coins: player.coins,
+          combo: player.combo.count,
+          magnetActive: player.magnetActive,
+          hasSpeedBoost: player.modifiers.some(m => m.id === 'speed-boost'),
+          hasLowGravity: player.gravityModifier !== null,
+        });
+      }
+    }
+  }
+}

package/template/apps/experiences/runner/systems/obstacleSystem.ts

@@ -0,0 +1,91 @@
+/**
+ * Obstacle collision system for Runner experience.
+ * Checks if the player collides with obstacles on the track.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { RunnerSession } from '../index.js';
+import type { PlacedObstacle } from '../track/segmentTypes.js';
+import { LANE_WIDTH } from '../track/laneSystem.js';
+
+/** How close the player must be in Z to trigger obstacle collision */
+const OBSTACLE_Z_TOLERANCE = 0.8;
+/** How close the player must be in X (lane) to trigger collision */
+const OBSTACLE_X_TOLERANCE = 0.8;
+
+/**
+ * Check if a player collides with an obstacle.
+ * Returns true if the player should die.
+ */
+export function checkObstacleCollision(
+  playerX: number,
+  playerY: number,
+  playerZ: number,
+  obstacle: PlacedObstacle,
+): boolean {
+  const dx = Math.abs(playerX - obstacle.x);
+  const dz = Math.abs(playerZ - obstacle.z);
+
+  if (dx > OBSTACLE_X_TOLERANCE || dz > OBSTACLE_Z_TOLERANCE) return false;
+
+  switch (obstacle.type) {
+    case 'wall':
+      // Wall blocks entire height — always fatal
+      return true;
+    case 'low-barrier':
+      // Low barrier — can jump over (player Y must be above barrier height)
+      return playerY < obstacle.height;
+    case 'high-barrier':
+      // High barrier — blocks upper space, must stay low (not jumping)
+      // Fatal if player is in the air above ground level
+      return playerY > 0.5;
+    default:
+      return false;
+  }
+}
+
+export class ObstacleSystem implements ExperienceSystem {
+  readonly id = 'runner-obstacles';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    const io = context.io as import('socket.io').Server;
+
+    for (const player of s.players.values()) {
+      if (player.dead) continue;
+
+      const playerX = player.body.x;
+      const playerY = player.body.y;
+      const playerZ = player.body.z;
+
+      for (const segment of player.track.segments) {
+        for (const obstacle of segment.obstacles) {
+          if (checkObstacleCollision(playerX, playerY, playerZ, obstacle)) {
+            player.dead = true;
+            // Update high score
+            const finalScore = Math.floor(player.score);
+            if (finalScore > player.highScore) {
+              player.highScore = finalScore;
+            }
+
+            const sock = io.sockets.sockets.get(player.socketId);
+            if (sock) {
+              sock.emit('message', {
+                type: 'RUNNER_DEAD',
+                distance: Math.floor(player.distanceRan),
+                score: finalScore,
+                coins: player.coins,
+                gems: player.gems,
+                bestCombo: player.bestCombo,
+                highScore: player.highScore,
+                cause: obstacle.type,
+              });
+            }
+            break;
+          }
+        }
+        if (player.dead) break;
+      }
+    }
+  }
+}

package/template/apps/experiences/runner/systems/runnerPhysicsSystem.ts

@@ -0,0 +1,82 @@
+/**
+ * Runner physics system — auto-run forward, lane movement, jump, glide, gravity.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { RunnerSession } from '../index.js';
+import { updatePhysicsBody } from '../../../../packages/core/src/physics/gravity.js';
+import { updateJumpState, tryJump } from '../../../../packages/core/src/physics/jump.js';
+import { getGlideGravityMultiplier } from '../../../../packages/core/src/physics/characterController.js';
+import { applyModifiers } from '../../../../packages/core/src/physics/modifiers.js';
+import { requestLaneSwitch, updateLane } from '../track/laneSystem.js';
+import { getTrackGroundHeight } from '../track/trackGenerator.js';
+import { RUNNER_PHYSICS_CONFIG, RUNNER_CHARACTER_CONFIG, RUNNER_JUMP_CONFIG, getSpeedForDistance } from '../data/runner-config.js';
+
+export class RunnerPhysicsSystem implements ExperienceSystem {
+  readonly id = 'runner-physics';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    for (const player of s.players.values()) {
+      if (player.dead) continue;
+
+      // Process lane input (inverted: camera looks in +Z, so screen-left = +X)
+      if (player.input.left) {
+        requestLaneSwitch(player.lane, 1);
+        player.input.left = false; // consume input
+      }
+      if (player.input.right) {
+        requestLaneSwitch(player.lane, -1);
+        player.input.right = false;
+      }
+
+      // Process jump input
+      if (player.input.jump) {
+        tryJump(player.body, player.jumpState, RUNNER_JUMP_CONFIG);
+        player.input.jump = false;
+      }
+
+      // Glide state
+      player.isGliding = player.input.glide && !player.body.isGrounded;
+
+      // Update lane interpolation
+      updateLane(player.lane, dt);
+
+      // Apply character modifiers (speed boost etc.)
+      const effectiveConfig = player.modifiers.length > 0
+        ? applyModifiers(RUNNER_CHARACTER_CONFIG, player.modifiers)
+        : RUNNER_CHARACTER_CONFIG;
+
+      // Auto-run: constant forward velocity (Z axis), modified by powerups
+      const baseSpeed = getSpeedForDistance(player.distanceRan);
+      const speedMultiplier = effectiveConfig.walkSpeed / RUNNER_CHARACTER_CONFIG.walkSpeed;
+      const speed = baseSpeed * speedMultiplier;
+      player.body.velocityZ = speed;
+
+      // Lane movement (X axis) — directly set X from lane offset
+      player.body.x = player.lane.laneOffset;
+
+      // Apply forward movement
+      player.body.z += player.body.velocityZ * dt;
+
+      // Apply glide and low-gravity powerup gravity modifiers
+      const glideMultiplier = getGlideGravityMultiplier(player.body, player.isGliding, effectiveConfig);
+      const gravityPowerupMultiplier = player.gravityModifier ? player.gravityModifier.multiplier : 1;
+      const totalGravityMultiplier = glideMultiplier * gravityPowerupMultiplier;
+      const physicsConfig = totalGravityMultiplier < 1
+        ? { ...RUNNER_PHYSICS_CONFIG, gravity: RUNNER_PHYSICS_CONFIG.gravity * totalGravityMultiplier }
+        : RUNNER_PHYSICS_CONFIG;
+
+      // Ground height based on track
+      const groundHeightFn = (x: number, z: number) =>
+        getTrackGroundHeight(player.track, x, z);
+
+      // Update vertical physics (gravity, ground snap)
+      updateJumpState(player.jumpState, player.body, dt);
+      updatePhysicsBody(player.body, dt, groundHeightFn, physicsConfig);
+
+      // Update distance ran
+      player.distanceRan += speed * dt;
+    }
+  }
+}

package/template/apps/experiences/runner/systems/trackStreamSystem.ts

@@ -0,0 +1,19 @@
+/**
+ * Track streaming system — generates segments ahead, disposes behind.
+ */
+
+import type { ExperienceSystem, SystemContext } from '../../../../packages/core/src/experience/types.js';
+import type { RunnerSession } from '../index.js';
+import { updateTrack } from '../track/trackGenerator.js';
+
+export class TrackStreamSystem implements ExperienceSystem {
+  readonly id = 'runner-track-stream';
+
+  update(session: unknown, dt: number, context: SystemContext): void {
+    const s = session as RunnerSession;
+    for (const player of s.players.values()) {
+      if (player.dead) continue;
+      updateTrack(player.track, player.body.z, 200, 50);
+    }
+  }
+}

package/template/apps/experiences/runner/track/laneSystem.ts

@@ -0,0 +1,53 @@
+/**
+ * 3-lane switching system for the Runner experience.
+ * Smooth interpolation between lanes.
+ */
+
+export type Lane = -1 | 0 | 1; // left, center, right
+
+export interface LaneState {
+  currentLane: Lane;
+  targetLane: Lane;
+  /** Current X offset (smooth interpolation) */
+  laneOffset: number;
+  /** Time remaining in lane switch animation */
+  switchTimer: number;
+}
+
+/** Distance between lane centers in world units */
+export const LANE_WIDTH = 2;
+
+/** Duration of a lane switch in seconds */
+export const LANE_SWITCH_TIME = 0.15;
+
+export function createLaneState(): LaneState {
+  return { currentLane: 0, targetLane: 0, laneOffset: 0, switchTimer: 0 };
+}
+
+/**
+ * Request a lane switch. Direction: -1 = left, 1 = right.
+ * Clamped to valid lane bounds (-1 to 1).
+ */
+export function requestLaneSwitch(state: LaneState, direction: -1 | 1): void {
+  const newLane = Math.max(-1, Math.min(1, state.currentLane + direction)) as Lane;
+  if (newLane !== state.currentLane) {
+    state.targetLane = newLane;
+    state.switchTimer = LANE_SWITCH_TIME;
+  }
+}
+
+/**
+ * Update lane interpolation. Call every tick.
+ */
+export function updateLane(state: LaneState, dt: number): void {
+  if (state.switchTimer > 0) {
+    state.switchTimer -= dt;
+    if (state.switchTimer <= 0) {
+      state.currentLane = state.targetLane;
+      state.switchTimer = 0;
+    }
+  }
+  // Smooth interpolation toward target lane position
+  const targetX = state.targetLane * LANE_WIDTH;
+  state.laneOffset += (targetX - state.laneOffset) * Math.min(1, dt * 15);
+}

package/template/apps/experiences/runner/track/segmentTypes.ts

@@ -0,0 +1,141 @@
+/**
+ * Segment type definitions for the Runner track generator.
+ */
+
+export type SegmentType = 'straight' | 'gap' | 'ramp' | 'narrow-left' | 'narrow-right' | 'narrow-center';
+
+export type CollectibleType = 'coin' | 'gem';
+export type PowerupType = 'speed-boost' | 'low-gravity' | 'magnet';
+export type ObstacleType = 'wall' | 'low-barrier' | 'high-barrier';
+
+export type Lane = -1 | 0 | 1;
+
+export interface SegmentCollectible {
+  lane: Lane;
+  /** Offset from segment start along Z (0-1 fraction of length) */
+  offset: number;
+  type: CollectibleType;
+}
+
+export interface SegmentPowerup {
+  lane: Lane;
+  offset: number;
+  type: PowerupType;
+}
+
+export interface SegmentObstacle {
+  lane: Lane;
+  offset: number;
+  type: ObstacleType;
+  /** Height of obstacle (for low-barrier/high-barrier checks) */
+  height: number;
+}
+
+export interface SegmentDef {
+  type: SegmentType;
+  /** Segment length in units along Z axis */
+  length: number;
+  /** Which lanes exist: [left, center, right] */
+  lanes: [boolean, boolean, boolean];
+  /** Ramp upward angle in radians (only for ramp type) */
+  rampAngle?: number;
+  /** Gap length within the segment (only for gap type) */
+  gapLength?: number;
+  /** Height of the ramp peak (only for ramp type) */
+  rampHeight?: number;
+  /** Collectibles placed on this segment */
+  collectibles?: SegmentCollectible[];
+  /** Powerup on this segment (at most one) */
+  powerup?: SegmentPowerup;
+  /** Obstacles on this segment */
+  obstacles?: SegmentObstacle[];
+}
+
+export interface PlacedCollectible {
+  id: number;
+  type: CollectibleType;
+  lane: Lane;
+  x: number;
+  y: number;
+  z: number;
+  collected: boolean;
+}
+
+export interface PlacedPowerup {
+  id: number;
+  type: PowerupType;
+  lane: Lane;
+  x: number;
+  y: number;
+  z: number;
+  collected: boolean;
+}
+
+export interface PlacedObstacle {
+  id: number;
+  type: ObstacleType;
+  lane: Lane;
+  x: number;
+  z: number;
+  height: number;
+}
+
+export interface PlacedSegment {
+  def: SegmentDef;
+  /** World Z position where segment starts */
+  startZ: number;
+  /** startZ + length */
+  endZ: number;
+  /** Segment number (for difficulty calculation) */
+  index: number;
+  /** Runtime: placed collectibles with world positions */
+  collectibles: PlacedCollectible[];
+  /** Runtime: placed powerup with world position */
+  powerup: PlacedPowerup | null;
+  /** Runtime: placed obstacles with world positions */
+  obstacles: PlacedObstacle[];
+}
+
+/** All 3 lanes exist */
+export const STRAIGHT_SEGMENT: SegmentDef = {
+  type: 'straight',
+  length: 20,
+  lanes: [true, true, true],
+};
+
+/** Gap in the middle — must jump */
+export const GAP_SEGMENT: SegmentDef = {
+  type: 'gap',
+  length: 20,
+  lanes: [true, true, true],
+  gapLength: 6,
+};
+
+/** Ramp launches player upward */
+export const RAMP_SEGMENT: SegmentDef = {
+  type: 'ramp',
+  length: 20,
+  lanes: [true, true, true],
+  rampHeight: 4,
+};
+
+/** Only center and right lanes */
+export const NARROW_LEFT_SEGMENT: SegmentDef = {
+  type: 'narrow-left',
+  length: 15,
+  lanes: [false, true, true],
+};
+
+/** Only left and center lanes */
+export const NARROW_RIGHT_SEGMENT: SegmentDef = {
+  type: 'narrow-right',
+  length: 15,
+  lanes: [true, true, false],
+};
+
+/** Only center lane */
+export const NARROW_CENTER_SEGMENT: SegmentDef = {
+  type: 'narrow-center',
+  length: 12,
+  lanes: [false, true, false],
+};