@crowdedkingdoms/construct 0.0.0 → 0.2.0-dev.1

package/src/platform/media/voiceFrames.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { encodeSamples } from './mulaw';
+import { RecordingPlayback, VoiceService, type VoiceTransport } from './VoiceService';
+
+type AudioN = { uuid: string; audioData: string; sequenceNumber?: number };
+type Handler<T> = (n: T) => void;
+
+function bytesToBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]!);
+  return btoa(binary);
+}
+
+function fakeTransport(self = 'self-uuid') {
+  const audio = new Set<Handler<AudioN>>();
+  const left = new Set<Handler<{ uuid: string }>>();
+  const lane = new Set<Handler<string>>();
+  const transport: VoiceTransport & {
+    emitAudio(n: AudioN): void;
+    emitLeft(uuid: string): void;
+  } = {
+    onAudio: (h) => {
+      audio.add(h);
+      return () => audio.delete(h);
+    },
+    onActorLeft: (h) => {
+      left.add(h);
+      return () => left.delete(h);
+    },
+    onLaneLeave: (h) => {
+      lane.add(h);
+      return () => lane.delete(h);
+    },
+    selfUuid: () => self,
+    selfChunk: () => ({ x: '0', y: '0', z: '0' }),
+    selfPosition: () => ({ x: 0, y: 0, z: 0 }),
+    remotePositions: () => [{ uuid: 'other', x: 4, y: 0, z: 0 }],
+    appId: () => '1',
+    sendAudioPacket: async () => true,
+    log: () => undefined,
+    emitAudio(n) {
+      for (const h of audio) h(n);
+    },
+    emitLeft(uuid) {
+      for (const h of left) h({ uuid });
+    },
+  };
+  return transport;
+}
+
+describe('VoiceService receive', () => {
+  const services: VoiceService[] = [];
+
+  afterEach(() => {
+    for (const service of services) service.dispose();
+    services.length = 0;
+  });
+
+  function start() {
+    const transport = fakeTransport();
+    const playback = new RecordingPlayback();
+    const voice = new VoiceService(transport, { playback, now: () => 1_000 });
+    services.push(voice);
+    voice.listen();
+    const payload = bytesToBase64(encodeSamples(new Float32Array(8).fill(0.2)));
+    return { transport, playback, voice, payload };
+  }
+
+  it('ignores self, plays others, drops a duplicate sequence, and tears down on actorLeft', () => {
+    const { transport, playback, payload } = start();
+    transport.emitAudio({ uuid: 'self-uuid', audioData: payload, sequenceNumber: 1 });
+    expect(playback.played).toHaveLength(0);
+    transport.emitAudio({ uuid: 'other', audioData: payload, sequenceNumber: 1 });
+    expect(playback.played).toHaveLength(1);
+    expect(playback.played[0]!.uuid).toBe('other');
+    transport.emitAudio({ uuid: 'other', audioData: payload, sequenceNumber: 1 });
+    expect(playback.played).toHaveLength(1);
+    transport.emitLeft('other');
+    expect(playback.forgotten).toContain('other');
+  });
+});

package/src/platform/model/ModelService.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from 'vitest';
+
+// The SDK root barrel drags Monaco into a unit test; the network layer only needs the constants.
+vi.mock('@crowdedkingdoms/crowdyjs', () => ({
+  CROWDY_DEFAULT_HTTP_ORIGIN: 'https://ck.test.example',
+  CROWDY_DEFAULT_TIER: 'test',
+}));
+
+const { ModelService } = await import('./ModelService');
+
+function withHub(replies: Record<string, unknown>) {
+  const logs: string[] = [];
+  const hub = {
+    call: vi.fn(async (method: string) => {
+      const reply = replies[method];
+      if (reply instanceof Error) throw reply;
+      return reply;
+    }),
+  };
+  const session = { network: { worldHub: hub, log: (line: string) => logs.push(line) } };
+  return { model: new ModelService(session as never), hub, logs };
+}
+
+describe('ModelService on the world hub', () => {
+  it('reads the pulse count and caches it for the HUD poll', async () => {
+    const { model, hub } = withHub({
+      world: { pulses: 7, lastPulseAt: 1, pulseEveryMs: 60_000 },
+    });
+    expect(await model.world()).toEqual({ pulses: 7, seeded: true });
+    await model.world();
+    expect(hub.call).toHaveBeenCalledTimes(1);
+    model.invalidate();
+    await model.world();
+    expect(hub.call).toHaveBeenCalledTimes(2);
+  });
+
+  it('says the hub is missing instead of throwing', async () => {
+    const { model, logs } = withHub({
+      world: new Error('NotFound: no such type'),
+      progress: new Error('x'),
+    });
+    expect(await model.world()).toEqual({ pulses: 0, seeded: false });
+    expect(await model.progress()).toBeNull();
+    expect(logs.some((line) => /world state unavailable: NotFound/.test(line))).toBe(true);
+  });
+
+  it('maps the catalog and the player progression to their records', async () => {
+    const { model } = withHub({
+      programs: {
+        programs: [{ programId: 1, sceneId: 'paint', name: 'Paint', description: 'd' }],
+      },
+      progress: { player: '42', xp: 3, level: 2, skillPoints: 1 },
+    });
+    expect(await model.programs()).toEqual([
+      { containerId: 'program-1', programId: 1, sceneId: 'paint', name: 'Paint', description: 'd' },
+    ]);
+    expect(await model.progress()).toEqual({ containerId: '42', xp: 3, level: 2, skillPoints: 1 });
+  });
+});

package/src/platform/model/ModelService.ts

@@ -0,0 +1,124 @@
+/**
+ * The game-state facade: what the client reads from the server that keeps the game's rules,
+ * in game terms.
+ *
+ * That server is the app's world hub on ck-exec (the starter's `exec/construct`, deployed by
+ * `npm run setup` / `npm run deploy:exec`), reached over the one connection
+ * `NetworkManager.worldHub` holds. The hub decides; this class only asks, as the signed-in
+ * player: it cannot grant itself XP, and it never names another player. Reads are cached
+ * briefly because the HUD polls them.
+ */
+import type { GameSession } from '../GameSession';
+import { messageOf } from '../network/NetworkManager';
+
+export interface ProgramRecord {
+  /** `program-<programId>`. */
+  containerId: string;
+  programId: number;
+  sceneId: string;
+  name: string;
+  description: string;
+}
+
+export interface ProgressSummary {
+  /** The progression record's id: the player's user id, on the world hub. */
+  containerId: string;
+  xp: number;
+  level: number;
+  skillPoints: number;
+}
+
+export interface WorldSummary {
+  pulses: number;
+  /** The world hub answered: it is deployed and reachable. */
+  seeded: boolean;
+}
+
+interface HubProgram {
+  programId: number;
+  sceneId: string;
+  name: string;
+  description: string;
+}
+
+interface HubProgress {
+  player: string;
+  xp: number;
+  level: number;
+  skillPoints: number;
+}
+
+const CACHE_MS = 15_000;
+
+export class ModelService {
+  private programsCache: { at: number; value: ProgramRecord[] } | null = null;
+  private worldCache: { at: number; value: WorldSummary } | null = null;
+  private progressCache: { at: number; value: ProgressSummary } | null = null;
+
+  constructor(private readonly session: GameSession) {}
+
+  private get hub() {
+    return this.session.network.worldHub;
+  }
+
+  /** The program catalog the hub serves; empty when the hub cannot be reached. */
+  async programs(): Promise<ProgramRecord[]> {
+    if (this.programsCache && Date.now() - this.programsCache.at < CACHE_MS)
+      return this.programsCache.value;
+    let value: ProgramRecord[] = [];
+    try {
+      const { programs } = await this.hub.call<{ programs: HubProgram[] }>('programs');
+      value = programs.map((program) => ({
+        containerId: `program-${program.programId}`,
+        programId: Number(program.programId),
+        sceneId: String(program.sceneId),
+        name: String(program.name),
+        description: String(program.description),
+      }));
+    } catch (error) {
+      this.session.network.log(`program catalog unavailable: ${messageOf(error)}`);
+    }
+    this.programsCache = { at: Date.now(), value };
+    return value;
+  }
+
+  /** The world's pulse count: proof the hub's minute timer runs while someone is here. */
+  async world(): Promise<WorldSummary> {
+    if (this.worldCache && Date.now() - this.worldCache.at < CACHE_MS) return this.worldCache.value;
+    let value: WorldSummary = { pulses: 0, seeded: false };
+    try {
+      const { pulses } = await this.hub.call<{ pulses: number }>('world');
+      value = { pulses: Number(pulses), seeded: true };
+    } catch (error) {
+      this.session.network.log(`world state unavailable: ${messageOf(error)}`);
+    }
+    this.worldCache = { at: Date.now(), value };
+    return value;
+  }
+
+  /** The player's progression, which the hub creates on first read. */
+  async progress(): Promise<ProgressSummary | null> {
+    if (this.progressCache && Date.now() - this.progressCache.at < CACHE_MS)
+      return this.progressCache.value;
+    try {
+      const progress = await this.hub.call<HubProgress>('progress');
+      const value: ProgressSummary = {
+        containerId: String(progress.player),
+        xp: Number(progress.xp),
+        level: Number(progress.level),
+        skillPoints: Number(progress.skillPoints),
+      };
+      this.progressCache = { at: Date.now(), value };
+      return value;
+    } catch (error) {
+      this.session.network.log(`progression unavailable: ${messageOf(error)}`);
+      return null;
+    }
+  }
+
+  invalidate(): void {
+    this.programsCache = null;
+    this.worldCache = null;
+    this.progressCache = null;
+  }
+}