297 lines
18 KiB
JavaScript
297 lines
18 KiB
JavaScript
// test/ui/deploy-replay.test.js — PR #416 by @Cromemadnd, ported in 0.2.6 (DESIGN §31.8): the round start replays the own
|
|
// board's Start clips in deployment order (ui/gameLogic deployOrder / roundStartReplay — the maintainer's confirmation from
|
|
// official play, 2026-10-13), and a landing sounds like the piece's battle deployment through the SFX channel
|
|
// (public/js/audio.js deployCue) in its own voices: at most LAND_VOICES at once, a new landing taking the oldest one's
|
|
// voice instead of being dropped (Grok's review of r37: the battle limiter left 6 of 8 b_char_set landings silent) —
|
|
// checked with the real AudioManager, SfxLimiter and buffer cache on a fake Web Audio context. The view side is
|
|
// test/render/deploy-replay.test.js, the browser check test/ui/deploy-replay.e2e.test.js.
|
|
// Run: node --test test/ui/deploy-replay.test.js
|
|
|
|
import { test, describe } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { readFileSync } from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { deployOrder, roundStartReplay } from '../../public/js/ui/gameLogic.js';
|
|
import { AudioManager, SfxLimiter, LAND_VOICES, deploySfxUrl } from '../../public/js/audio.js';
|
|
import { mediaUrl } from '../../public/js/media.js';
|
|
import { PHASE } from '../../shared/constants.js';
|
|
|
|
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
|
|
const manifest = JSON.parse(readFileSync(path.join(ROOT, 'data', 'assets.json'), 'utf8'));
|
|
const chess = (uid, row, col, extra = {}) => ({ uid, kind: 'chess', id: `chess_${uid}`, row, col, ...extra });
|
|
|
|
describe('deployOrder — the order the battle deploys the board (Battle.start)', () => {
|
|
test('operators by column from the left, top to bottom within a column, then the summons the same way; no items', () => {
|
|
// board rows 9 (bottom) … 12 (top), cols 2 … 10; given in reading order, as m.private sends it (server board.js boardOrder)
|
|
const board = [
|
|
chess(1, 12, 5), chess(2, 12, 2), { uid: 3, kind: 'token', id: 'token_a', row: 12, col: 3 }, chess(4, 11, 2),
|
|
{ uid: 5, kind: 'item', id: 'chess_item_6_03_m', row: 10, col: 4 }, chess(6, 10, 5), chess(7, 9, 3),
|
|
{ uid: 8, kind: 'token', id: 'token_b', row: 9, col: 2 },
|
|
];
|
|
assert.deepEqual(deployOrder(board), [2, 4, 7, 1, 6, 8, 3]);
|
|
// the same rule the client's merge target uses (gameLogic mergeTarget: col asc, then row desc)
|
|
assert.deepEqual(deployOrder([chess(1, 9, 4), chess(2, 12, 4), chess(3, 10, 3)]), [3, 2, 1]);
|
|
});
|
|
|
|
test('junk and missing fields are left out; an empty or absent board is no order', () => {
|
|
assert.deepEqual(deployOrder(null), []);
|
|
assert.deepEqual(deployOrder([]), []);
|
|
assert.deepEqual(deployOrder([null, 'x', { uid: 1, kind: 'chess', row: 10 }, { kind: 'chess', row: 10, col: 3 }, chess(9, 10, 3)]), [9]);
|
|
});
|
|
});
|
|
|
|
describe('roundStartReplay — once per round, in 回合开始, on the own board', () => {
|
|
const board = [chess(11, 12, 6), chess(12, 9, 2)];
|
|
const base = { phase: PHASE.ROUND_START, round: 7, replayed: 6, ownBoard: true, board };
|
|
|
|
test('due in 回合开始 of a round not replayed yet: its pieces in deployment order', () => {
|
|
assert.deepEqual(roundStartReplay(base), { round: 7, uids: [12, 11] });
|
|
});
|
|
|
|
test('not again for the same round (a reconnect, a re-render); not in another phase', () => {
|
|
assert.equal(roundStartReplay({ ...base, replayed: 7 }), null);
|
|
for (const phase of [PHASE.PREP, PHASE.SP_DRAFT, PHASE.SETTLE, PHASE.COMBAT, PHASE.BATTLE_CHECK, null]) {
|
|
assert.equal(roundStartReplay({ ...base, phase }), null, String(phase));
|
|
}
|
|
assert.equal(roundStartReplay({ ...base, round: null }), null);
|
|
});
|
|
|
|
test('only the viewer\'s own board: a scouted teammate, a spectator seat or an eliminated player gets none', () => {
|
|
assert.equal(roundStartReplay({ ...base, ownBoard: false }), null);
|
|
});
|
|
|
|
test('an empty board (or a private state not here yet) schedules nothing — and marks nothing, so a board that arrives later in 回合开始 still plays', () => {
|
|
assert.equal(roundStartReplay({ ...base, board: [] }), null);
|
|
assert.equal(roundStartReplay({ ...base, board: undefined }), null);
|
|
assert.deepEqual(roundStartReplay({ ...base, replayed: null }), { round: 7, uids: [12, 11] });
|
|
});
|
|
|
|
test('screens/game.js asks after the wiring effect and marks the round only once the view took the sequence', () => {
|
|
const src = readFileSync(path.join(ROOT, 'public/js/screens/game.js'), 'utf8');
|
|
const wiring = src.indexOf('}, [view, showPrep, priv, editable, field, combat, mode, watchingOther, watching, holdSeq]);');
|
|
const replay = src.indexOf('const plan = roundStartReplay(');
|
|
assert.ok(wiring > 0 && replay > wiring, 'the replay effect runs after setPrep in the same commit');
|
|
assert.match(src, /roundStartReplay\(\{ phase, round: pub\?\.round, replayed: replayedRef\.current, ownBoard: showPrep && alive && !spectator, board: priv\?\.board \}\)/);
|
|
assert.match(src, /if \(plan && view && view\.replayDeploys\?\.\(plan\.uids\) > 0\) replayedRef\.current = plan\.round;/);
|
|
assert.doesNotMatch(src, /deployPiece|deploySequence/, 'no landing at the wheel\'s confirm: the state that shows the move lands the piece once');
|
|
const host = readFileSync(path.join(ROOT, 'public/js/ui/fieldHost.js'), 'utf8');
|
|
assert.match(host, /'stripesUnder', 'replayDeploys'\]/, 'an optional view method (the simplified board has none)');
|
|
});
|
|
});
|
|
|
|
// ---- the landing voices: the real AudioManager (SfxLimiter, _buffer, the nodes) on a fake Web Audio context --------------
|
|
|
|
const SET = manifest.audio.sfx.battle.deploy; // b_char_set: 192 of the 210 operators land with it
|
|
const TOKEN_SET = manifest.audio.sfx.battle.tokenDeploy;
|
|
const OWN = Object.keys(manifest.audio.sfx.units).find((k) => k.startsWith('char_') && typeof manifest.audio.sfx.units[k].born === 'string');
|
|
const PLAIN = Object.keys(manifest.chars).filter((k) => !manifest.audio.sfx.units[k]?.born);
|
|
/** Seconds of the files as served (b_char_set 1.41 s, b_char_tokenset 0.50 s — afinfo); 1 s for any other. */
|
|
const durationOf = (url) => (/b_char_set/.test(url) ? 1.41 : /b_char_tokenset/.test(url) ? 0.5 : 1);
|
|
|
|
/**
|
|
* A fake Web Audio window: every buffer source records when it started and stopped on a clock the test moves (`at(ms)`:
|
|
* performance.now() and ctx.currentTime follow it, a source that reaches its end fires `onended`); fetch serves every
|
|
* sound with its real length. `hold(url)` keeps one download open until the returned function is called.
|
|
*/
|
|
function landingRig({ settings = { sfx: 0.8, muted: false } } = {}) {
|
|
const clock = { ms: 0 };
|
|
const sources = [];
|
|
const fetched = [];
|
|
const held = new Map();
|
|
class Param {
|
|
constructor() { this.value = 1; this.ramps = []; }
|
|
setValueAtTime(v) { this.value = v; } linearRampToValueAtTime(v, t) { this.ramps.push([v, t]); } setTargetAtTime(v) { this.value = v; }
|
|
cancelScheduledValues() {}
|
|
}
|
|
class Node { connect() {} disconnect() {} }
|
|
class Gain extends Node { constructor() { super(); this.gain = new Param(); } }
|
|
class Src extends Node {
|
|
constructor() { super(); this.playbackRate = new Param(); this.buffer = null; this.startedAt = null; this.stoppedAt = null; this.stopWhen = null; this.ended = false; sources.push(this); }
|
|
start() { this.startedAt = clock.ms; }
|
|
stop(when) { this.stoppedAt = clock.ms; this.stopWhen = when; }
|
|
get playing() { return this.startedAt != null && this.stoppedAt == null && !this.ended; }
|
|
}
|
|
class Ctx {
|
|
constructor() { this.state = 'running'; this.destination = new Node(); this.sampleRate = 44100; }
|
|
get currentTime() { return clock.ms / 1000; }
|
|
createGain() { return new Gain(); }
|
|
createBufferSource() { return new Src(); }
|
|
createBuffer() { return { duration: 0 }; }
|
|
decodeAudioData(ab, ok) { ok({ duration: ab.duration, length: 1, numberOfChannels: 1, url: ab.url }); }
|
|
resume() { return Promise.resolve(); }
|
|
suspend() { return Promise.resolve(); }
|
|
}
|
|
const listeners = new Map();
|
|
const win = { AudioContext: Ctx, document: { hidden: false, addEventListener() {} }, addEventListener(t, fn) { listeners.set(t, fn); }, removeEventListener(t) { listeners.delete(t); } };
|
|
const realFetch = globalThis.fetch;
|
|
const perf = globalThis.performance;
|
|
const realNow = perf.now;
|
|
globalThis.fetch = async (u) => {
|
|
fetched.push(u);
|
|
const wait = held.get(u);
|
|
if (wait) await wait;
|
|
return { ok: true, headers: { get: () => 'audio/mpeg' }, arrayBuffer: async () => ({ duration: durationOf(u), url: u }) };
|
|
};
|
|
perf.now = () => clock.ms;
|
|
const a = new AudioManager({ win, getManifest: () => manifest, random: () => 0 });
|
|
a.setVolumes(settings);
|
|
a.install();
|
|
a.warmLandings(); // the field view's wish when the match screen comes up, before any gesture (render/app.js)
|
|
const flush = async () => { for (let i = 0; i < 4; i++) await new Promise((r) => setImmediate(r)); };
|
|
return {
|
|
a, sources, fetched,
|
|
unlock: async () => { listeners.get('pointerdown')?.(); await flush(); },
|
|
/** Move the clock to `ms`: a playing source whose file ran out ends (onended), as Web Audio does. */
|
|
at: async (ms) => {
|
|
clock.ms = ms;
|
|
for (const s of sources) if (s.playing && s.buffer && ms >= s.startedAt + s.buffer.duration * 1000) { s.ended = true; s.onended?.(); }
|
|
await flush();
|
|
},
|
|
flush,
|
|
hold: (url) => { let open; held.set(mediaUrl(url), new Promise((r) => { open = r; })); return () => open(); },
|
|
playing: () => sources.filter((s) => s.playing && s.buffer?.duration > 0),
|
|
started: () => sources.filter((s) => s.startedAt != null && s.buffer?.duration > 0),
|
|
restore: () => { globalThis.fetch = realFetch; perf.now = realNow; },
|
|
};
|
|
}
|
|
|
|
describe('AudioManager.deployCue — the landing sound in its own voices, taken over instead of dropped', () => {
|
|
test(`8 operators on b_char_set, 50 ms apart: 8 starts, never more than ${LAND_VOICES} at once, the oldest taken over each time`, async () => {
|
|
assert.equal(LAND_VOICES, 3);
|
|
// the battle rule this replaces: ≤ 2 copies of a file at once and the rest dropped — 2 of the 8 would have sounded
|
|
const battle = new SfxLimiter();
|
|
assert.equal([...Array(8).keys()].filter((i) => battle.tryAcquire(i * 50, `land:p:${i}`, SET)).length, 2);
|
|
const r = landingRig();
|
|
try {
|
|
await r.unlock();
|
|
const most = [];
|
|
for (let i = 0; i < 8; i++) {
|
|
await r.at(i * 50);
|
|
assert.equal(r.a.deployCue({ def: PLAIN[i], defId: `chess_${i}`, kind: 'op' }, `p:${i}`), true);
|
|
await r.flush();
|
|
most.push(r.playing().length);
|
|
const started = r.started();
|
|
assert.equal(started.length, i + 1, `landing #${i} started at once`);
|
|
assert.equal(started[i].startedAt, i * 50);
|
|
assert.equal(started[i].buffer.url, mediaUrl(SET), 'b_char_set');
|
|
if (i >= LAND_VOICES) {
|
|
const old = started[i - LAND_VOICES];
|
|
assert.equal(old.stoppedAt, i * 50, `#${i} took the voice of #${i - LAND_VOICES}, the oldest still ringing`);
|
|
assert.ok(Math.abs(old.stopWhen - (i * 50) / 1000 - 0.035) < 1e-9, 'which fades out over 30 ms instead of clicking');
|
|
assert.deepEqual(r.a.landVoices.length, LAND_VOICES);
|
|
}
|
|
}
|
|
assert.ok(Math.max(...most) <= LAND_VOICES, `at most ${LAND_VOICES} at once (${most.join(',')})`);
|
|
assert.deepEqual(most, [1, 2, 3, 3, 3, 3, 3, 3]);
|
|
assert.deepEqual(r.a.landStats, { started: 8, stolen: 5 });
|
|
// the newest three ring out; the other battle sounds' limiter was never touched
|
|
await r.at(350 + 1500);
|
|
assert.equal(r.playing().length, 0);
|
|
assert.equal(r.a.landVoices.length, 0, 'every voice returned');
|
|
assert.equal(r.a.landLimiter.active, 0);
|
|
assert.equal(r.a.limiter.active, 0);
|
|
assert.equal(r.a.limiter.lastByUrl.size, 0, 'the battle limiter knows nothing of landings');
|
|
} finally { r.restore(); }
|
|
});
|
|
|
|
test('a full board of 36 pieces — b_char_set, own deploy sounds and summons — lands every one within the cap', async () => {
|
|
const r = landingRig();
|
|
try {
|
|
await r.unlock();
|
|
let most = 0;
|
|
for (let i = 0; i < 36; i++) {
|
|
await r.at(i * 50);
|
|
const info = i % 6 === 5 ? { def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token' }
|
|
: i % 9 === 4 ? { def: OWN, defId: `chess_${i}`, kind: 'op' } : { def: PLAIN[i], defId: `chess_${i}`, kind: 'op' };
|
|
r.a.deployCue(info, `p:${i}`);
|
|
await r.flush();
|
|
most = Math.max(most, r.playing().length, r.a.landVoices.length);
|
|
}
|
|
assert.equal(r.started().length, 36, 'every landing started');
|
|
assert.ok(most <= LAND_VOICES, `never more than ${LAND_VOICES} at once (${most})`);
|
|
assert.equal(r.a.landStats.started, 36);
|
|
const files = new Set(r.started().map((s) => s.buffer.url));
|
|
assert.ok(files.has(mediaUrl(SET)) && files.has(mediaUrl(manifest.audio.sfx.units[OWN].born)) && files.size >= 3, 'the generic, an own and a summon sound');
|
|
await r.at(36 * 50 + 1500);
|
|
assert.equal(r.a.landVoices.length, 0);
|
|
assert.equal(r.a.landLimiter.active, 0);
|
|
} finally { r.restore(); }
|
|
});
|
|
|
|
test('one landing never sounds twice: the same piece within the cooldown takes no voice and stops nothing', async () => {
|
|
const r = landingRig();
|
|
try {
|
|
await r.unlock();
|
|
for (let i = 0; i < LAND_VOICES; i++) { await r.at(i * 50); r.a.deployCue({ def: PLAIN[i], kind: 'op' }, `p:${i}`); await r.flush(); }
|
|
await r.at(LAND_VOICES * 50);
|
|
r.a.deployCue({ def: PLAIN[LAND_VOICES - 1], kind: 'op' }, `p:${LAND_VOICES - 1}`); // 50 ms after its own landing
|
|
await r.flush();
|
|
assert.equal(r.started().length, LAND_VOICES, 'no second start');
|
|
assert.equal(r.started().filter((s) => s.stoppedAt != null).length, 0, 'and nothing taken over for it');
|
|
await r.at(LAND_VOICES * 50 + 200);
|
|
r.a.deployCue({ def: PLAIN[0], kind: 'op' }, 'p:0'); // a later landing of the same piece
|
|
await r.flush();
|
|
assert.equal(r.started().length, LAND_VOICES + 1);
|
|
} finally { r.restore(); }
|
|
});
|
|
|
|
test('the sound of the piece\'s battle deployment at its gain: own ON_UNIT_BORN file, else b_char_set / b_char_tokenset', async () => {
|
|
const r = landingRig();
|
|
try {
|
|
await r.unlock();
|
|
assert.equal(r.a.deployCue({ def: OWN, defId: 'chess_x', kind: 'op' }, 'p:3'), true);
|
|
assert.equal(r.a.deployCue({ def: PLAIN[0], defId: 'chess_y', kind: 'op' }, 'p:4'), true);
|
|
assert.equal(r.a.deployCue({ def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token' }, 'p:5'), true);
|
|
await r.flush();
|
|
const token = deploySfxUrl(manifest, { def: 'token_10000_silent_healrb', defId: 'token_10000_silent_healrb', kind: 'token', side: 'ally' });
|
|
assert.deepEqual(r.a.landVoices.map((v) => v.url), [manifest.audio.sfx.units[OWN].born, SET, token]);
|
|
assert.equal(token, manifest.audio.sfx.units.token_10000_silent_healrb?.born ?? TOKEN_SET, 'a summon: the token sound');
|
|
assert.equal(r.a.landVoices[1].gain.gain.value, 0.5, 'the generic file at the battle deploy\'s gain');
|
|
assert.ok(r.a.landVoices[0].gain.gain.value > 0 && r.a.landVoices[0].gain.gain.value <= 0.8, 'an own file at its bank gain');
|
|
} finally { r.restore(); }
|
|
});
|
|
|
|
test('a landing taken over while its file still downloads never starts; the generic files are fetched ahead', async () => {
|
|
const r = landingRig();
|
|
try {
|
|
assert.equal(r.fetched.length, 0, 'the field view\'s wish waits for the first gesture');
|
|
await r.unlock();
|
|
assert.deepEqual(r.fetched, [mediaUrl(SET), mediaUrl(TOKEN_SET)], 'fetched at unlock: a round start never waits for them');
|
|
const born = manifest.audio.sfx.units[OWN].born;
|
|
const open = r.hold(born);
|
|
r.a.deployCue({ def: OWN, kind: 'op' }, 'p:1'); // still downloading …
|
|
for (let i = 0; i < LAND_VOICES; i++) { await r.at(50 + i * 50); r.a.deployCue({ def: PLAIN[i], kind: 'op' }, `p:${10 + i}`); await r.flush(); }
|
|
assert.equal(r.a.landStats.stolen, 1, '… when the pool filled up it gave its voice');
|
|
open();
|
|
await r.flush();
|
|
assert.equal(r.started().filter((s) => s.buffer.url === mediaUrl(born)).length, 0, 'and it never starts');
|
|
assert.equal(r.started().length, LAND_VOICES);
|
|
} finally { r.restore(); }
|
|
});
|
|
|
|
test('the SFX volume and mute apply: muted or at 0 nothing is fetched, started or taken over; a manifest without the sound: nothing', async () => {
|
|
const r = landingRig({ settings: { sfx: 0.8, muted: true } });
|
|
try {
|
|
await r.unlock();
|
|
assert.equal(r.fetched.length, 0, 'no warm-up while muted');
|
|
r.a.deployCue({ def: PLAIN[0], kind: 'op' }, 'p:1');
|
|
r.a.setVolumes({ sfx: 0, muted: false });
|
|
r.a.deployCue({ def: PLAIN[1], kind: 'op' }, 'p:2');
|
|
await r.flush();
|
|
assert.deepEqual([r.fetched.length, r.started().length, r.a.landVoices.length], [0, 0, 0]);
|
|
r.a.setVolumes({ sfx: 0.8, muted: false });
|
|
await r.flush();
|
|
assert.deepEqual(r.fetched, [mediaUrl(SET), mediaUrl(TOKEN_SET)], 'audible again: the kept wish fetches them now');
|
|
r.a.deployCue({ def: PLAIN[2], kind: 'op' }, 'p:3');
|
|
await r.flush();
|
|
assert.equal(r.started().length, 1);
|
|
} finally { r.restore(); }
|
|
const bare = new AudioManager({ win: null, getManifest: () => ({ audio: { sfx: { battle: {}, units: {} } } }) });
|
|
assert.equal(bare.deployCue({ def: 'char_x', kind: 'op' }, 1), false);
|
|
const none = new AudioManager({ win: null, getManifest: () => null });
|
|
assert.equal(none.deployCue({ def: 'char_x', kind: 'op' }, 1), false);
|
|
assert.equal(none.deployCue(null, 1), false);
|
|
});
|
|
});
|