Initial commit: ssessesse ki battle

2026-10-13 11:15:26 +09:00
commit 4f24129e29
104 changed files with 10520 additions and 0 deletions
@@ -0,0 +1,132 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createMatchController } from '../src/client/match-controller.js';
+import { emptyPlayerStats, type PeerMessage, type ResultSubmission } from '../src/shared/p2p-types.js';
+import { ManualClock } from './helpers.js';
+import type { PeerState } from '../src/client/peer.js';
+
+test('failed rematch request remains retryable', async () => {
+  let attempts = 0;
+  const h = setup(async () => { if (++attempts === 1) throw new Error('offline'); }); const [a, b] = h.controllers;
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await a.leave(); await h.clock.advance(1);
+    assert.equal(a.view().finished?.reason, 'forfeit'); assert.equal(b.view().finished?.winnerIndex, 1);
+    await assert.rejects(a.rematch(), /offline/); assert.equal(a.view().rematch[0], false);
+    await a.rematch(); assert.equal(attempts, 2);
+  } finally { h.close(); }
+});
+
+class Wire {
+  epoch = 0; connected = false; remote?: Wire; drop = false;
+  intercept?: (message: PeerMessage) => boolean;
+  messages = new Set<(m: PeerMessage) => void>(); states = new Set<(s: PeerState) => void>();
+  async connect() { this.connected = true; }
+  send(message: PeerMessage) {
+    if (!this.connected) throw new Error('DISCONNECTED');
+    if (this.intercept?.(message)) return;
+    if (!this.drop) queueMicrotask(() => { if (this.remote?.connected) for (const h of this.remote.messages) h(structuredClone(message)); });
+  }
+  onMessage(h: (m: PeerMessage) => void) { this.messages.add(h); return () => { this.messages.delete(h); }; }
+  onState(h: (s: PeerState) => void) { this.states.add(h); return () => { this.states.delete(h); }; }
+  async restart(epoch = this.epoch + 1) { this.epoch = epoch; this.connected = true; }
+  close() { this.connected = false; }
+  disconnect() { this.connected = false; for (const h of this.states) h('disconnected'); }
+}
+function setup(onRematch?: () => Promise<void>, guestClockOffset = 0) {
+  const clock = new ManualClock(); clock.time = 1000;
+  const a = new Wire(), b = new Wire(); a.remote = b; b.remote = a;
+  const records: ResultSubmission[][] = [[], []];
+  const storages: any[] = [];
+  const controllers = [a, b].map((peer, slot) => {
+    const memory = new Map<string, string>();
+    const storage = { getItem: (k: string) => memory.get(k) ?? null, setItem: (k: string, v: string) => { memory.set(k, v); }, removeItem: (k: string) => { memory.delete(k); } }; storages.push(storage);
+    const localClock = slot === 1 ? { now: () => clock.now() + guestClockOffset, setTimeout: clock.setTimeout, clearTimeout: clock.clearTimeout } : clock;
+    return createMatchController({ activeMatch: { matchId: 'friend-match', seq: 1, mode: 'friend', roomId: 'r' }, gameSessionId: `session-${slot}`, selfIndex: slot as 0 | 1, clock: localClock, peer, onRematch,
+      reporter: { submit: async data => { records[slot].push(data); return { status: 'applied', stats: emptyPlayerStats() }; } },
+      storage,
+    });
+  });
+  return { clock, a, b, controllers, records, storages, close: () => controllers.forEach(c => c.destroy()) };
+}
+test('two peers agree turns and record complementary results without server turn events', async () => {
+  const h = setup(); const [a, b] = h.controllers;
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(3000);
+    assert.equal(a.view().phase, 'selecting'); assert.equal(b.view().phase, 'selecting');
+    await a.submitAction('charge'); await b.submitAction('charge'); await h.clock.advance(4000);
+    assert.deepEqual(a.view().energy, [1, 1]); assert.deepEqual(b.view().energy, [1, 1]);
+    await h.clock.advance(1200); await a.submitAction('blast'); await b.submitAction('charge'); await h.clock.advance(4000);
+    assert.equal(h.records[0][0]?.outcome, 'win'); assert.equal(h.records[1][0]?.outcome, 'loss');
+    assert.equal(h.records[0].length, 1); assert.equal(h.records[1].length, 1);
+  } finally { h.close(); }
+});
+
+test('loss of final presentation after digest acknowledgements preserves both agreed results', async () => {
+  const h = setup(); const [a, b] = h.controllers;
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(3000);
+    await a.submitAction('charge'); await b.submitAction('charge'); await h.clock.advance(5200);
+    await a.submitAction('blast'); await b.submitAction('charge');
+    h.a.intercept = m => { if (m.type !== 'turn:present') return false; queueMicrotask(() => { h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect(); }); return true; };
+    await h.clock.advance(14000);
+    assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['win'], ['loss']]);
+  } finally { h.close(); }
+});
+
+test('crossed explicit leave requests produce one draw per player instead of two wins', async () => {
+  const h = setup();
+  try {
+    await Promise.all(h.controllers.map(c => c.start()));
+    await Promise.all(h.controllers.map(c => c.leave())); await h.clock.advance(1);
+    assert.deepEqual(h.records.map(r => r.map(x => x.outcome)), [['draw'], ['draw']]);
+  } finally { h.close(); }
+});
+test('recovery starts a fresh epoch and ignores messages from the previous connection', async () => {
+  const h = setup(); const [a, b] = h.controllers;
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(3000); await a.submitAction('charge');
+    h.a.disconnect(); h.b.disconnect(); await h.clock.advance(100);
+    assert.equal(h.a.epoch, 1); assert.equal(h.b.epoch, 1);
+    assert.equal(a.view().ownAction, null); assert.equal(b.view().ownAction, null);
+    assert.equal(h.records[0].length, 0);
+    h.a.send({ protocolVersion: 1, rulesVersion: '1', matchId: 'friend-match', connectionEpoch: 0, turnId: 1, type: 'turn:commit', digest: '0'.repeat(64), slot: 0 });
+    await h.clock.advance(1); assert.equal(b.view().phase, 'selecting');
+  } finally { h.close(); }
+});
+
+test('peers whose wall clocks differ by five seconds agree on deadline and timeout result', async () => {
+  const h = setup(undefined, 5000); const [a, b] = h.controllers;
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(3000);
+    assert.equal(a.view().deadline, b.view().deadline); assert.equal(a.view().clockNow, b.view().clockNow);
+    await a.submitAction('charge'); await h.clock.advance(4000);
+    assert.equal(h.records[0][0]?.outcome, 'win'); assert.equal(h.records[1][0]?.outcome, 'loss');
+    assert.equal(a.view().finished?.reason, 'timeout'); assert.equal(b.view().finished?.reason, 'timeout');
+  } finally { h.close(); }
+});
+test('unrecoverable transport interruption aborts rather than inventing two wins', async () => {
+  const h = setup();
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(3000);
+    h.a.drop = h.b.drop = true; h.a.disconnect(); h.b.disconnect();
+    await new Promise(r => setImmediate(r)); // drain already-delivered messages before advancing the recovery clock
+    await h.clock.advance(10000);
+    assert.equal(h.records[0][0]?.outcome, 'aborted'); assert.equal(h.records[1][0]?.outcome, 'aborted');
+  } finally { h.close(); }
+});
+
+test('refresh of a mutually confirmed final result saves without reconnecting to the opponent', async () => {
+  const h = setup();
+  try {
+    await Promise.all(h.controllers.map(c => c.start())); await h.clock.advance(7000);
+    const { GAME_CHECKPOINT_KEY } = await import('../constants/recording.js');
+    const saved = JSON.parse(h.storages[0].getItem(GAME_CHECKPOINT_KEY));
+    saved.checkpoint.state.finished.saved = false; saved.checkpoint.state.saveStatus = 'pending';
+    h.storages[0].setItem(GAME_CHECKPOINT_KEY, JSON.stringify(saved));
+    h.close(); let recorded = 0;
+    const restored = createMatchController({ activeMatch: saved.activeMatch, gameSessionId: 'session-0', selfIndex: 0, clock: h.clock, storage: h.storages[0],
+      reporter: { submit: async data => { recorded++; assert.equal(data.outcome, 'draw'); return { status: 'duplicate', stats: emptyPlayerStats() }; } } });
+    try { await restored.start(); assert.equal(recorded, 1); assert.equal(restored.view().saveStatus, 'saved'); }
+    finally { restored.destroy(); }
+  } finally { h.close(); }
+});