towerdef/e2e/scenarios/09-audio.js
Claude 28502984ec Co-op robustness, audio/a11y, new towers and enemies, Uplink rebalance
Co-op (QA'd with two to three real browsers, TCP-proxy chaos scenarios):
- partner's tower changes are never dropped after a render stall or snapshot burst
- half-open connections show "reconnecting" in ~6 s instead of 45-65 s
- upgrade and next-wave are idempotent (stale commands refused), restart message,
  promoted host gets Play again, failed joins never kill a live game, listener leaks

Audio / keyboard / a11y:
- one Audio element per track, fade/stinger supersede tokens, play() retry on the
  next gesture, 5 s fallback to the synth, mute works everywhere, dialogs with
  role/aria-modal/focus handling, accessible names for sound/speed/pause

New content:
- enemies: Daemon (healer), Proxy (regenerating shield), Botnet (flyer swarm);
  waves weave them in from wave 9 (waves 1-8 unchanged)
- towers: Sandbox (stun pulse), Load Balancer (fire-rate aura); hotkeys 1-9
- glyphs/shapes, stun/heal effects, gallery e2e that pixel-checks every kind

Orbital Uplink rebalanced after playtesting (was affordable by wave ~6 and buyable
in bulk from boss rewards): 1500 credits, upgrades 1200/2000/3200, and every Uplink
already owned makes the next one 25% dearer to buy AND to upgrade (each tower
remembers its multiplier, carried in the tower list as a 9th field). Shared
TD.priceFor/upgradePrice so the UI shows exactly what the sim charges.

Also: tablet/foldable viewports in the layout matrix (tolerant colour check),
docs (README tower/enemy tables, PROTOCOL shield/stun/pm encodings, NEXT roadmap).

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Tb8pW2KAN4oFkh1aK1BfD8
2026-10-10 21:18:43 +00:00

397 lines
27 KiB
JavaScript
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

'use strict';
/*
* Real audio, real files (public/assets/music via tracks.json), real Chromium. Every check reads the HTMLAudioElement itself
* (paused, volume, currentTime), not only NW.Audio.now: the old code said "playing" while the element had been paused.
*
* flow theme -> battle -> boss -> lose stinger -> Play again -> battle -> win stinger -> Keep going, with and without
* --autoplay-policy=no-user-gesture-required; one element and one download per track; boss and stingers preloaded (code-12, code-16)
* rapid five music() calls in one tick; M twice within 90 ms; M during the fade-in; Play again 100 ms after the end (code-7, code-16)
* mute M and the sound buttons work on the end screen and stop the stinger; state in the labels (code-13, code-27)
* late a stinger that loads late never plays over the next game (code-12)
* fallback a track that never answers or fails: synth within seconds, the file is used again later (code-15)
* gesture play() refused by the browser (iOS / Safari rules): retried at the next tap; strict "only inside a gesture" stub (code-14)
* coop Play again and Keep going start the music for BOTH players and stop the stinger (code-5)
*
* Headless Chromium resolves play() without a gesture whatever --autoplay-policy says, so code-14 is proven with a stub of the
* browser's rule, not with the flag.
*/
const { chromium } = require('playwright-core');
const { createServer } = require('../../server');
const assert = (c, m) => { if (!c) throw new Error('ASSERT: ' + m); console.log('ok -', m); };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
async function until(fn, ms, what) { const t0 = Date.now(); for (;;) { try { const v = await fn(); if (v) return v; } catch (e) { /* retry */ } if (Date.now() - t0 > ms) throw new Error('TIMEOUT: ' + what); await sleep(40); } }
// Injected before the game's scripts: every Audio element is recorded, so a test can look at all of them.
function instrument() {
window.__els = [];
const A = window.Audio;
window.Audio = function (src) { const el = src === undefined ? new A() : new A(src); window.__els.push(el); return el; };
window.Audio.prototype = A.prototype;
const nm = (e) => ((e.src || '').split('/').pop() || '').replace(/\.mp3$/, '');
window.__info = () => window.__els.map((e) => ({ n: nm(e), playing: !e.paused && !e.ended, vol: +e.volume.toFixed(2), t: +e.currentTime.toFixed(2), rs: e.readyState, err: e.error ? e.error.code : 0 }));
try { localStorage.setItem('nw.helped', 'true'); } catch (e) { /* ignore */ } // (the first-run help is tested elsewhere)
}
// The browser's rule on iOS / Safari, as a stub: play() is only allowed inside the dispatch of a tap, click or key press.
function strictPolicy() {
window.__gesture = false; window.__refused = 0;
for (const ev of ['pointerdown', 'pointerup', 'keydown', 'click', 'touchend']) {
window.addEventListener(ev, (e) => {
if (ev === 'pointerdown' && e.pointerType !== 'mouse') return; // (HTML: only a mouse press activates the page; a finger counts when it lifts)
window.__gesture = true; setTimeout(() => { window.__gesture = false; }, 0);
}, true);
}
const P = HTMLMediaElement.prototype.play;
HTMLMediaElement.prototype.play = function () {
if (!window.__gesture) { window.__refused++; return Promise.reject(new DOMException('play() failed: not allowed', 'NotAllowedError')); }
return P.apply(this, arguments);
};
}
// The refusal is the test's to switch: "the user has not allowed it yet" / "now they have".
function denyPolicy() {
window.__deny = true; window.__refused = 0;
const P = HTMLMediaElement.prototype.play;
HTMLMediaElement.prototype.play = function () {
if (window.__deny) { window.__refused++; return Promise.reject(new DOMException('play() failed: not allowed', 'NotAllowedError')); }
return P.apply(this, arguments);
};
}
const FILES = { theme: 'menu', battle: 'battle', boss: 'boss', win: 'win', lose: 'lose' };
const elsOf = async (page, n) => (await page.evaluate(() => window.__info())).filter((e) => e.n === n);
const audible = async (page, n) => (await elsOf(page, n)).some((e) => e.playing && e.vol > 0.05);
const silent = async (page, n) => (await elsOf(page, n)).every((e) => !e.playing);
const nowOf = (page) => page.evaluate(() => { const n = NW.Audio.now; return n ? n.name + ':' + n.kind : null; });
const state = (page) => page.evaluate(() => NW.app.ctrl.view.state);
const endShown = (page) => page.evaluate(() => !document.getElementById('end').hidden);
async function advancing(page, n) { // the file really plays: its clock runs
const a = (await elsOf(page, n)).find((e) => e.playing); if (!a) return false;
await sleep(450);
const b = (await elsOf(page, n)).find((e) => e.playing);
return !!b && b.t > a.t + 0.2;
}
async function newPage(browser, errors, setup, opts) {
const ctx = await browser.newContext(Object.assign({ viewport: { width: 1100, height: 700 }, serviceWorkers: 'block' }, opts || {}));
await ctx.addInitScript(instrument);
if (setup) await ctx.addInitScript(setup);
const page = await ctx.newPage();
page.on('pageerror', (e) => errors.push('pageerror: ' + e.message));
page.on('console', (m) => { if (m.type() === 'error' && !/Failed to load resource|net::ERR/.test(m.text())) errors.push('console.error: ' + m.text()); });
return { ctx, page };
}
async function startSolo(page, url) {
await page.goto(url); await sleep(350);
await page.click('#btnSolo');
await until(() => page.evaluate(() => NW.app.inGame), 2000, 'in game');
}
const lose = (page) => page.evaluate(() => { NW.app.ctrl.sim.lives = 0; });
// ------------------------------------------------------------------------------------------------ flow
async function flow(browser, url, errors, tag) {
console.log('--- flow (' + tag + ')');
const { ctx, page } = await newPage(browser, errors);
try {
await page.goto(url); await sleep(350);
const manifest = await page.evaluate(() => fetch('assets/music/tracks.json').then((r) => r.json()));
for (const n of Object.keys(FILES)) assert(typeof manifest[n] === 'string', 'tracks.json names a real file for ' + n);
assert((await nowOf(page)) === null, 'nothing plays before the first gesture');
await page.mouse.click(8, 8);
await until(async () => (await nowOf(page)) === 'theme:file' && await audible(page, 'menu'), 4000, 'menu theme plays from the file after the first tap');
assert(await advancing(page, 'menu'), 'menu.mp3 clock runs');
await page.click('#btnSolo');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'battle music starts');
await until(() => silent(page, 'menu'), 3000, 'the menu theme is paused after the crossfade');
assert(await advancing(page, 'battle'), 'battle.mp3 clock runs');
// the stingers load in the background once the battle track plays: the end screen has them ready
await until(async () => (await elsOf(page, 'lose')).length === 1 && (await elsOf(page, 'win')).length === 1, 6000, 'win and lose are preloaded after the battle track starts');
await until(async () => (await elsOf(page, 'lose'))[0].rs >= 3, 6000, 'lose.mp3 is ready before it is needed');
// boss: wave 8 is the wave before it, so the panel announces wave 9 and the boss track is fetched ahead
await page.evaluate(() => { NW.app.ctrl.sim.wave = 8; });
await until(async () => (await elsOf(page, 'boss')).length === 1, 3000, 'boss.mp3 is requested a wave or two ahead');
assert(await silent(page, 'boss'), '... but not played');
await until(async () => (await elsOf(page, 'boss'))[0].rs >= 3, 8000, 'boss.mp3 is ready before the boss');
await page.evaluate(() => { const s = NW.app.ctrl.sim; s.wave = 10; s.spawnQ.push({ t: 0, k: 'rootkit', wave: 10 }); });
await until(async () => (await nowOf(page)) === 'boss:file' && await audible(page, 'boss'), 4000, 'boss music takes over when the rootkit appears');
await until(() => silent(page, 'battle'), 3000, 'battle is paused while the boss plays');
await page.evaluate(() => { const s = NW.app.ctrl.sim; s.monsters.length = 0; s.spawnQ.length = 0; });
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'battle music is back when the boss is gone');
await until(() => silent(page, 'boss'), 3000, 'boss is paused again');
// lose: the music stops, the stinger plays
await lose(page);
await until(() => endShown(page), 4000, 'end screen');
await until(async () => (await nowOf(page)) === null && await audible(page, 'lose'), 3000, 'the lose stinger plays, the music is off');
await until(() => silent(page, 'battle'), 3000, 'battle is paused on the end screen');
await sleep(700);
await page.click('#btnAgain');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'Play again: battle music again');
await until(() => silent(page, 'lose'), 3000, 'the lose stinger stops with the new game');
assert(await advancing(page, 'battle'), 'battle clock runs after Play again');
// win and Keep going
await page.evaluate(() => { const s = NW.app.ctrl.sim; s.wave = 1; s.winWave = 1; });
await until(async () => (await state(page)) === 'won' && await audible(page, 'win'), 4000, 'the win stinger plays');
await until(() => silent(page, 'battle'), 3000, 'battle is paused on the win screen');
await sleep(700);
await page.click('#btnContinue');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'Keep going: battle music again');
await until(() => silent(page, 'win'), 3000, 'the win stinger stops');
const info = await page.evaluate(() => window.__info());
for (const n of ['menu', 'battle', 'boss', 'win', 'lose']) assert(info.filter((e) => e.n === n).length === 1, 'exactly one audio element for ' + n + ' in the whole session');
} finally { await ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ rapid
async function rapid(browser, url, errors) {
console.log('--- rapid: calls faster than loads and fades');
const { ctx, page } = await newPage(browser, errors);
try {
await page.goto(url); await sleep(350);
await page.mouse.click(8, 8);
await until(async () => (await nowOf(page)) === 'theme:file', 4000, 'theme');
await page.evaluate(() => { for (const n of ['battle', 'theme', 'battle', 'theme', 'battle']) NW.Audio.music(n); });
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'five music() calls in one tick end on battle');
await until(() => silent(page, 'menu'), 3000, 'and the theme is stopped');
const els = await page.evaluate(() => window.__info());
assert(els.filter((e) => e.n === 'battle').length === 1 && els.filter((e) => e.n === 'menu').length === 1, 'one element per track (battle ' + els.filter((e) => e.n === 'battle').length + ', menu ' + els.filter((e) => e.n === 'menu').length + ')');
// mute twice within 90 ms: net unmuted, the music must be playing and stay playing
await page.evaluate(() => { NW.Audio.music(null); NW.Audio.music('battle'); });
await page.click('#btnSolo'); await sleep(2500);
await page.keyboard.press('m'); await sleep(90); await page.keyboard.press('m');
await sleep(2500);
assert(!(await page.evaluate(() => NW.Audio.muted)), 'M, M: not muted');
assert(await audible(page, 'battle') && await advancing(page, 'battle'), 'M, M within 90 ms: the battle element still plays (a stale fade-out used to pause it)');
// mute during the fade-in, then unmute during the fade-out
await page.evaluate(() => { NW.Audio.music(null); }); await sleep(700);
await page.evaluate(() => NW.Audio.music('battle')); await sleep(250); // fading in
await page.keyboard.press('m');
await until(() => silent(page, 'battle'), 2000, 'M during the fade-in silences the music');
await sleep(1800);
assert(await silent(page, 'battle') && (await nowOf(page)) === null, 'and the fade-in does not bring it back');
await page.keyboard.press('m');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 3000, 'unmute brings the music back');
await page.keyboard.press('m'); await sleep(80); await page.keyboard.press('m'); // mute, and unmute inside the fade-out
await sleep(2200);
assert(await audible(page, 'battle') && await advancing(page, 'battle'), 'mute undone during its own fade-out: still playing');
// Play again 100 ms after the end screen opens: inside the old fade-out of the music
await lose(page);
await until(() => endShown(page), 4000, 'end screen');
await sleep(100);
await page.click('#btnAgain');
await sleep(2500);
assert(await audible(page, 'battle') && await advancing(page, 'battle'), 'Play again 100 ms after the end screen: battle plays');
} finally { await ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ mute
async function mute(browser, url, errors) {
console.log('--- mute: the end screen and the labels');
const { ctx, page } = await newPage(browser, errors);
try {
await startSolo(page, url);
await until(async () => await audible(page, 'battle'), 4000, 'battle plays');
assert((await page.getAttribute('#btnSound', 'aria-label')) === 'Mute sound', 'Sound button: "Mute sound" while the sound is on');
await page.click('#btnSpeed');
await until(async () => (await page.getAttribute('#btnSpeed', 'aria-label')) === 'Game speed 2×', 1500, 'the speed button says the speed: Game speed 2×');
await page.click('#btnSpeed'); await page.click('#btnSpeed');
await until(async () => (await page.getAttribute('#btnSpeed', 'aria-label')) === 'Game speed 1×', 1500, 'and back to 1×');
await page.click('#btnPause');
await until(async () => (await page.getAttribute('#btnPause', 'aria-pressed')) === 'true', 1500, 'Pause is pressed while paused');
assert((await page.getAttribute('#btnPause', 'aria-label')) === 'Pause', 'and keeps its name "Pause" (a toggle does not rename itself)');
await page.click('#btnPause');
await lose(page);
await until(() => endShown(page), 4000, 'end screen');
await until(async () => await audible(page, 'lose'), 3000, 'lose stinger plays');
const covered = await page.evaluate(() => { const b = document.getElementById('btnSound').getBoundingClientRect(); const e = document.elementFromPoint(b.left + b.width / 2, b.top + b.height / 2); return !!e && !!e.closest('#end'); });
assert(covered, 'the top-bar Sound button is behind the end dialog (so the dialog has its own)');
await page.keyboard.press('m');
assert(await page.evaluate(() => NW.Audio.muted), 'M on the end screen mutes');
await until(() => silent(page, 'lose'), 2000, 'and the stinger stops');
assert((await page.locator('#btnEndSound').count()) === 1 && (await page.isVisible('#btnEndSound')), 'the end dialog has its own sound button');
await until(async () => (await page.textContent('#btnEndSound')) === 'Sound: off', 1500, 'the end dialog button follows: Sound: off');
assert((await page.getAttribute('#btnSound', 'aria-label')) === 'Unmute sound', 'the top-bar button name is now "Unmute sound"');
await sleep(700);
await page.click('#btnAgain');
await sleep(2200);
assert((await nowOf(page)) === null && await silent(page, 'battle'), 'a new game while muted stays silent');
await lose(page);
await until(() => endShown(page), 4000, 'end screen again');
await sleep(900);
assert(await silent(page, 'lose'), 'no stinger while muted');
await page.click('#btnEndSound');
assert(!(await page.evaluate(() => NW.Audio.muted)), 'the end dialog button unmutes');
await until(async () => (await page.textContent('#btnEndSound')) === 'Sound: on', 1500, 'and shows it');
await sleep(700);
await page.click('#btnAgain');
await until(async () => await audible(page, 'battle'), 4000, 'unmuted: battle plays again');
// menu: M and the menu's own button
await page.click('#btnMenu');
await page.keyboard.press('m');
assert(await page.evaluate(() => NW.Audio.muted), 'M mutes in the menu');
await until(async () => (await page.textContent('#btnMenuSound')) === 'Sound: off', 1500, 'the menu button follows: Sound: off');
await page.click('#btnMenuSound');
assert(!(await page.evaluate(() => NW.Audio.muted)), 'the menu button unmutes');
} finally { await ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ late stinger
async function late(browser, url, errors) {
console.log('--- late: a stinger that arrives after Play again');
const { ctx, page } = await newPage(browser, errors);
try {
await page.route('**/assets/music/lose.mp3', async (route) => { await sleep(2500); try { await route.continue(); } catch (e) { /* page closed */ } });
await startSolo(page, url);
await until(async () => await audible(page, 'battle'), 4000, 'battle plays');
await lose(page); // (before the stingers are preloaded: lose.mp3 is first requested now)
await until(() => endShown(page), 4000, 'end screen');
await sleep(700);
await page.click('#btnAgain');
const t0 = Date.now(); let bad = 0;
while (Date.now() - t0 < 6500) { // (the first 1.5 s: a stinger that is still loading has `paused` false but makes no sound, and a loaded one is fading out)
if (Date.now() - t0 > 1500 && (await elsOf(page, 'lose')).some((e) => e.playing && e.vol > 0.05 && e.rs >= 3)) bad++;
await sleep(100);
}
assert(bad === 0, 'the late lose stinger never played over the new game');
assert(await audible(page, 'battle'), 'the battle music plays');
} finally { await ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ fallback
async function fallback(browser, url, errors) {
console.log('--- fallback: a track that never answers, and one that fails');
const { ctx, page } = await newPage(browser, errors);
try {
let held = null;
await page.route('**/assets/music/battle.mp3', (route) => { if (!held) held = route; else route.continue().catch(() => {}); }); // the first request hangs: no bytes, no error
await startSolo(page, url);
const t0 = Date.now();
await until(async () => (await nowOf(page)) === 'battle:synth', 9000, 'a file that never answers: the synth takes over');
const took = Date.now() - t0;
assert(took < 7500, 'within ' + took + ' ms (it was 10 to 35 s, or never)');
assert(await silent(page, 'battle'), 'the stalled element is not playing');
if (held) await held.continue().catch(() => {}); // the server answers at last
await until(async () => (await elsOf(page, 'battle')).some((e) => e.rs >= 3), 8000, 'the file arrives');
await page.evaluate(() => { NW.Audio.music('theme'); });
await sleep(300);
await page.evaluate(() => { NW.Audio.music('battle'); });
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 4000, 'the next time the track is wanted, the file plays');
assert((await elsOf(page, 'battle')).length === 1, 'still one element');
} finally { await ctx.close(); }
const b2 = await newPage(browser, errors);
try {
await b2.page.route('**/assets/music/battle.mp3', (route) => route.abort());
await startSolo(b2.page, url);
await until(async () => (await nowOf(b2.page)) === 'battle:synth', 3000, 'a file that fails: the synth takes over at once');
await b2.page.unroute('**/assets/music/battle.mp3');
await b2.page.evaluate(() => { if (NW.Audio.timing) NW.Audio.timing.retry = 500; });
await sleep(800);
await b2.page.evaluate(() => { NW.Audio.music('theme'); });
await sleep(300);
await b2.page.evaluate(() => { NW.Audio.music('battle'); });
await until(async () => (await nowOf(b2.page)) === 'battle:file' && await audible(b2.page, 'battle'), 5000, 'after the server is back the file is tried again (it used to stay synth for the whole session)');
} finally { await b2.ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ gesture
async function gesture(browser, url, errors) {
console.log('--- gesture: play() refused until the user allows it (code-14)');
let T = await newPage(browser, errors, denyPolicy);
try {
const page = T.page;
await page.goto(url); await sleep(350);
await page.mouse.click(8, 8);
await sleep(900);
assert((await nowOf(page)) === null && (await page.evaluate(() => window.__refused)) >= 1, 'the first tap: play() was refused, nothing plays (refused ' + (await page.evaluate(() => window.__refused)) + 'x)');
await page.evaluate(() => { window.__deny = false; });
await page.mouse.click(8, 8);
await until(async () => (await nowOf(page)) === 'theme:file' && await audible(page, 'menu'), 3000, 'the next tap retries it: the theme plays');
assert((await elsOf(page, 'menu')).length === 1, 'on the same element');
} finally { await T.ctx.close(); }
console.log('--- gesture: play() only inside a tap (the strict stub)');
T = await newPage(browser, errors, strictPolicy);
try {
const page = T.page;
await page.goto(url); await sleep(500);
await page.mouse.click(8, 8);
await until(async () => (await nowOf(page)) === 'theme:file' && await audible(page, 'menu'), 3000, 'the first tap starts the theme: play() is called inside the tap');
await page.click('#btnSolo');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 3000, 'Play solo starts the battle music inside the tap');
// the boss track is started by the game loop, outside any tap: refused, and waiting for the next one
await page.evaluate(() => { const s = NW.app.ctrl.sim; s.wave = 10; s.spawnQ.push({ t: 0, k: 'rootkit', wave: 10 }); });
await until(async () => (await page.evaluate(() => NW.Audio.blocked === true)) || (await nowOf(page)) === 'boss:file', 4000, 'the boss track is either refused or plays');
await page.mouse.click(300, 300);
await until(async () => (await nowOf(page)) === 'boss:file' && await audible(page, 'boss'), 3000, 'the next tap on the board starts it');
} finally { await T.ctx.close(); }
console.log('--- gesture: a finger (pointerdown is no gesture, the lift is)');
T = await newPage(browser, errors, strictPolicy, { viewport: { width: 390, height: 844 }, deviceScaleFactor: 2, isMobile: true, hasTouch: true });
try {
const page = T.page;
await page.goto(url); await sleep(500);
await page.touchscreen.tap(195, 30);
await until(async () => (await nowOf(page)) === 'theme:file' && await audible(page, 'menu'), 3000, 'the first tap of a finger starts the theme (the press was refused, the lift retried it)');
assert((await elsOf(page, 'menu')).length === 1, 'on one element');
await page.tap('#btnSolo');
await until(async () => (await nowOf(page)) === 'battle:file' && await audible(page, 'battle'), 3000, 'Play solo by finger starts the battle music');
} finally { await T.ctx.close(); }
}
// ------------------------------------------------------------------------------------------------ coop
async function coop(browser, errors) {
console.log('--- coop: Play again and Keep going start the music for both players');
const srv = await createServer({ port: 0, host: '127.0.0.1', log: () => {}, pingMs: 0 }), url = 'http://127.0.0.1:' + srv.port + '/';
const A = await newPage(browser, errors), B = await newPage(browser, errors);
try {
const joined = (P) => P.page.evaluate(() => NW.app.ctrl.kind === 'remote' && NW.app.ctrl.status === 'joined');
await A.page.goto(url); await sleep(300);
await A.page.click('#btnCoop'); await A.page.fill('#inName', 'Alice'); await A.page.click('#btnCreate');
await until(() => joined(A), 6000, 'host joined');
const room = await A.page.evaluate(() => NW.app.ctrl.room);
await B.page.goto(url + '?room=' + room); await sleep(300);
await B.page.fill('#inName', 'Bob'); await B.page.click('#btnJoin');
await until(() => joined(B), 6000, 'guest joined');
const R = srv.rooms.get(room);
const both = async (fn) => (await fn(A.page)) && (await fn(B.page));
await until(() => both(async (p) => (await nowOf(p)) === 'battle:file' && await audible(p, 'battle')), 5000, 'both hear the battle music');
R.sim.lives = 0;
await until(() => both(endShown), 5000, 'both see the end screen');
await until(() => both(async (p) => (await nowOf(p)) === null && await audible(p, 'lose')), 4000, 'both: stinger on, music off');
await sleep(700);
await A.page.click('#btnAgain');
await until(() => both(async (p) => (await state(p)) === 'playing' && !(await endShown(p))), 4000, 'new game on both');
await until(() => both(async (p) => (await nowOf(p)) === 'battle:file' && await audible(p, 'battle')), 4000, 'Play again: the battle music plays on the host AND on the guest');
await until(() => both((p) => silent(p, 'lose')), 3000, 'and the lose stinger stopped on both');
R.sim.wave = 1; R.sim.winWave = 1;
await until(() => both(async (p) => (await state(p)) === 'won' && await audible(p, 'win')), 5000, 'both: win stinger');
await sleep(700);
await A.page.click('#btnContinue');
await until(() => both(async (p) => (await state(p)) === 'playing' && !(await endShown(p))), 4000, 'the game goes on for both');
await until(() => both(async (p) => (await nowOf(p)) === 'battle:file' && await audible(p, 'battle')), 4000, 'Keep going: the battle music plays on the host AND on the guest');
await until(() => both((p) => silent(p, 'win')), 3000, 'and the win stinger stopped on both');
} finally { await A.ctx.close(); await B.ctx.close(); await srv.close(); }
}
module.exports = async function ({ url, out }) {
const errors = [];
const run = async (flag, fn) => { const b = await chromium.launch({ args: ['--no-sandbox'].concat(flag ? [flag] : []) }); try { await fn(b); } finally { await b.close(); } };
await run('--autoplay-policy=no-user-gesture-required', (b) => flow(b, url, errors, 'no-user-gesture-required'));
await run('--autoplay-policy=document-user-activation-required', (b) => flow(b, url, errors, 'document-user-activation-required'));
await run(null, async (b) => {
await rapid(b, url, errors);
await mute(b, url, errors);
await late(b, url, errors);
await fallback(b, url, errors);
await gesture(b, url, errors);
await coop(b, errors);
});
if (errors.length) throw new Error('console errors:\n' + errors.join('\n'));
console.log('no console errors');
};