wuwiandClaude Opus 5
b5838b2b24
Three things off the back of the picker. THE LIVE PLAYER on the setup screen is the real sprite through the real tint, not a mock-up of the pick — so the menu cannot promise a colour the court will not keep. It redraws on every tap of a tour, a kit or a skin. THE WOMEN'S TOUR IS NO LONGER SAT OUT. Her set is drawn head to toe in whites, so there was no hue to rotate — the answer is not a dye but a WASH: the pick laid over her whites at a low saturation with the lightness kept, which is how you dye a white kit in life and gives rose, powder blue, mint, lilac. Her hair and skin fall out of it on lightness alone, which is exactly what a dye could not manage. THE FRIEND ACROSS THE NET now wears what they picked on their own phone. Their look crosses on pairing, and since the opponent art is red rather than blue the kit rides its own hue arc — safe there for the one reason it would not be on the player's own sheets: the opponent sprites carry no drawn blood. An older build simply never sends it and the opponent draws as before; the match still plays. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
750 lines
43 KiB
JavaScript
750 lines
43 KiB
JavaScript
// Splatter Tennis — boot, main loop, intro overlay, and the window.T test hooks.
|
||
// World units: meters. z axis = court depth, 0 at FAR baseline, 23.77 at NEAR baseline.
|
||
// Module map: config (tuning/constants) · state (mutable game state) · gameplay (logic/update)
|
||
// render (camera/drawing) · input (keys/touch) · audio (sfx/umpire) · panel (T tuning UI)
|
||
|
||
import { TUNE, COURTS, TOURS, KITS, SKINS, MODES, MENU, DIFFS, EATEN_RESTART, DONE_RESTART, WEAPONS, bossArt, CUP_ROUNDS, matchFoe } from './config.js';
|
||
import { P, O, ball, score, G, setupPoint, selectCourt, selectTour, selectKit, selectSkin } from './state.js';
|
||
import { update, restartRun, keyPressed, solveShot, inServeBox, inCourt, forceZombies, startGore, splatPoint, deliverTin, selectWeapon, grantWeapon, showModal, dismissModal, flickTarget, dragServe, toggleTestMode } from './gameplay.js';
|
||
import { startDuel, resolveInterlude, startBossFight, endBossFight, startDrill, endDrill, startMatch, endMatch, startBench, endBench, FALL, benchFall, startNetVs } from './beats.js';
|
||
import { netConnect, netHooks } from './net.js';
|
||
import { fitViewport, render, proj, RES, SPRV, LOAD, SPR, drawLook } from './render.js';
|
||
import { voice, ambient, menuMusic, menuDuck } from './audio.js';
|
||
import { zombies, spawnZombie, spawnRacketZombie, spawnMachine, spawnChapterBoss, piles, gore, parts, pellets, extras, shots, pops, explode, hurtPlayer, killPlayer , spawnBarrel } from './zombies.js';
|
||
import { cv } from './dom.js';
|
||
import * as stats from './stats.js';
|
||
import './input.js';
|
||
|
||
let last = performance.now();
|
||
// T.pause(true) freezes the WORLD but keeps drawing, so a value changed in devtools shows up on the
|
||
// next frame without the scene moving on underneath you. Halting rAF instead (the old test recipe)
|
||
// freezes the picture too, which is useless for looking at a shot.
|
||
let paused = false;
|
||
// CALM STATES RUN SLOW. The battery bill is fill-rate × frame-rate, and two screens can sit on a
|
||
// phone for minutes while fully static: a SETTLED modal (the world is frozen behind it — only the
|
||
// blink still moves) and the death summary once its fade and gore have played out. 20-odd fps
|
||
// there is invisible and thirds the drain; live play stays at TUNE.fps, untouched — the 60 was a
|
||
// feel decision and this deliberately never applies to anything that moves.
|
||
const calmFps = () => G.modal && G.modal.in >= 1 ? 20
|
||
: G.mode === 'eaten' && G.eatenT > EATEN_RESTART + 1 ? 24 : 0;
|
||
let lowPowerApplied = false; // the last lowPower state fitViewport was run under (T-panel flips it live)
|
||
function frame(now) {
|
||
requestAnimationFrame(frame); // schedule FIRST: one bad frame must never kill the loop (a thrown error froze the game for good)
|
||
if ((TUNE.lowPower >= 0.5) !== lowPowerApplied) { lowPowerApplied = TUNE.lowPower >= 0.5; fitViewport(); }
|
||
const cap = calmFps() || TUNE.fps;
|
||
if (cap && now - last < 1000 / cap - 2) return; // frame cap (battery): skip RAF ticks until it's our beat
|
||
// THE MENU IS OPAQUE (#intro: fixed, inset 0, solid background). Painting the whole court at RES
|
||
// density behind it — for the minutes a phone idles on the splash and stats screens — was pure
|
||
// battery burn nobody could see. The world holds still too; nothing on it predates the menu.
|
||
if (menuUp()) { last = now; return; }
|
||
if (paused) { last = now; render(); return; }
|
||
let dt = Math.min(0.04, (now - last) / 1000); last = now;
|
||
// A chapter boss dies in slow motion. The clock that ENDS it runs at real speed, so the effect is
|
||
// always the same length in seconds however far the world has been slowed.
|
||
if (G.slowT > 0) { G.slowT -= dt; dt *= TUNE.bossSlowMo; }
|
||
update(dt); render();
|
||
}
|
||
|
||
fitViewport();
|
||
// iOS PWA cold start. Launched from the homescreen, WebKit resolves the viewport AND every env()
|
||
// safe-area inset once, against a provisional geometry, and never revisits them until the geometry
|
||
// is "exercised" — which is why the game only filled the screen after a rotate and back, and why
|
||
// waiting for an event could never work: nothing fires. Toggling viewport-fit off and on is the
|
||
// known WebKit workaround: it forces that recalculation without the user rotating anything.
|
||
// Standalone only, because that is the only mode with the bug.
|
||
if (navigator.standalone || matchMedia('(display-mode: standalone)').matches) {
|
||
const meta = document.querySelector('meta[name=viewport]'), real = meta.content;
|
||
meta.content = real.replace('viewport-fit=cover', 'viewport-fit=auto');
|
||
requestAnimationFrame(() => { meta.content = real; requestAnimationFrame(fitViewport); });
|
||
}
|
||
setupPoint();
|
||
// warm both faces so the canvas never paints a system-serif fallback frame
|
||
if (document.fonts) for (const f of ['700 8px Silkscreen', '400 8px Silkscreen', '400 20px Bangers'])
|
||
document.fonts.load(f);
|
||
|
||
// The overlay is a four-stage machine: splash -> {setup, stats, ranks}. The title screen IS the
|
||
// menu — a separate menu stage behind it showed the same logo on the same backdrop and read as the
|
||
// title screen failing to advance. One overlay throughout, swapped by data-stage, so the court never
|
||
// flashes between screens; HIDDEN during play rather than removed, so a restart puts it back.
|
||
const intro = document.getElementById('intro');
|
||
const menuUp = () => !intro.hidden;
|
||
const remembered = k => { try { return localStorage.getItem(k); } catch { return null; } };
|
||
let picked = remembered('court') || COURTS[0].id;
|
||
let pickedTour = remembered('tour') || TOURS[0].id;
|
||
const go = stage => { intro.dataset.stage = stage; menuMusic(); }; // every stage change is a gesture, so it is also a safe place to (re)start the theme
|
||
|
||
// --- MODE selection in TWO STEPS (config.MENU + config.MODES): three posters on top, and the
|
||
// picked one deals its own second step underneath — classic deals the difficulty chips, zombie
|
||
// tennis deals its two sub-mode cards, gore just is gore. `pickedMode` stays the RUN mode id
|
||
// (classic/zombie/cup/gore) so start(), stats and the summary never learn about the grouping.
|
||
let pickedMode = remembered('mode') || MODES[0].id;
|
||
let pickedDiff = remembered('diff') || 'medium';
|
||
const modeOf = id => MODES.find(x => x.id === id);
|
||
const topOf = m => MENU.find(t => t.mode === m || (t.kids && t.kids.includes(m))) || MENU[0];
|
||
const modeList = document.getElementById('modeList');
|
||
const modeSub = document.getElementById('modeSub');
|
||
// QUESTION SCREENS CARRY NO SELECTION (Oliver: a highlighted card that also navigates is "a
|
||
// checkbox and a button combined"). Every poster is full-bright and equal — all of them are live
|
||
// answers — and the only memory shown is the LAST tag, an indicator rather than a selection. The
|
||
// select-and-confirm border lives solely on the final screen, where SERVE UP actually confirms.
|
||
const banner = (card, cls, last) => {
|
||
const b = document.createElement('button');
|
||
b.className = cls;
|
||
// the scrim rides IN the background stack (gradient over art), so the caption needs no extra box
|
||
b.style.backgroundImage =
|
||
`linear-gradient(180deg, rgba(0,0,0,0) 34%, rgba(0,0,0,0.78)), url(assets/${card.art}.png?v=${SPRV})`;
|
||
b.innerHTML = `<span class="cb"><b>${card.name}</b><i>${card.sub}</i></span>`
|
||
+ (last ? '<u class="last">LAST</u>' : '');
|
||
return b;
|
||
};
|
||
const pickMode = id => { pickedMode = id; try { localStorage.setItem('mode', id); } catch {} };
|
||
// TAP ADVANCES. Each screen's tap both answers and moves on — the wizard's whole promise is one
|
||
// decision per screen, and a NEXT button under a single row of choices is a second tap for nothing.
|
||
// NETPLAY's second step: two chips, and either one IS the start — a room needs a socket, not a
|
||
// setup screen (court and tour ride whatever was last picked). HOST shows the code to share in a
|
||
// modal over the frozen court; JOIN asks for a friend's code.
|
||
// ponytail: prompt() is the join UI — replace with a drawn code entry if the mode ships.
|
||
// The host's one decision — classic or the death match — rides the room, so the joiner never picks
|
||
// a mode: the start message carries it to both phones and both courts are rebuilt on pairing.
|
||
function netChip(label, join, death = false) {
|
||
const b = document.createElement('button');
|
||
b.className = 'chip';
|
||
b.textContent = label;
|
||
b.addEventListener('click', () => {
|
||
let code = null;
|
||
if (join) {
|
||
code = (prompt('ROOM CODE FROM YOUR OPPONENT') || '').trim().toUpperCase();
|
||
if (!code) return;
|
||
}
|
||
start('classic'); // the waiting court is classic either way; a death room swaps it on pairing
|
||
// the host's court rides the room too (server.py) — the guest plays where the host plays
|
||
if (startNetVs()) netConnect(code, death, picked);
|
||
});
|
||
return b;
|
||
}
|
||
|
||
function buildSub(top) {
|
||
modeSub.innerHTML = '';
|
||
const t = top || topOf(pickedMode);
|
||
document.getElementById('subTitle').textContent = t.diffs ? 'DIFFICULTY' : (t.name || '');
|
||
if (t.net) {
|
||
modeSub.appendChild(netChip('HOST — CLASSIC TENNIS', false));
|
||
modeSub.appendChild(netChip('HOST — DEATH MATCH', false, true));
|
||
modeSub.appendChild(netChip('JOIN WITH A CODE', true));
|
||
return;
|
||
}
|
||
if (t.diffs) for (const d of DIFFS) {
|
||
const b = document.createElement('button');
|
||
b.className = 'chip';
|
||
b.innerHTML = d.name + (d.id === pickedDiff ? '<u class="last">LAST</u>' : '');
|
||
b.addEventListener('click', () => {
|
||
pickedDiff = d.id;
|
||
try { localStorage.setItem('diff', d.id); } catch {}
|
||
summary();
|
||
go('setup');
|
||
});
|
||
modeSub.appendChild(b);
|
||
}
|
||
else if (t.kids) for (const id of t.kids) {
|
||
const b = banner(modeOf(id), 'mode', id === pickedMode);
|
||
b.addEventListener('click', () => {
|
||
pickMode(id);
|
||
summary();
|
||
go('setup');
|
||
});
|
||
modeSub.appendChild(b);
|
||
}
|
||
}
|
||
// the top posters are rebuilt on every visit so the LAST tag follows what was actually played
|
||
function buildTops() {
|
||
modeList.innerHTML = '';
|
||
for (const t of MENU) {
|
||
const b = banner(t.mode ? modeOf(t.mode) : t, 'mode', topOf(pickedMode) === t);
|
||
b.addEventListener('click', () => {
|
||
// the netplay poster deals HOST/JOIN and never touches pickedMode — it is not a run mode
|
||
// the stats screen or the summary could name, and either chip starts the game itself
|
||
if (t.net) { buildSub(t); go('modesub'); return; }
|
||
// a group remembers which child you were on; entering it fresh lands on its first card
|
||
pickMode(t.mode || (t.kids.includes(pickedMode) ? pickedMode : t.kids[0]));
|
||
buildSub();
|
||
summary();
|
||
go(t.diffs || t.kids ? 'modesub' : 'setup');
|
||
});
|
||
modeList.appendChild(b);
|
||
}
|
||
}
|
||
buildTops();
|
||
buildSub();
|
||
|
||
// --- tour tiles, built from the table. Same "tap selects, SERVE UP starts" rule as the court rows —
|
||
// the setup screen picks WHO and WHERE, and nothing on it commits you.
|
||
const tourList = document.getElementById('tours');
|
||
for (const t of TOURS) {
|
||
const b = document.createElement('button');
|
||
b.className = t.id === pickedTour ? 'on' : '';
|
||
b.innerHTML = `<img src="assets/${t.tile}.png?v=${SPRV}" alt=""><b>${t.name}</b>`;
|
||
b.addEventListener('click', () => {
|
||
pickedTour = t.id;
|
||
for (const el of tourList.children) el.classList.toggle('on', el === b);
|
||
refreshLook();
|
||
summary();
|
||
});
|
||
tourList.appendChild(b);
|
||
}
|
||
// THE LIVE PLAYER, redrawn on every tap of a tour, a kit or a skin. It draws the REAL sprite through
|
||
// the REAL tint (drawLook), so there is no second recolour to keep in step with the first — the only
|
||
// way this can show a wrong colour is if the court would show it too.
|
||
// The sprite sheets load asynchronously and the menu deliberately parks the game loop, so the first
|
||
// draw can land before the art does: retry on a slow poll that stops itself the moment it succeeds.
|
||
const lookCv = document.getElementById('look');
|
||
let lookPoll = 0;
|
||
function refreshLook() {
|
||
const t = TOURS.find(x => x.id === pickedTour) || TOURS[0];
|
||
const ok = drawLook(lookCv, t, KITS.find(e => e.id === pickedKit) || KITS[0],
|
||
SKINS.find(e => e.id === pickedSkin) || SKINS[0]);
|
||
clearTimeout(lookPoll);
|
||
if (!ok) lookPoll = setTimeout(refreshLook, 200); // sprites still coming; ask again shortly
|
||
}
|
||
|
||
// --- KIT and SKIN swatches, built from the tables. Same rule as the tour tiles: tapping selects and
|
||
// nothing more, SERVE UP is what commits. Both rows are one builder — they differ only in which
|
||
// table they read and which localStorage key they remember, and a second copy of this loop to say
|
||
// "skin" instead of "kit" would be the same eleven lines twice.
|
||
const swatches = (rowId, nameId, table, keyName, get, set) => {
|
||
const row = document.getElementById(rowId), label = document.getElementById(nameId);
|
||
for (const e of table) {
|
||
const b = document.createElement('button');
|
||
b.className = e.id === get() ? 'on' : '';
|
||
b.style.background = e.sw;
|
||
b.title = e.name; // desktop hover; the h3 label is what a phone reads
|
||
b.setAttribute('aria-label', e.name);
|
||
b.addEventListener('click', () => {
|
||
set(e.id);
|
||
try { localStorage.setItem(keyName, e.id); } catch {}
|
||
for (const el of row.children) el.classList.toggle('on', el === b);
|
||
label.textContent = e.name;
|
||
refreshLook();
|
||
});
|
||
row.appendChild(b);
|
||
}
|
||
label.textContent = (table.find(e => e.id === get()) || table[0]).name;
|
||
};
|
||
let pickedKit = remembered('kit') || KITS[0].id;
|
||
let pickedSkin = remembered('skin') || SKINS[0].id;
|
||
swatches('kitRow', 'kitName', KITS, 'kit', () => pickedKit, id => pickedKit = id);
|
||
swatches('skinRow', 'skinName', SKINS, 'skin', () => pickedSkin, id => pickedSkin = id);
|
||
refreshLook();
|
||
|
||
// --- court rows, built from the table.
|
||
// The two meters come out of the court's OWN bounce numbers rather than a pair of hand-written
|
||
// ratings, so a physics change moves the bars with it and the screen can never advertise a court
|
||
// that plays differently from what it says.
|
||
// SPEED how much pace survives the bounce — bounceXZ, grass .84 fastest, clay .70 slowest
|
||
// BOUNCE how much of it comes back UP — bounceY, clay .66 highest, grass .50 lowest
|
||
// The two divisors just stretch those narrow real ranges across a full bar; they carry no physics.
|
||
const meter = (label, v, cls = '') =>
|
||
`<div class="meter ${cls}"><u>${label}</u><s><i style="width:${
|
||
Math.round(Math.min(1, Math.max(0.08, v)) * 100)}%"></i></s></div>`;
|
||
const courtList = document.getElementById('courtList');
|
||
for (const c of COURTS) {
|
||
const b = document.createElement('button');
|
||
b.className = 'court' + (c.id === picked ? ' on' : ''); // your last court comes up pre-picked
|
||
b.innerHTML = `<img src="assets/${c.tile}.png?v=${SPRV}" alt=""><span class="cb">`
|
||
+ `<b>${c.name}</b><i>${c.sub}</i>`
|
||
+ meter('SPEED', (c.bounceXZ - 0.62) / 0.26)
|
||
+ meter('BOUNCE', (c.bounceY - 0.44) / 0.28, 'b')
|
||
+ '</span>';
|
||
// Tapping a tile SELECTS it and nothing more. It used to start the match on the spot, which gave
|
||
// you no way to look at the three of them and no way back out of the screen.
|
||
b.addEventListener('click', () => {
|
||
picked = c.id;
|
||
for (const el of courtList.children) el.classList.toggle('on', el === b);
|
||
summary();
|
||
});
|
||
courtList.appendChild(b);
|
||
}
|
||
|
||
// ---- THE DRAW (Oliver, 2026-08-15: "when starting the tournament there should be a view of the
|
||
// tournament hierarchy but only the finale is settled — the game against the champion... random
|
||
// browsing through the roster in the individual spots which begins fast, gets slower and then
|
||
// settles on a random character, so that every tournament is new").
|
||
//
|
||
// THE SCREEN IS THE DRAW, NOT A TEASER. `cupPicks` is what walks on: startMatch takes it and
|
||
// cupDraw reads it instead of rolling its own, so the face you watched land in ROUND ONE is the
|
||
// body across the net. A screen that showed a different draw from the one being played would be
|
||
// worse than no screen — it would teach the player that the ceremony is a lie.
|
||
//
|
||
// The roll is one recursive setTimeout per row whose gap grows with p^2 — fast, then visibly
|
||
// slowing, then stopped. No rAF: the menu deliberately parks the game loop (see menuUp), and three
|
||
// staggered timers are the whole animation.
|
||
const cupRows = document.getElementById('cupRows'), cupGo = document.getElementById('cupGo');
|
||
let cupPicks = null, cupSpins = [];
|
||
// the portrait: every family's own head crop (assets/_heads.py), the club pro's included — the
|
||
// same file the in-play walk-on card uses, so the draw and the court show the same face
|
||
const foeArt = f => `assets/z_${f.fam}head.png?v=${SPRV}`;
|
||
|
||
function buildBracket() {
|
||
for (const t of cupSpins) clearTimeout(t);
|
||
cupSpins = [];
|
||
cupPicks = CUP_ROUNDS.map(r => r.band[Math.floor(Math.random() * r.band.length)]);
|
||
cupRows.innerHTML = '';
|
||
cupGo.disabled = true;
|
||
document.getElementById('brState').textContent = 'DRAWING…';
|
||
document.getElementById('brSum').innerHTML =
|
||
`<span>ONLY THE FINAL WAS EVER SETTLED</span><span>${
|
||
(COURTS.find(c => c.id === picked) || COURTS[0]).name}</span>`;
|
||
CUP_ROUNDS.forEach((r, i) => {
|
||
const fixed = r.band.length === 1; // the final: one rung, nothing to roll
|
||
const row = document.createElement('div');
|
||
row.className = 'cupRow' + (fixed ? ' fin set' : '');
|
||
row.innerHTML = `<u>${r.name}</u><img alt=""><b></b><i>${
|
||
r.need === 1 ? 'ONE GAME' : r.need + ' GAMES'}</i>`;
|
||
cupRows.appendChild(row);
|
||
const img = row.querySelector('img'), nm = row.querySelector('b');
|
||
const show = n => { const f = matchFoe(n); img.src = foeArt(f); nm.textContent = f.name; };
|
||
if (fixed) return show(cupPicks[i]);
|
||
const t0 = performance.now(), len = 1500 + i * 550; // 1.5 / 2.05 / 2.6 s — they land in order
|
||
(function roll() {
|
||
const p = Math.min(1, (performance.now() - t0) / len);
|
||
if (p >= 1) {
|
||
show(cupPicks[i]);
|
||
row.classList.add('set');
|
||
if (cupRows.querySelectorAll('.set').length === CUP_ROUNDS.length) {
|
||
cupGo.disabled = false;
|
||
document.getElementById('brState').textContent = 'THE DRAW IS MADE';
|
||
}
|
||
return;
|
||
}
|
||
show(r.band[Math.floor(Math.random() * r.band.length)]);
|
||
cupSpins.push(setTimeout(roll, 45 + 330 * p * p));
|
||
})();
|
||
});
|
||
}
|
||
document.getElementById('brBack').addEventListener('click', () => {
|
||
for (const t of cupSpins) clearTimeout(t); // a screen you walked out of must stop spinning
|
||
cupSpins = [];
|
||
go('setup');
|
||
});
|
||
document.getElementById('cupGo').addEventListener('click', () => start('cup'));
|
||
|
||
// Which RECORD BOOK a run mode writes to. The four run modes share three books — the arcade ladder
|
||
// and the tournament are both zombie tennis and are counted together (see the record-shape note in
|
||
// stats.endRun). Lived inline in three places before the world board grew tabs of its own.
|
||
const boardFor = m => m === 'zombie' || m === 'cup' ? stats.MODE_MATCH
|
||
: m === 'classic' ? stats.MODE_CLASSIC : stats.MODE_GORE;
|
||
|
||
// what the setup footer says you are about to play, and what it is worth beating
|
||
function summary() {
|
||
const t = TOURS.find(x => x.id === pickedTour) || TOURS[0];
|
||
const c = COURTS.find(x => x.id === picked) || COURTS[0];
|
||
const m = MODES.find(x => x.id === pickedMode) || MODES[0];
|
||
// the mark to beat is the PICKED MODE's own, because the three of them do not measure the same
|
||
// thing — see the record-shape note in stats.endRun. The cup banks through endRun as MODE_MATCH
|
||
// (see cupWon), so its summary reads the same book it writes.
|
||
const best = stats.read('all', undefined, boardFor(m.id)).longest;
|
||
const unit = m.id === 'zombie' || m.id === 'cup' ? ' FELLED'
|
||
: best === 1 ? ' GAME' : ' GAMES';
|
||
const name = m.id === 'classic'
|
||
? m.name + ' · ' + (DIFFS.find(d => d.id === pickedDiff) || DIFFS[1]).name : m.name;
|
||
document.getElementById('sSum').innerHTML =
|
||
`<span>${name} · ${t.name.replace(' SINGLES', '')} · ${c.name}</span>`
|
||
+ `<span>${best ? best + unit + ' TO BEAT' : 'FIRST RUN'}</span>`;
|
||
}
|
||
|
||
// The splash carries ONE number, on the STATS button. A boxed BEST RUN / WORLD RANK bar across the
|
||
// top came out of the mockup and went again: it sat on the best part of the art and said twice what
|
||
// the two buttons underneath already say. Re-read whenever the splash comes back up, because a run
|
||
// has just ended and the count has moved.
|
||
function refreshSplash() {
|
||
document.getElementById('mKills').textContent = stats.total().kills.toLocaleString('en-GB') + ' KILLS';
|
||
summary();
|
||
}
|
||
|
||
// `modeId` is the mode to drop into. It defaults to what the setup screen picked — but the BACK
|
||
// ROOM passes null, because those entries bring their own mode and a remembered ZOMBIE TENNIS was
|
||
// taking the court before startDrill/startBench/toggleTestMode could, so every one of them silently
|
||
// refused. The sprite bench found this the first time it was opened.
|
||
function start(modeId = pickedMode) {
|
||
if (!menuUp()) return;
|
||
selectTour(pickedTour);
|
||
selectKit(pickedKit); selectSkin(pickedSkin);
|
||
selectCourt(picked);
|
||
menuDuck(true); // the theme belongs to the menus — hand the court over to the ambience
|
||
intro.hidden = true; ambient(); voice('quiet_please'); // low atmosphere bed starts with the first gesture
|
||
// ...and the mode the setup screen picked. THREE LINES, because that is genuinely all the modes
|
||
// differ by at this point: gore is the game as it always was, classic is the same tennis with the
|
||
// turn switched off, and zombie tennis is the match taking the court. Everything else about a mode
|
||
// lives in the code that reads G.classic / G.match, never here.
|
||
quitChip.hidden = false; // the door out rides every run (see the quit block below)
|
||
G.classic = modeId === 'classic';
|
||
// the difficulty rides on G like G.classic does, so a mid-run restart keeps the CPU you chose
|
||
G.diff = G.classic ? (DIFFS.find(d => d.id === pickedDiff) || DIFFS[1]) : null;
|
||
if (modeId === 'gore') startGore(); // no tennis prologue: the mode you picked is the mode you get
|
||
if (modeId === 'zombie') { intoSplatter(); startMatch(); }
|
||
// ...and the cup carries the draw the bracket screen just made. Null (the #cup back door) still
|
||
// means "roll it yourself", which is what the mode did before the screen existed.
|
||
if (modeId === 'cup') { intoSplatter(); startMatch(true, cupPicks); }
|
||
}
|
||
let stPeriod = 'all', stMode = stats.MODE_GORE;
|
||
// the stats screen opens on the mode you last PICKED to play — that is the one whose numbers you
|
||
// came to look at, and it saves a tap on the way in every single time
|
||
const openStats = () => {
|
||
stMode = boardFor(pickedMode);
|
||
for (const el of document.getElementById('stModes').children) el.classList.toggle('on', el.dataset.m === stMode);
|
||
stats.drawStats(stPeriod, SPRV, stMode); go('stats');
|
||
};
|
||
// entering a question screen rebuilds it, so the LAST tag always names the run actually played
|
||
const goMode = () => { buildTops(); go('mode'); };
|
||
document.getElementById('mStart').addEventListener('click', goMode);
|
||
document.getElementById('mStats').addEventListener('click', openStats);
|
||
// the world board opens on the mode you last PICKED, like the stats screen does — that is the one
|
||
// whose names you came to look at
|
||
let rkMode = stats.MODE_GORE;
|
||
const openRanks = () => {
|
||
rkMode = boardFor(pickedMode);
|
||
for (const el of document.getElementById('rkModes').children) el.classList.toggle('on', el.dataset.m === rkMode);
|
||
go('ranks'); stats.drawRanks(null, rkMode);
|
||
};
|
||
document.getElementById('mRanks').addEventListener('click', openRanks);
|
||
document.getElementById('rkModes').addEventListener('click', e => {
|
||
const b = e.target.closest('button'); if (!b) return;
|
||
rkMode = b.dataset.m;
|
||
for (const el of e.currentTarget.children) el.classList.toggle('on', el === b);
|
||
stats.drawRanks(null, rkMode);
|
||
});
|
||
|
||
// --- THE NAME PROMPT. It appears on exactly one occasion: a run that beat your own best on ITS
|
||
// OWN board (every mode has one now), on the tap that takes you off the death screen. Anything
|
||
// more often is a form standing between you and the next match.
|
||
const nbName = document.getElementById('nbName'), nbMsg = document.getElementById('nbMsg');
|
||
let nbRun = null;
|
||
function askName(run) {
|
||
nbRun = run;
|
||
const B = stats.BOARDS[run.mode] || stats.BOARDS[stats.MODE_GORE];
|
||
// the prompt names the BOARD's number, not the gore mode's — a tournament run that said
|
||
// "5 KILLS" would be describing something nobody was playing for
|
||
document.getElementById('nbScore').innerHTML =
|
||
`<b>${run.score.toLocaleString('en-GB')}</b> ${B.unit} · <b>${run.sub}</b> ${B.subUnit}`;
|
||
nbName.value = stats.savedName();
|
||
nbMsg.textContent = 'PUT IT ON THE WORLD BOARD.';
|
||
document.getElementById('nbSend').disabled = false;
|
||
go('newbest');
|
||
// focus only where a keyboard is already there. On a phone this would throw the soft keyboard up
|
||
// over the score you just earned, before you have read it.
|
||
if (!matchMedia('(pointer: coarse)').matches) nbName.focus();
|
||
}
|
||
document.getElementById('nbSkip').addEventListener('click', () => { nbRun = null; go('splash'); });
|
||
document.getElementById('nbSend').addEventListener('click', async () => {
|
||
const name = stats.tidyName(nbName.value);
|
||
if (!name) { nbMsg.textContent = 'A NAME FIRST.'; nbName.focus(); return; }
|
||
nbName.value = name; // show what is actually going on the board
|
||
if (!nbRun) return go('splash');
|
||
const btn = document.getElementById('nbSend');
|
||
btn.disabled = true; nbMsg.textContent = 'SENDING…'; // the double-tap posts twice otherwise
|
||
try {
|
||
const r = await stats.submit(name, nbRun.score, nbRun.sub, nbRun.mode);
|
||
rkMode = nbRun.mode; // ...and the board that opens is the one you just wrote your name on
|
||
for (const el of document.getElementById('rkModes').children)
|
||
el.classList.toggle('on', el.dataset.m === rkMode);
|
||
nbRun = null;
|
||
go('ranks');
|
||
stats.drawRanks(r.scores, rkMode); // the board came back with the reply — no second round trip
|
||
} catch (e) {
|
||
btn.disabled = false;
|
||
nbMsg.textContent = e.taken ? 'THAT NAME IS SPOKEN FOR. PICK ANOTHER.'
|
||
: 'THE BOARD DID NOT ANSWER. TRY AGAIN?';
|
||
if (e.taken) { nbName.select(); nbName.focus(); }
|
||
}
|
||
});
|
||
nbName.addEventListener('keydown', e => { if (e.key === 'Enter') document.getElementById('nbSend').click(); });
|
||
// () => start(), NEVER `start` — addEventListener hands the listener a MouseEvent as its first
|
||
// argument, so `start(modeId = pickedMode)` never saw its default and modeId was an EVENT OBJECT.
|
||
// `G.classic = modeId === 'classic'` was therefore always false and the zombie branch never fired:
|
||
// SERVE UP dropped you into the gore mode whatever the setup screen said, and picking CLASSIC or
|
||
// ZOMBIE TENNIS did nothing at all. A default parameter only applies to `undefined`, and a click
|
||
// handler always passes something.
|
||
// SERVE UP starts the run — except in the cup, where the draw has to be made first. That screen
|
||
// carries its own start button, so this stays the one place a run begins from the setup screen.
|
||
document.getElementById('cStart').addEventListener('click', () => {
|
||
if (pickedMode === 'cup') { buildBracket(); go('bracket'); return; }
|
||
start();
|
||
});
|
||
for (const id of ['mBack', 'stBack', 'rkBack', 'scBack'])
|
||
document.getElementById(id).addEventListener('click', () => go('splash'));
|
||
// the wizard walks back the way it came: who-and-where returns to the mode's own second step when
|
||
// it has one, the second step returns to the posters
|
||
document.getElementById('subBack').addEventListener('click', goMode);
|
||
document.getElementById('sBack').addEventListener('click', () => {
|
||
const t = topOf(pickedMode);
|
||
if (t.diffs || t.kids) { buildSub(); go('modesub'); }
|
||
else goMode();
|
||
});
|
||
document.getElementById('bsBack').addEventListener('click', () => go('secret'));
|
||
|
||
// ---- THE BACK ROOM: five taps in the TOP-LEFT CORNER of the splash (#hot, an invisible box in
|
||
// index.html), and nothing on the screen says so. It replaces the triple-tap on the in-play
|
||
// scoreboard, which sat on top of the miss-log tap and which the testteam kept opening by accident.
|
||
// The corner rather than the logo: on the way to PLAY MATCH your thumb crosses the middle of the
|
||
// splash all the time, and a hidden door you can open by accident is just a bug with a secret.
|
||
let logoTaps = [];
|
||
document.getElementById('hot').addEventListener('pointerdown', () => {
|
||
const now = performance.now();
|
||
logoTaps = logoTaps.filter(t => now - t < 2000);
|
||
logoTaps.push(now);
|
||
if (logoTaps.length >= 5) { logoTaps = []; go('secret'); }
|
||
});
|
||
|
||
// Both entries drop you into a REAL run rather than a special mode — same update loop, same
|
||
// scoring, same death — which is the only way a test tells you anything about the game.
|
||
// This is laserScene's trick: force the turn and then step the transition out in one go, because
|
||
// the cinematic is ten seconds you did not come here to watch.
|
||
function intoSplatter() {
|
||
startGore(); // the direct door. It used to force the turn and then step the whole 8-second
|
||
// cinematic out in 900 hidden updates — every sound it makes fired in one frame.
|
||
G.modal = null; G.horde = null; G.hordeWarn = 0; G.interlude = false; G.changeover = 0; G.clearing = false;
|
||
G.mgT = 0; G.gunId = null; G.beam = null; G.hp = G.hpMax = TUNE.playerHp;
|
||
zombies.length = 0; shots.length = 0; pellets.length = 0;
|
||
score.server = 'P'; setupPoint();
|
||
}
|
||
netHooks.intoSplatter = intoSplatter; // netplay's death match enters splatter through the same hack
|
||
document.getElementById('scWeapons').addEventListener('click', () => {
|
||
start(null); intoSplatter(); toggleTestMode();
|
||
});
|
||
document.getElementById('scBosses').addEventListener('click', () => go('bosses'));
|
||
// THE DRILL, from the back room — the cognitive mode's feel-test. Like the two above it drops
|
||
// into a real run first (same loop, same contact rules) and then hands the court to startDrill,
|
||
// which refuses if anything else still owns it.
|
||
document.getElementById('scDrill').addEventListener('click', () => {
|
||
start(null); intoSplatter();
|
||
startDrill();
|
||
});
|
||
document.getElementById('scMatch').addEventListener('click', () => {
|
||
start(null); intoSplatter();
|
||
startMatch();
|
||
});
|
||
// (netplay has no back-room button: the VS A FRIEND poster on the mode screen IS the door, and
|
||
// #net / #net-CODE below covers sending a phone straight in from a URL)
|
||
// THE SPRITE BENCH — the art test. Same "drop into a real run first" trick as its neighbours, so the
|
||
// body is drawn by the real renderer at the real size, on the real court, under the real palette.
|
||
// Judging a walk cycle anywhere else is judging a different picture.
|
||
document.getElementById('scBench').addEventListener('click', () => {
|
||
start(null); intoSplatter();
|
||
startBench();
|
||
});
|
||
|
||
// The list is built by ASKING bossArt which design each chapter gets, so it can never drift from
|
||
// what the run actually spawns — including the champion sitting on chapter 10 rather than 7.
|
||
const bossList = document.getElementById('bossList');
|
||
for (let ch = 1; ch <= 10; ch++) {
|
||
const art = bossArt(ch), b = document.createElement('button');
|
||
b.innerHTML = `<img src="assets/${art.walk[0]}.png?v=${SPRV}" alt="">`
|
||
+ `<b>${art.name}</b><i>CHAPTER ${ch} · GAME ${ch * TUNE.bossEvery}</i>`;
|
||
b.addEventListener('click', () => {
|
||
start(null); intoSplatter();
|
||
G.runGames = ch * TUNE.bossEvery; // the roster, the HUD and the spawn ramp all read this one
|
||
G.bossDue = 0; // ...and the schedule must not queue a SECOND fight behind it
|
||
for (const id of Object.keys(WEAPONS)) grantWeapon(id, TUNE.wCap); // full arsenal, every tin
|
||
G.weapon = 0;
|
||
startBossFight(ch);
|
||
});
|
||
bossList.appendChild(b);
|
||
}
|
||
// the three period tabs are one listener on the strip — the button carries the period in data-p
|
||
// the two tab strips are one listener each — the button carries its value in a data attribute
|
||
document.getElementById('stTabs').addEventListener('click', e => {
|
||
const b = e.target.closest('button'); if (!b) return;
|
||
stPeriod = b.dataset.p;
|
||
for (const el of e.currentTarget.children) el.classList.toggle('on', el === b);
|
||
stats.drawStats(stPeriod, SPRV, stMode);
|
||
});
|
||
document.getElementById('stModes').addEventListener('click', e => {
|
||
const b = e.target.closest('button'); if (!b) return;
|
||
stMode = b.dataset.m;
|
||
for (const el of e.currentTarget.children) el.classList.toggle('on', el === b);
|
||
stats.drawStats(stPeriod, SPRV, stMode);
|
||
});
|
||
refreshSplash();
|
||
|
||
// THE BOOT GATE. render.js fires all ~230 sprite requests at import; this only watches them and
|
||
// keeps the splash's buttons out of reach until the last one has landed and both faces are ready.
|
||
// Without it a cold start could open the stats screen — which hangs <img> tags on the same files —
|
||
// or start a rally while half the sheets were still in flight, and the missing ones drew as
|
||
// whatever the fallback was. onerror counts too (render.js), so a dead network still finishes the
|
||
// bar rather than parking the player on it forever.
|
||
const splash = document.getElementById('splash'), bootFill = document.querySelector('#boot i');
|
||
splash.classList.add('busy');
|
||
const loaded = () => !splash.classList.contains('busy');
|
||
// setInterval, NOT requestAnimationFrame: rAF does not fire in a hidden tab, and a phone that
|
||
// launches the app and locks — or an install that loads in the background — would come back to a
|
||
// bar frozen at whatever it reached and a menu with no buttons on it. An interval still ticks
|
||
// (throttled to about a second), so the gate always opens.
|
||
const tick = setInterval(function watchLoad() {
|
||
const frac = LOAD.total ? LOAD.done / LOAD.total : 1;
|
||
bootFill.style.width = (frac * 100).toFixed(1) + '%';
|
||
if (frac < 1) return;
|
||
clearInterval(tick);
|
||
// fonts.ready resolves once nothing is pending — including the three faces warmed above — so the
|
||
// first canvas frame is never the system serif.
|
||
(document.fonts ? document.fonts.ready : Promise.resolve()).then(() => splash.classList.remove('busy'));
|
||
}, 100);
|
||
|
||
// THE FIRST TAP ANYWHERE ON THE OVERLAY STARTS THE THEME, and does nothing else — the screens have
|
||
// real buttons now. This is the gesture the autoplay policy is waiting for, which is why the theme
|
||
// is not started at boot. menuMusic itself is a no-op once the bed exists (loopBed's beds.has
|
||
// guard), so coming back from a run picks up the track already playing rather than restarting it.
|
||
intro.addEventListener('pointerdown', () => menuMusic());
|
||
// which build am I looking at? Push = deploy and the browser cannot see git, so the served file's
|
||
// own timestamp IS the version marker — it changes on every deploy, with nothing to remember to bump.
|
||
// Match it against `git log -1 --format=%cd` when a phone looks suspiciously out of date.
|
||
fetch('src/main.js', { method: 'HEAD' }) // page-relative: index.html sits at the root, the code in src/
|
||
.then(r => { const t = r.headers.get('last-modified'); if (!t) return;
|
||
document.getElementById('build').textContent = 'BUILD ' + new Date(t).toLocaleString('en-GB').replace(',', ''); })
|
||
.catch(() => {}); // no header, no line — never a broken start screen
|
||
// Keyboard, per stage. On the splash Enter/Space goes to setup and S opens the stats; on the setup
|
||
// screen 1..N picks a court and Enter starts; Escape backs out to the splash from anywhere.
|
||
addEventListener('keydown', e => {
|
||
if (!menuUp()) return;
|
||
menuMusic(); // a key is a gesture too — unlock the theme on a desktop that never taps
|
||
const stage = intro.dataset.stage;
|
||
if (e.key === 'Escape') return go('splash');
|
||
if (stage === 'splash') {
|
||
if (!loaded()) return; // the boot bar hides the buttons; a key must not walk past it
|
||
if (e.key === 'Enter' || e.key === ' ') goMode();
|
||
else if (e.key === 's' || e.key === 'S') openStats();
|
||
return;
|
||
}
|
||
if (stage !== 'setup') return; // stats and ranks are read-only: Escape is the whole interface
|
||
const n = parseInt(e.key, 10);
|
||
if (n >= 1 && n <= COURTS.length) courtList.children[n - 1].click();
|
||
// through the BUTTON, not start() — the cup's draw screen sits between the two and a keyboard
|
||
// must not be the one way to walk past it
|
||
else if (e.key === 'Enter' || e.key === ' ') document.getElementById('cStart').click();
|
||
});
|
||
|
||
// A run the player walks out on is still a run. killPlayer banks a death; this banks everything
|
||
// else — the tab closed mid-match, the phone's browser killed in the background. `pagehide` is the
|
||
// one that actually fires on iOS, where beforeunload/unload do not. endRun is idempotent and
|
||
// no-ops on an empty run, so closing the tab at the menu writes nothing.
|
||
addEventListener('pagehide', () => {
|
||
if (G.mode !== 'splatter') return;
|
||
// ...tagged with the mode that was being played, and carrying THAT mode's two headline numbers —
|
||
// see the record-shape note in stats.endRun. A match abandoned mid-rally is a match run.
|
||
if (G.match) stats.endRun(G.match.opp - 1, score.games[0] + score.games[1], G.splatT, false, stats.MODE_MATCH);
|
||
else stats.endRun(G.runGames, G.sets[0], G.splatT, false);
|
||
});
|
||
|
||
// eaten: any tap or key returns to the title — but only once the death animation has played out, so
|
||
// a panic tap during the gore burst can't skip it. A modal owns its own gesture (see input.js).
|
||
// NOT a page reload any more: that reset everything honestly but also tore down the AudioContext, so
|
||
// the theme restarted from silence. restartRun puts every bag back from a pristine copy, and the
|
||
// bed that has been playing under the death summary simply carries on into the title screen.
|
||
const maybeRestart = () => {
|
||
// ...and the classic ending taps out the same way, on its own shorter clock (G.done, no corpse)
|
||
const ready = G.done ? G.done.t > DONE_RESTART : G.mode === 'eaten' && G.eatenT > EATEN_RESTART;
|
||
if (G.modal || !ready) return;
|
||
restartRun();
|
||
refreshSplash(); // the run just ended: the splash count has moved
|
||
intro.hidden = false;
|
||
quitChip.hidden = true; // the door out goes with the run it belonged to
|
||
// stats.lastRun() survives restartRun on purpose — it lives in the stats module, not on G, which
|
||
// has just been restored from PRISTINE. Consumed on read, so the prompt appears once.
|
||
const run = stats.lastRun();
|
||
// ...on the BOARD's number, not on kills: a classic match has none, so the gore-shaped test here
|
||
// silently barred two of the three modes from ever reaching the prompt
|
||
if (run && run.newKillBest && run.score > 0) askName(run);
|
||
else go('splash');
|
||
};
|
||
cv.addEventListener('pointerdown', maybeRestart);
|
||
addEventListener('keydown', maybeRestart);
|
||
|
||
// THE DOOR OUT (Oliver: every tennis screen lacked an exit — force-closing the app was the only
|
||
// way back). The chip shows for the whole run; tapping it (or Escape on desktop) freezes the
|
||
// world and asks. Quitting is the death path minus the death: restartRun resets everything and
|
||
// nothing is banked — an abandoned run never happened, statistically.
|
||
const quitChip = document.getElementById('quit'), qAsk = document.getElementById('qAsk');
|
||
document.getElementById('qChip').addEventListener('click', () => { paused = true; qAsk.hidden = false; });
|
||
document.getElementById('qNo').addEventListener('click', () => { qAsk.hidden = true; paused = false; });
|
||
document.getElementById('qYes').addEventListener('click', () => {
|
||
qAsk.hidden = true; paused = false; quitChip.hidden = true;
|
||
restartRun();
|
||
refreshSplash();
|
||
intro.hidden = false;
|
||
go('splash');
|
||
});
|
||
addEventListener('keydown', e => {
|
||
if (e.key !== 'Escape' || !intro.hidden || quitChip.hidden) return;
|
||
qAsk.hidden = !qAsk.hidden;
|
||
paused = !qAsk.hidden;
|
||
});
|
||
|
||
// A tap on the SCOREBOARD toggles the miss-log overlay, and that is now all it does. The triple-tap
|
||
// that opened test mode has moved to the back room on the splash (see below): a cheat you can trip
|
||
// by accident mid-run is a bug, and this one sat on the one thing you tap to read the log.
|
||
cv.addEventListener('pointerdown', e => {
|
||
const r = cv.getBoundingClientRect();
|
||
const x = (e.clientX - r.left) / r.width * (cv.width / RES); // logical coords
|
||
const y = (e.clientY - r.top) / r.height * (cv.height / RES);
|
||
if (x >= 6 && x <= 138 && y >= 6 && y <= 36) G.logShow = !G.logShow; // the scoreboard
|
||
});
|
||
|
||
|
||
|
||
// ---- A POSED SCENE for tuning a shot: `T.laserScene()`, or load with #laser. Six bodies of
|
||
// different types at known depths, the laser armed, a pull held.
|
||
// IT DOES NOT PAUSE, deliberately. The first version froze the world so the picture would hold
|
||
// still — and then every TUNE value you changed did nothing visible, because nothing redrew. The
|
||
// bodies are held still individually (v = 0) and spawning is off instead, so the picture is stable
|
||
// while the render loop keeps running and an edit shows on the very next frame.
|
||
function laserScene() {
|
||
const intro = document.getElementById('intro');
|
||
if (intro) intro.hidden = true;
|
||
paused = false;
|
||
if (G.mode === 'tennis') forceZombies();
|
||
for (let i = 0; i < 600; i++) update(1 / 60); // ride the transition out into splatter
|
||
G.modal = null; G.horde = null; G.hordeWarn = 0; G.interlude = false; G.changeover = 0; G.clearing = false;
|
||
G.mgT = 0; G.gunId = null; G.beam = null; G.bossFight = 0; G.hp = G.hpMax = TUNE.playerHp;
|
||
zombies.length = 0; pellets.length = 0; parts.length = 0; gore.length = 0; piles.length = 0;
|
||
score.server = 'P'; setupPoint();
|
||
P.x = 0;
|
||
TUNE.zMax = 0; // nothing new wanders into the shot
|
||
for (const [x, z, v] of [[0, 20, 'a'], [0.75, 16, 'b'], [-0.85, 12, 'k'],
|
||
[0.85, 8.5, 'g'], [-0.75, 5.5, 'h'], [0, 3, 'e']]) {
|
||
spawnZombie(x, z, v);
|
||
zombies[zombies.length - 1].v = 0; // held still: the scene is a photograph
|
||
}
|
||
G.rack.length = 0; G.temp = null;
|
||
G.weapon = grantWeapon('laser');
|
||
G.modal = null;
|
||
G.aim = { fx: 0, fy: -1, mag: 100 }; // a full pull straight up-court (fy is NEGATIVE)
|
||
return 'posed and LIVE — change TUNE (T panel or console) and it redraws. T.laserFire() to shoot it.';
|
||
}
|
||
// fire the posed shot, then pose it again so you can keep tuning
|
||
function laserFire() {
|
||
G.aim = null; score.server = 'P'; setupPoint();
|
||
keyPressed('Space');
|
||
return 'fired — T.laserScene() to re-pose';
|
||
}
|
||
// a plain timer, not the load event: this module runs as a module, so `load` may already have gone
|
||
if (location.hash === '#laser') setTimeout(laserScene, 600);
|
||
// #drill — the same door from a URL, so a phone can be sent straight into the mode
|
||
if (location.hash === '#drill') setTimeout(() => { start(null); intoSplatter(); startDrill(); }, 700);
|
||
if (location.hash === '#match') setTimeout(() => { start(null); intoSplatter(); startMatch(); }, 700);
|
||
if (location.hash === '#cup') setTimeout(() => { start(null); intoSplatter(); startMatch(true); }, 700);
|
||
if (location.hash === '#bench') setTimeout(() => { start(null); intoSplatter(); startBench(); }, 700);
|
||
// #net hosts classic, #netd hosts a death match, #net-ABCD joins — the netplay doors from a URL
|
||
if (location.hash === '#netd') setTimeout(() => {
|
||
start('classic');
|
||
if (startNetVs()) netConnect(null, true, picked);
|
||
}, 700);
|
||
else if (location.hash.startsWith('#net')) setTimeout(() => {
|
||
start('classic');
|
||
if (startNetVs()) netConnect(location.hash.slice(5).toUpperCase() || null, false, picked);
|
||
}, 700);
|
||
|
||
requestAnimationFrame(frame);
|
||
|
||
// exposed for in-browser sanity checks and simulated playtests
|
||
window.T = { TUNE, ball, P, O, score, G, zombies, keyPressed, SPR, laserScene, laserFire, pause: v => { paused = v !== false; }, spawnZombie, spawnRacketZombie, spawnMachine, spawnChapterBoss, spawnBarrel, grantWeapon, toggleTestMode, piles, gore, parts, pellets, extras, shots, pops, explode, hurtPlayer, killPlayer, splatPoint, solveShot, inServeBox, inCourt, proj, setupPoint, forceZombies, deliverTin, selectWeapon, showModal, dismissModal, dragServe, startDuel, resolveInterlude, flickTarget, startBossFight, endBossFight, startDrill, endDrill, startMatch, endMatch,
|
||
stats, step: dt => update(dt), render, press: keyPressed, FALL, benchFall,
|
||
get phase() { return G.phase; }, set phase(v) { G.phase = v; } };
|