@loonylabs/create-game 0.1.0

package/template/apps/server/src/tests/runner-experience.test.ts

@@ -0,0 +1,273 @@
+import { describe, test, expect } from 'vitest';
+import { RunnerExperience, createRunnerSession, addRunnerPlayer, removeRunnerPlayer } from '../../../experiences/runner/index.js';
+import {
+  createTrackGenerator,
+  updateTrack,
+  getTrackGroundHeight,
+} from '../../../experiences/runner/track/trackGenerator.js';
+import {
+  createLaneState,
+  requestLaneSwitch,
+  updateLane,
+  LANE_WIDTH,
+} from '../../../experiences/runner/track/laneSystem.js';
+import { getSpeedForDistance, BASE_SPEED, MAX_SPEED } from '../../../experiences/runner/data/runner-config.js';
+
+// ---------------------------------------------------------------------------
+// RunnerExperience
+// ---------------------------------------------------------------------------
+
+describe('RunnerExperience', () => {
+  test('implements ExperienceDefinition', () => {
+    const exp = new RunnerExperience();
+    expect(exp.id).toBe('runner');
+    expect(exp.name).toBeDefined();
+    expect(exp.description).toBeDefined();
+    expect(exp.defaultCameraMode).toBe('follow');
+  });
+
+  test('createSystems returns non-empty list', () => {
+    const exp = new RunnerExperience();
+    const systems = exp.createSystems();
+    expect(systems.length).toBe(6);
+    expect(systems.map(s => s.id)).toEqual([
+      'runner-track-stream', 'runner-physics', 'runner-collectibles', 'runner-obstacles', 'runner-death', 'runner-entity-sync',
+    ]);
+  });
+
+  test('systems have unique ids', () => {
+    const exp = new RunnerExperience();
+    const ids = exp.createSystems().map(s => s.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// RunnerSession
+// ---------------------------------------------------------------------------
+
+describe('RunnerSession', () => {
+  test('create session with seed', () => {
+    const session = createRunnerSession(42);
+    expect(session.seed).toBe(42);
+    expect(session.players.size).toBe(0);
+  });
+
+  test('add and remove player', () => {
+    const session = createRunnerSession(42);
+    const player = addRunnerPlayer(session, 'sock1', 'player1');
+    expect(player.entityId).toBe(1);
+    expect(session.players.size).toBe(1);
+    expect(player.body.x).toBe(0);
+    expect(player.body.z).toBe(0);
+    expect(player.dead).toBe(false);
+
+    removeRunnerPlayer(session, 'sock1');
+    expect(session.players.size).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Track Generator
+// ---------------------------------------------------------------------------
+
+describe('TrackGenerator', () => {
+  test('generates segments ahead of player', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 200, 50);
+    expect(state.segments.length).toBeGreaterThan(0);
+    expect(state.segments[state.segments.length - 1].endZ).toBeGreaterThanOrEqual(200);
+  });
+
+  test('disposes segments behind player', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 200, 50);
+    // Move player far ahead — segments with endZ < (playerZ - bufferBehind) should be removed
+    updateTrack(state, 300, 200, 50);
+    // All remaining segments should have endZ > 300 - 50 = 250
+    expect(state.segments.every(s => s.endZ > 250)).toBe(true);
+    // And there should be segments ahead of playerZ
+    expect(state.segments.some(s => s.endZ >= 500)).toBe(true);
+  });
+
+  test('same seed produces same track', () => {
+    const s1 = createTrackGenerator(42);
+    const s2 = createTrackGenerator(42);
+    updateTrack(s1, 0, 500, 0);
+    updateTrack(s2, 0, 500, 0);
+    expect(s1.segments.map(s => s.def.type)).toEqual(s2.segments.map(s => s.def.type));
+  });
+
+  test('different seeds produce different tracks', () => {
+    const s1 = createTrackGenerator(42);
+    const s2 = createTrackGenerator(999);
+    updateTrack(s1, 0, 1000, 0);
+    updateTrack(s2, 0, 1000, 0);
+    const types1 = s1.segments.map(s => s.def.type).join(',');
+    const types2 = s2.segments.map(s => s.def.type).join(',');
+    expect(types1).not.toEqual(types2);
+  });
+
+  test('first 3 segments are straight (grace period)', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 200, 0);
+    expect(state.segments[0].def.type).toBe('straight');
+    expect(state.segments[1].def.type).toBe('straight');
+    expect(state.segments[2].def.type).toBe('straight');
+  });
+
+  test('difficulty increases with index (more non-straight segments later)', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 3000, 0);
+    const earlyNonStraight = state.segments.filter(s => s.index >= 3 && s.index < 15 && s.def.type !== 'straight').length;
+    const lateNonStraight = state.segments.filter(s => s.index >= 40 && s.def.type !== 'straight').length;
+    // Late segments should have more variety (or at least not fewer)
+    expect(lateNonStraight).toBeGreaterThanOrEqual(earlyNonStraight);
+  });
+
+  test('segments connect seamlessly (no gaps between segments)', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 500, 0);
+    for (let i = 1; i < state.segments.length; i++) {
+      expect(state.segments[i].startZ).toBeCloseTo(state.segments[i - 1].endZ, 5);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Ground Height
+// ---------------------------------------------------------------------------
+
+describe('getTrackGroundHeight', () => {
+  test('returns 0 for straight segment center lane', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 100, 0);
+    const height = getTrackGroundHeight(state, 0, 5); // center lane, z=5
+    expect(height).toBe(0);
+  });
+
+  test('returns null outside any segment', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 100, 0);
+    const height = getTrackGroundHeight(state, 0, -10);
+    expect(height).toBeNull();
+  });
+
+  test('returns null in gap', () => {
+    const state = createTrackGenerator(42);
+    // Generate until we find a gap segment
+    updateTrack(state, 0, 3000, 0);
+    const gap = state.segments.find(s => s.def.type === 'gap');
+    if (gap) {
+      const midZ = (gap.startZ + gap.endZ) / 2;
+      const height = getTrackGroundHeight(state, 0, midZ);
+      expect(height).toBeNull();
+    }
+  });
+
+  test('returns > 0 on ramp peak', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 3000, 0);
+    const ramp = state.segments.find(s => s.def.type === 'ramp');
+    if (ramp) {
+      const midZ = (ramp.startZ + ramp.endZ) / 2;
+      const height = getTrackGroundHeight(state, 0, midZ);
+      expect(height).not.toBeNull();
+      expect(height!).toBeGreaterThan(0);
+    }
+  });
+
+  test('returns null for missing lane in narrow segment', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 3000, 0);
+    const narrow = state.segments.find(s => s.def.type === 'narrow-left');
+    if (narrow) {
+      const midZ = (narrow.startZ + narrow.endZ) / 2;
+      // Left lane (x = -LANE_WIDTH) should be missing in narrow-left
+      const height = getTrackGroundHeight(state, -LANE_WIDTH, midZ);
+      expect(height).toBeNull();
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lane System
+// ---------------------------------------------------------------------------
+
+describe('LaneSystem', () => {
+  test('starts at center lane', () => {
+    const state = createLaneState();
+    expect(state.currentLane).toBe(0);
+    expect(state.laneOffset).toBe(0);
+  });
+
+  test('lane switch moves to target', () => {
+    const state = createLaneState();
+    requestLaneSwitch(state, 1); // switch right
+    expect(state.targetLane).toBe(1);
+    // Simulate to completion
+    for (let i = 0; i < 20; i++) updateLane(state, 0.05);
+    expect(state.currentLane).toBe(1);
+    expect(state.laneOffset).toBeCloseTo(LANE_WIDTH, 0);
+  });
+
+  test('cannot switch beyond lane bounds (right)', () => {
+    const state = createLaneState();
+    state.currentLane = 1;
+    state.targetLane = 1;
+    state.laneOffset = LANE_WIDTH;
+    requestLaneSwitch(state, 1); // try to go further right
+    expect(state.targetLane).toBe(1); // stays at 1
+  });
+
+  test('cannot switch beyond lane bounds (left)', () => {
+    const state = createLaneState();
+    state.currentLane = -1;
+    state.targetLane = -1;
+    state.laneOffset = -LANE_WIDTH;
+    requestLaneSwitch(state, -1); // try to go further left
+    expect(state.targetLane).toBe(-1); // stays at -1
+  });
+
+  test('double switch reaches lane 1 from -1', () => {
+    const state = createLaneState();
+    state.currentLane = -1;
+    state.targetLane = -1;
+    state.laneOffset = -LANE_WIDTH;
+
+    requestLaneSwitch(state, 1);
+    for (let i = 0; i < 20; i++) updateLane(state, 0.05);
+    expect(state.currentLane).toBe(0);
+
+    requestLaneSwitch(state, 1);
+    for (let i = 0; i < 20; i++) updateLane(state, 0.05);
+    expect(state.currentLane).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Speed Curve
+// ---------------------------------------------------------------------------
+
+describe('getSpeedForDistance', () => {
+  test('starts at base speed', () => {
+    expect(getSpeedForDistance(0)).toBe(BASE_SPEED);
+  });
+
+  test('caps at max speed', () => {
+    expect(getSpeedForDistance(100000)).toBe(MAX_SPEED);
+  });
+
+  test('increases with distance', () => {
+    expect(getSpeedForDistance(1000)).toBeGreaterThan(getSpeedForDistance(0));
+  });
+
+  test('monotonically increases up to cap', () => {
+    let prev = 0;
+    for (let d = 0; d <= 10000; d += 500) {
+      const speed = getSpeedForDistance(d);
+      expect(speed).toBeGreaterThanOrEqual(prev);
+      prev = speed;
+    }
+  });
+});

package/template/apps/server/src/tests/runner-powerups-scoring.test.ts

@@ -0,0 +1,221 @@
+import { describe, test, expect } from 'vitest';
+import { createRunnerSession, addRunnerPlayer } from '../../../experiences/runner/index.js';
+import {
+  createTrackGenerator,
+  updateTrack,
+} from '../../../experiences/runner/track/trackGenerator.js';
+import {
+  getComboMultiplier,
+  isInPickupRange,
+  applyPowerup,
+} from '../../../experiences/runner/systems/collectibleSystem.js';
+import {
+  checkObstacleCollision,
+} from '../../../experiences/runner/systems/obstacleSystem.js';
+import { updateModifiers } from '../../../../packages/core/src/physics/modifiers.js';
+import type { PlacedObstacle } from '../../../experiences/runner/track/segmentTypes.js';
+
+// ---------------------------------------------------------------------------
+// Combo System
+// ---------------------------------------------------------------------------
+
+describe('getComboMultiplier', () => {
+  test('x1 for 0-4 consecutive', () => {
+    expect(getComboMultiplier(0)).toBe(1);
+    expect(getComboMultiplier(4)).toBe(1);
+  });
+
+  test('x2 for 5-9', () => {
+    expect(getComboMultiplier(5)).toBe(2);
+    expect(getComboMultiplier(9)).toBe(2);
+  });
+
+  test('x3 for 10-19', () => {
+    expect(getComboMultiplier(10)).toBe(3);
+    expect(getComboMultiplier(19)).toBe(3);
+  });
+
+  test('x5 for 20+', () => {
+    expect(getComboMultiplier(20)).toBe(5);
+    expect(getComboMultiplier(100)).toBe(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Pickup Range
+// ---------------------------------------------------------------------------
+
+describe('isInPickupRange', () => {
+  test('picks up when close', () => {
+    expect(isInPickupRange(0, 10, 0, 10.5, false)).toBe(true);
+  });
+
+  test('does not pick up when far', () => {
+    expect(isInPickupRange(0, 10, 0, 15, false)).toBe(false);
+  });
+
+  test('magnet extends range', () => {
+    expect(isInPickupRange(0, 10, 4, 10, false)).toBe(false);
+    expect(isInPickupRange(0, 10, 4, 10, true)).toBe(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Powerups
+// ---------------------------------------------------------------------------
+
+describe('applyPowerup', () => {
+  function makePlayer() {
+    const session = createRunnerSession(42);
+    return addRunnerPlayer(session, 'sock1', 'p1');
+  }
+
+  test('speed-boost adds CharacterModifier', () => {
+    const player = makePlayer();
+    applyPowerup(player, 'speed-boost');
+    expect(player.modifiers).toHaveLength(1);
+    expect(player.modifiers[0].id).toBe('speed-boost');
+    expect(player.modifiers[0].multipliers.walkSpeed).toBe(1.5);
+    expect(player.modifiers[0].remainingTime).toBe(5);
+  });
+
+  test('low-gravity sets gravityModifier', () => {
+    const player = makePlayer();
+    applyPowerup(player, 'low-gravity');
+    expect(player.gravityModifier).not.toBeNull();
+    expect(player.gravityModifier!.multiplier).toBe(0.3);
+    expect(player.gravityModifier!.remainingTime).toBe(5);
+  });
+
+  test('magnet activates with timer', () => {
+    const player = makePlayer();
+    applyPowerup(player, 'magnet');
+    expect(player.magnetActive).toBe(true);
+    expect(player.magnetTimer).toBe(8);
+  });
+
+  test('speed-boost modifier expires via updateModifiers', () => {
+    const player = makePlayer();
+    applyPowerup(player, 'speed-boost');
+    player.modifiers = updateModifiers(player.modifiers, 6);
+    expect(player.modifiers).toHaveLength(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Obstacle Collision
+// ---------------------------------------------------------------------------
+
+describe('checkObstacleCollision', () => {
+  const wall: PlacedObstacle = { id: 1, type: 'wall', lane: 0, x: 0, z: 50, height: 3 };
+  const lowBarrier: PlacedObstacle = { id: 2, type: 'low-barrier', lane: 0, x: 0, z: 50, height: 1 };
+  const highBarrier: PlacedObstacle = { id: 3, type: 'high-barrier', lane: 0, x: 0, z: 50, height: 3 };
+
+  test('wall always kills on contact', () => {
+    expect(checkObstacleCollision(0, 0, 50, wall)).toBe(true);
+    expect(checkObstacleCollision(0, 5, 50, wall)).toBe(true);
+  });
+
+  test('wall does not kill if far away', () => {
+    expect(checkObstacleCollision(0, 0, 55, wall)).toBe(false);
+    expect(checkObstacleCollision(4, 0, 50, wall)).toBe(false);
+  });
+
+  test('low barrier kills if on ground', () => {
+    expect(checkObstacleCollision(0, 0, 50, lowBarrier)).toBe(true);
+  });
+
+  test('low barrier survived by jumping over', () => {
+    expect(checkObstacleCollision(0, 2, 50, lowBarrier)).toBe(false);
+  });
+
+  test('high barrier kills if in air', () => {
+    expect(checkObstacleCollision(0, 2, 50, highBarrier)).toBe(true);
+  });
+
+  test('high barrier survived by staying low', () => {
+    expect(checkObstacleCollision(0, 0.3, 50, highBarrier)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Track Generator — Collectibles & Obstacles
+// ---------------------------------------------------------------------------
+
+describe('TrackGenerator with items', () => {
+  test('segments have collectibles array', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 500, 0);
+    // All segments should have a collectibles array (may be empty)
+    for (const seg of state.segments) {
+      expect(Array.isArray(seg.collectibles)).toBe(true);
+      expect(Array.isArray(seg.obstacles)).toBe(true);
+    }
+  });
+
+  test('some segments have coins', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 2000, 0);
+    const withCoins = state.segments.filter(s => s.collectibles.length > 0);
+    expect(withCoins.length).toBeGreaterThan(0);
+  });
+
+  test('some segments have obstacles at higher indices', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 3000, 0);
+    const withObstacles = state.segments.filter(s => s.obstacles.length > 0);
+    expect(withObstacles.length).toBeGreaterThan(0);
+  });
+
+  test('some segments have powerups', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 3000, 0);
+    const withPowerups = state.segments.filter(s => s.powerup !== null);
+    expect(withPowerups.length).toBeGreaterThan(0);
+  });
+
+  test('collectibles have world positions', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 500, 0);
+    const seg = state.segments.find(s => s.collectibles.length > 0);
+    if (seg) {
+      for (const c of seg.collectibles) {
+        expect(c.z).toBeGreaterThanOrEqual(seg.startZ);
+        expect(c.z).toBeLessThanOrEqual(seg.endZ);
+        expect(c.collected).toBe(false);
+      }
+    }
+  });
+
+  test('obstacles never block all lanes', () => {
+    const state = createTrackGenerator(42);
+    updateTrack(state, 0, 5000, 0);
+    for (const seg of state.segments) {
+      if (seg.obstacles.length > 0) {
+        const availableLanes = seg.def.lanes.filter(Boolean).length;
+        const blockedLanes = new Set(seg.obstacles.map(o => o.lane)).size;
+        expect(blockedLanes).toBeLessThan(availableLanes);
+      }
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// RunnerPlayer initial state
+// ---------------------------------------------------------------------------
+
+describe('RunnerPlayer scoring fields', () => {
+  test('new player starts with zero score', () => {
+    const session = createRunnerSession(42);
+    const player = addRunnerPlayer(session, 'sock1', 'p1');
+    expect(player.score).toBe(0);
+    expect(player.coins).toBe(0);
+    expect(player.gems).toBe(0);
+    expect(player.bestCombo).toBe(0);
+    expect(player.combo.count).toBe(0);
+    expect(player.modifiers).toHaveLength(0);
+    expect(player.magnetActive).toBe(false);
+    expect(player.gravityModifier).toBeNull();
+    expect(player.highScore).toBe(0);
+  });
+});

package/template/apps/server/src/tests/server.integration.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { io as Client, type Socket } from 'socket.io-client';
+import { createServer, type GameServer } from '../index.js';
+
+const TEST_PORT = 3099;
+
+describe('Server Integration', () => {
+  let server: GameServer;
+  let client: Socket;
+  const received: Record<string, unknown>[] = [];
+
+  beforeAll(async () => {
+    server = await createServer(TEST_PORT, 42); // fixed seed for determinism
+
+    client = Client(`http://localhost:${TEST_PORT}`);
+
+    // Capture all messages from the start
+    client.on('message', (msg: Record<string, unknown>) => {
+      received.push(msg);
+    });
+
+    // Wait for connection + EXPERIENCE_LIST, then join Diablo experience
+    await new Promise<void>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Connection timeout')), 3000);
+      client.on('connect', () => {
+        // Wait for EXPERIENCE_LIST, then join diablo
+        setTimeout(() => {
+          client.emit('message', { type: 'EXPERIENCE_JOIN', experienceId: 'diablo' });
+          // Wait for AREA_CHANGE to arrive
+          setTimeout(() => {
+            clearTimeout(timer);
+            resolve();
+          }, 300);
+        }, 100);
+      });
+    });
+  });
+
+  afterAll(async () => {
+    client.disconnect();
+    try {
+      await server.close();
+    } catch {
+      // ignore ERR_SERVER_NOT_RUNNING on test cleanup
+    }
+  });
+
+  it('sends EXPERIENCE_LIST on connect', () => {
+    const expList = received.find(m => m.type === 'EXPERIENCE_LIST');
+    expect(expList).toBeDefined();
+    const experiences = (expList as any).experiences as Array<{ id: string; name: string }>;
+    expect(experiences.length).toBeGreaterThan(0);
+    expect(experiences.find(e => e.id === 'diablo')).toBeDefined();
+  });
+
+  it('sends AREA_CHANGE with overworld on connect', () => {
+    const areaChange = received.find(m => m.type === 'AREA_CHANGE');
+    expect(areaChange).toBeDefined();
+    expect(areaChange!.targetArea).toBe('overworld');
+    expect(areaChange!.voxelConfig).toBeDefined();
+    expect(typeof areaChange!.spawnX).toBe('number');
+    expect(typeof areaChange!.spawnY).toBe('number');
+    expect(typeof areaChange!.localEntityId).toBe('number');
+  });
+
+  it('broadcasts ENTITY_SYNC at ~20Hz', async () => {
+    const before = received.filter(m => m.type === 'ENTITY_SYNC').length;
+    await new Promise((res) => setTimeout(res, 400));
+    const after = received.filter(m => m.type === 'ENTITY_SYNC').length;
+    expect(after - before).toBeGreaterThanOrEqual(3);
+  });
+
+  it('ENTITY_SYNC has correct shape', () => {
+    const sync = received.find(m => m.type === 'ENTITY_SYNC') as {
+      type: string;
+      entities: unknown[];
+      tick: number;
+    } | undefined;
+    expect(sync).toBeDefined();
+    expect(Array.isArray(sync!.entities)).toBe(true);
+    expect(typeof sync!.tick).toBe('number');
+  });
+
+  it('accepts PLAYER_MOVE message without crashing', async () => {
+    const countBefore = received.filter(m => m.type === 'ENTITY_SYNC').length;
+    client.emit('message', { type: 'PLAYER_MOVE', targetX: 10, targetY: 5 });
+    await new Promise((res) => setTimeout(res, 200));
+    const countAfter = received.filter(m => m.type === 'ENTITY_SYNC').length;
+    // Server still sends ENTITY_SYNC — didn't crash
+    expect(countAfter).toBeGreaterThan(countBefore);
+  });
+});