wuwiandClaude Opus 5
ffac9b5512
Steps 1-3 of the late-game depth plan, after Oliver's 50+ game playtest. "Sometimes the racket zombie doesn't seem harmable" was real, not a feeling. Three of the five rack slots did nothing at all to him and said nothing about it: TRIPLE side balls skipped him, GUN and horde pellets skipped him, fire couldn't ignite him. BOMB meanwhile deleted him outright ignoring his hp. All of it now routes through one wound() with a TUNE.dmg* table, so damage is proportional to the body and a future 20 hp boss needs no new code. Fractional damage banks on zb.chip so whole points only come off hp — the wound skins switch on hp thresholds. His contact radius goes to 0.7 m, because part of "unharmable" was just missing him. Melee still skips him and that's correct: he's on the far side of the net and melee can't span it. The HP bar is gone. It was the only floating UI on a body, it was on screen for nearly the whole run, and nobody knew what it meant — while the wound skins already say the same thing in the language every other multi-hit enemy uses. A one-per-run modal explains what he is instead. Skins and bleed anchors now read a fraction of hpMax, since his hp scales with the run. And the plateau: every difficulty dial bottomed out by about game 12, so games 12-50 were arithmetically identical. Body cap, spawn gap, shamble speed, variant mix, boss hp and horde size all keep climbing now, calibrated to track the old curve through game 12 rather than replace it. One deliberate exception: shamble speed was time-based and maxed during game 2, so the early game is genuinely gentler now — zSpeedPerGame if that reads flabby. HANDOFF carries the full spec for steps 4 and 5 (ranged attacks with player damage, then chapter bosses) including the decisions we settled, so the next session can pick it up cold. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
509 lines
31 KiB
JavaScript
509 lines
31 KiB
JavaScript
// The splatter phase: shamblers, gore decals, particles. The ball is the weapon;
|
||
// tennis scoring keeps running via gameplay.splatPoint. Zombies advance toward
|
||
// your baseline — one crossing it is a point for THEM.
|
||
// (zombies <-> gameplay is a runtime-only import cycle, same pattern as input.)
|
||
|
||
import { TUNE, UI, COURT } from './config.js';
|
||
import { G, P, ball, sendBoy, setupPoint } from './state.js';
|
||
import { splat, moan, pock, voice, boom, swish, shriek, aww, sfx } from './audio.js';
|
||
import { splatPoint, cheer, spentBall, resolveInterlude, showModal } from './gameplay.js';
|
||
|
||
export const zombies = []; // {x, z, v, walkT, variant: 'a'|'b'|'c'}
|
||
export const gore = []; // lawn decals {x, z, r, a} — the flat ground layer
|
||
export const piles = []; // 3D-ish gore mounds {x, z, size 1..4, seed} — grow where kills cluster
|
||
export const parts = []; // splatter particles {x, y, z, vx, vy, vz, t, dark}
|
||
export const pellets = []; // machine-gun rounds during a horde {x, y, z, vx, vz, t}
|
||
export const extras = []; // triple-serve side balls {x, y, z, vx, vy, vz, pow, t} — ballistic clones
|
||
|
||
let spawnT = 1.5, moanT = 3;
|
||
|
||
export function spawnZombie(x, z, variant) {
|
||
// Keyed on GAMES FINISHED, not on splatT: the old `1 + min(1.5, splatT / 70)` maxed out after
|
||
// 105 seconds of splatter, so every shambler from roughly game 3 onward walked at the same top
|
||
// speed for the rest of a 50-game run. Games are what the player experiences as progress.
|
||
const ramp = 1 + Math.min(TUNE.zSpeedMax, G.runGames * TUNE.zSpeedPerGame);
|
||
const zb = { x, z, v: TUNE.zSpeed * ramp * (0.8 + Math.random() * 0.4), walkT: Math.random() * 9,
|
||
homeOff: (Math.random() * 2 - 1) * 0.8, variant }; // personal lane offset so they don't stack into a column
|
||
if (variant === 'f') { zb.v = Math.min(TUNE.runnerVMax, zb.v * TUNE.runnerSpeed); shriek(); } // shriek = the fairness contract; capped so late runners stay reactable
|
||
if (variant === 'a' || variant === 'b') zb.hp = TUNE.shamblerHp; // classic shamblers take a wound before they drop — only the runner is one-shot glass
|
||
if (variant === 'g') { zb.v *= 0.55; zb.hp = TUNE.bruteHp; } // slow, but soaks hits
|
||
if (variant === 's') zb.shieldT = 0; // chair up; > 0 = seconds of stagger left
|
||
zombies.push(zb);
|
||
}
|
||
|
||
// Which shambler steps out next. Unlocks are keyed on GAMES, not on sets won: a set is six games,
|
||
// so the old top gate (`tier >= 2`) opened around game 12 and after that the mix was frozen forever
|
||
// at 15% shield / 15% brute / 12% runner — a third of why a 50-game run stopped changing.
|
||
// Now the advanced SHARE keeps climbing after everything is unlocked, which is what makes game 40
|
||
// feel different from game 20 rather than merely faster.
|
||
function pickVariant() {
|
||
const g = G.runGames;
|
||
const pool = [];
|
||
if (g >= 2 && !zombies.some(z => z.variant === 'f')) pool.push('f'); // at most one runner alive
|
||
if (g >= 6) pool.push('g');
|
||
if (g >= 12) pool.push('s');
|
||
const nasty = Math.min(TUNE.nastyMax, g * TUNE.nastyPerGame);
|
||
if (pool.length && Math.random() < nasty) return pool[Math.floor(Math.random() * pool.length)];
|
||
return Math.random() < 0.5 ? 'a' : 'b';
|
||
}
|
||
|
||
// How big a target a body is. Bosses are deliberately a little more generous than a shambler —
|
||
// part of "the racket zombie doesn't seem harmable" was simply missing him.
|
||
const hitR = zb => zb.variant === 'g' ? 0.75 : zb.variant === 'r' ? 0.7 : 0.55;
|
||
|
||
// core kill: remove the zombie, spawn its gore/pile/particles, score. No ball coupling —
|
||
// shared by ball hits, machine-gun pellets, melee swipes, and extra (multi-serve) balls.
|
||
// how absurdly a variant dies: classics splash, the advanced roster DETONATES
|
||
const GORE_MUL = { a: 1, b: 1, f: 1.8, s: 2.5, g: 4, r: 3 };
|
||
|
||
function killZombie(i, quiet) {
|
||
const zb = zombies[i];
|
||
const mul = GORE_MUL[zb.variant] || 1;
|
||
zombies.splice(i, 1);
|
||
if (G.interlude && zb.variant === 'r') resolveInterlude('P'); // regicide ends the duel your way — any weapon counts
|
||
const stains = Math.round(Math.sqrt(mul)); // advanced kills splash a scatter of stains, not one puddle
|
||
for (let k = 0; k < stains; k++) {
|
||
gore.push({ x: zb.x + (k ? (Math.random() * 2 - 1) * 0.9 : 0), z: zb.z + (k ? (Math.random() * 2 - 1) * 0.9 : 0),
|
||
r: (0.45 + Math.random() * 0.35) * Math.sqrt(mul), a: 0.85 });
|
||
if (gore.length > 40) gore.shift();
|
||
}
|
||
const pl = piles.find(p => Math.hypot(p.x - zb.x, p.z - zb.z) < 0.6); // stack up where kills cluster
|
||
if (pl) pl.size = Math.min(4, pl.size + Math.round(mul / 2 + 0.5));
|
||
else { piles.push({ x: zb.x, z: zb.z, size: Math.min(4, Math.round(mul / 2 + 0.5)), seed: Math.random() * 1e4, blobs: null, builtSize: 0 });
|
||
if (piles.length > 30) piles.shift(); }
|
||
const n = Math.round(30 * mul); // base bumped 24 -> 30, then the multiplier goes to work
|
||
for (let k = 0; k < n; k++) { const dark = k >= n * 2 / 3; parts.push({ // ~1/3 dark & long-lived: settling gore
|
||
x: zb.x, y: 0.9, z: zb.z,
|
||
vx: (Math.random() * 2 - 1) * 3.5, vy: 1 + Math.random() * 3.5, vz: (Math.random() * 2 - 1) * 3.5,
|
||
t: dark ? 0.6 + Math.random() * 0.6 : 0.4 + Math.random() * 0.4, dark,
|
||
}); }
|
||
splat();
|
||
sfx('headshot-' + (Math.random() < 0.5 ? 1 : 2), 0.6); // random headshot crack layered on the gore burst
|
||
sendBoy(zb.x, zb.z, true); // a boy comes out with the mop
|
||
if (!G.horde && !G.clearing) splatPoint('P', quiet); // horde = survival, clearing = mopping up an already-won game — neither scores
|
||
}
|
||
|
||
// ---- fire. The flame ball doesn't just kill what it touches, it starts an epidemic: the kill
|
||
// ignites its neighbours, and every burning body keeps igniting whatever it shambles past.
|
||
// Read-only over zombies[] (it only sets burnT), so it is safe to call from inside a kill loop.
|
||
export function ignite(x, z, r) {
|
||
for (const zb of zombies) {
|
||
if (!zb || zb.burnT > 0) continue; // the boss DOES catch now — just at TUNE.bossBurnMul the rate,
|
||
// so fire is a real answer to a big body instead of a no-op
|
||
if (Math.hypot(zb.x - x, zb.z - z) < r) { zb.burnT = TUNE.burnTime; if (zb.hp === undefined) zb.hp = 1; }
|
||
}
|
||
}
|
||
|
||
// Bank `amount` of damage on a multi-hit body and return true once it should DIE. Fractional amounts
|
||
// are legal (a machine-gun pellet chips a third of a point): they accumulate on zb.chip and only
|
||
// WHOLE points come off hp, because the wound skins and bleed() anchors switch on hp thresholds and
|
||
// a fractional hp would never match one. The caller decides HOW it dies — splatter() for the
|
||
// multi-kill fanfare, killZombie() for a quiet one — and must stop touching zb afterwards, because
|
||
// killZombie splices the array. This is the one place damage is applied, so a future boss with 20 hp
|
||
// needs no new code: every weapon is already proportional to it.
|
||
function wound(zb, amount, fx = true) {
|
||
zb.chip = (zb.chip || 0) + amount;
|
||
let took = 0;
|
||
while (zb.chip >= 1 && zb.hp > 0) { zb.chip -= 1; zb.hp--; took++; }
|
||
if (took && fx) { splat(0.5); woundBurst(zb); }
|
||
return zb.hp <= 0;
|
||
}
|
||
|
||
// one burning body's frame: damage, spread, embers. Returns true if the fire killed it (the
|
||
// caller must then stop touching zb — killZombie splices, and splatPoint can cascade further).
|
||
function burnTick(zb, i, dt) {
|
||
zb.burnT -= dt;
|
||
ignite(zb.x, zb.z, TUNE.burnSpread);
|
||
// fx off: the embers below already ARE the feedback, a wet pop per cooked hp point would be noise
|
||
const dead = wound(zb, TUNE.burnDps * (zb.variant === 'r' ? TUNE.bossBurnMul : 1) * dt, false);
|
||
if (parts.length < 110) for (let k = 0; k < 2; k++) parts.push({ // embers off the body
|
||
x: zb.x + (Math.random() * 2 - 1) * 0.3, y: 0.5 + Math.random() * 1.4, z: zb.z,
|
||
vx: (Math.random() * 2 - 1) * 0.5, vy: 1.2 + Math.random(), vz: (Math.random() * 2 - 1) * 0.5,
|
||
t: 0.25 + Math.random() * 0.2, fire: true });
|
||
if (!dead) return false;
|
||
killZombie(i, !!G.horde);
|
||
return true;
|
||
}
|
||
|
||
// phase B of the death animation (EATEN_BURST, config.js): the player IS the gore now. Reuses killZombie's machinery —
|
||
// the biggest mound on the court, and it stays visible under the summary scrim. That's the point.
|
||
export function playerGore() {
|
||
const at = G.eatenAt || { x: P.x, z: P.z };
|
||
gore.push({ x: at.x, z: at.z, r: 1.7, a: 1 }); if (gore.length > 40) gore.shift();
|
||
piles.push({ x: at.x, z: at.z, size: 4, seed: Math.random() * 1e4, blobs: null, builtSize: 0 });
|
||
if (piles.length > 30) piles.shift();
|
||
for (let k = 0; k < 90; k++) parts.push({
|
||
x: at.x, y: 1.0, z: at.z,
|
||
vx: (Math.random() * 2 - 1) * 5.5, vy: 1 + Math.random() * 6, vz: (Math.random() * 2 - 1) * 5.5,
|
||
t: 0.6 + Math.random() * 0.9, dark: k % 3 === 0 });
|
||
splat(1); boom();
|
||
G.shake = { t: 0.35, mag: 7 };
|
||
G.boomFlash = 0.08;
|
||
}
|
||
|
||
// a small dark spatter the instant a multi-hit shambler is wounded — subtle impact pop, NOT the
|
||
// kill spray (the ongoing thin trickle is bleed()'s job). Kept low per the settled blood feel.
|
||
function woundBurst(zb) {
|
||
for (let k = 0; k < 5; k++) parts.push({
|
||
x: zb.x + (Math.random() * 2 - 1) * 0.15, y: 1.4, z: zb.z,
|
||
vx: (Math.random() * 2 - 1) * 1.6, vy: 0.6 + Math.random() * 1.4, vz: (Math.random() * 2 - 1) * 1.6,
|
||
t: 0.35 + Math.random() * 0.3, dark: Math.random() < 0.6 });
|
||
}
|
||
|
||
// swishing the racket cleaves every shambler in reach — it's the panic button for when they're
|
||
// already on top of you, so it stays a full sweep. TUNE.meleeCool is the brake that stops it
|
||
// from being the default attack.
|
||
// The boss skip is NOT a gap in the damage model: it is unreachable by construction. The player is
|
||
// bounded at P_BOUNDS.zMin (netZ + 1.2 = 13.1) and the boss holds z <= COURT.svcFar (5.5), so they
|
||
// are always on opposite sides of the net and meleeRange 1.7 can never span it. Left as a skip
|
||
// rather than "fixed", because a melee path to the boss would need him to cross the net first.
|
||
export function meleeSwipe(x, z, range) {
|
||
let hit = 0;
|
||
for (let i = zombies.length - 1; i >= 0; i--) {
|
||
const zb = zombies[i];
|
||
if (!zb || zb.variant === 'r') continue; // !zb: killZombie can sweep the court mid-loop
|
||
if (Math.hypot(zb.x - x, zb.z - z) < range) { killZombie(i, !!G.horde); hit++; }
|
||
}
|
||
if (hit) swish(0.35);
|
||
return hit;
|
||
}
|
||
|
||
function splatter(i, fanfare = true) { // the MAIN ball hit a zombie
|
||
killZombie(i, !!G.horde);
|
||
ball.vx *= TUNE.zPierce; ball.vz *= TUNE.zPierce; // keep enough pace to plow through the next
|
||
if (!fanfare) return; // machine-gun pellets splatter but skip the streak fanfare / bomb meter
|
||
ball.kills++; // this shot's running streak
|
||
// escalating multi-kill fanfare — one shot, ≥2 zombies
|
||
if (ball.kills === 2) { G.flash = { text: 'DOUBLE KILL', t: 0.9 }; cheer(1.6, 0.45); voice('double_kill', 0.4); }
|
||
else if (ball.kills === 3) { G.flash = { text: 'TRIPLE KILL', t: 0.9 }; cheer(2.2, 0.6); voice('triple_kill', 0.4); }
|
||
else if (ball.kills >= 4) { G.flash = { text: `MASSACRE ×${ball.kills}`, t: 0.9 }; cheer(2.8, 0.7); voice('unbelievable', 0.4); }
|
||
}
|
||
|
||
// ---- horde wave: dense spawns + an auto-firing machine-gun racket (pellets, not the match ball)
|
||
function spawnHordeZombie() { // all from the far baseline, across the court — never off-screen at the sides
|
||
spawnZombie((Math.random() * 2 - 1) * 5, -1.5 - Math.random(), Math.random() < 0.5 ? 'a' : 'b');
|
||
}
|
||
function firePellet() {
|
||
const a = (Math.random() * 2 - 1) * 4 * Math.PI / 180, s = 26; // ±4° spread, straight up-court (-z)
|
||
pellets.push({ x: P.x, y: 0.9, z: P.z, vx: Math.sin(a) * s, vz: -Math.cos(a) * s, t: 1.2 });
|
||
pock(0.25, 1400); // rapid fire tick; if it clips on device, gate to every 2nd pellet
|
||
}
|
||
export function spawnRacketZombie() { // one takes up residence on the far court — an opponent, of sorts
|
||
// He stiffens as the run goes on. hpMax is stored because the wound skins and bleed() anchors read
|
||
// a FRACTION of full health now — hardcoded `hp === 2` thresholds would leave a late-run boss
|
||
// looking pristine right up to the killing blow.
|
||
const hp = TUNE.racketHp + Math.floor(G.runGames * TUNE.racketHpPerGame);
|
||
zombies.push({ x: (Math.random() * 2 - 1) * 2.5, z: 3.5, v: 0, walkT: Math.random() * 9,
|
||
variant: 'r', side: 'O', facing: 1, pose: 'idle', poseT: 0, swingT: -1, swingCool: 0, runT: 0,
|
||
hp, hpMax: hp });
|
||
if (!G.seen.racket) { // it is not a shambler and it does not behave like one — say so, once
|
||
G.seen.racket = true;
|
||
showModal({ title: 'IT HAS A RACKET', color: UI.hot,
|
||
body: ['IT RETURNS YOUR WEAK SHOTS', 'ONLY A FULL PULL WOUNDS IT'] });
|
||
}
|
||
}
|
||
function endHorde() {
|
||
G.horde = null; pellets.length = 0;
|
||
if (!zombies.some(z => z.variant === 'r')) spawnRacketZombie(); // survive the wave → a racket zombie stays
|
||
setupPoint(); // serve loop resumes; any zombies still standing are yours to mop up
|
||
voice('quiet_dark', 0.5, 0.85);
|
||
}
|
||
function tickHorde(dt) {
|
||
const h = G.horde;
|
||
h.t -= dt;
|
||
// h.rate is stamped by startHorde and grows per set banked — every horde used to be the same
|
||
// twelve seconds at the same 2.5/s, so the fifth one was indistinguishable from the first.
|
||
if ((h.spawnT -= dt) <= 0) {
|
||
if (zombies.length < TUNE.zHordeCap) spawnHordeZombie(); // ...but bounded, see TUNE.zHordeCap
|
||
h.spawnT = 1 / (h.rate || TUNE.hordeRate);
|
||
}
|
||
if ((h.mgT -= dt) <= 0) { firePellet(); h.mgT = 1 / TUNE.mgRate; }
|
||
if (h.t <= 0) endHorde();
|
||
}
|
||
|
||
// bomb ball: everything inside bombRadius splatters at once (each kill still ++ball.kills so
|
||
// the Phase-2 fanfare escalates), plus a crater — big stain, size-3 pile, extra particles, boom.
|
||
export function explode(x, z) {
|
||
for (let i = zombies.length - 1; i >= 0; i--) { // backwards: splatter() splices (and can sweep) the array
|
||
const zb = zombies[i];
|
||
if (!zb || Math.hypot(zb.x - x, zb.z - z) >= TUNE.bombRadius) continue;
|
||
// A blast used to delete the boss outright, ignoring his hp entirely — which made BOMB the only
|
||
// real answer to him and would have made any bigger boss meaningless. It's heavy damage now.
|
||
if (zb.variant === 'r') { if (wound(zb, TUNE.dmgBomb)) splatter(i); }
|
||
else splatter(i);
|
||
}
|
||
gore.push({ x, z, r: 2.2, a: 1, scorch: true }); if (gore.length > 40) gore.shift(); // the crater — near-permanent
|
||
gore.push({ x, z, r: 2.0, a: 0.9 }); if (gore.length > 40) gore.shift();
|
||
// a ring of splatter thrown outward, so the blast paints the lawn instead of leaving one puddle
|
||
for (let k = 0; k < 6; k++) {
|
||
const a = Math.random() * 6.2832, r = TUNE.bombRadius * (0.35 + Math.random() * 0.6);
|
||
gore.push({ x: x + Math.cos(a) * r, z: z + Math.sin(a) * r, r: 0.7 + Math.random() * 0.7, a: 0.85 });
|
||
if (gore.length > 40) gore.shift();
|
||
}
|
||
const pl = piles.find(p => Math.hypot(p.x - x, p.z - z) < 0.6);
|
||
if (pl) pl.size = Math.min(4, pl.size + 3);
|
||
else { piles.push({ x, z, size: 4, seed: Math.random() * 1e4, blobs: null, builtSize: 0 }); if (piles.length > 30) piles.shift(); }
|
||
// the eruption itself: a fat, slow, high-arcing column of gore rather than a camera flash
|
||
for (let k = 0; k < 120; k++) parts.push({
|
||
x: x + (Math.random() * 2 - 1) * 0.4, y: 0.5, z: z + (Math.random() * 2 - 1) * 0.4,
|
||
vx: (Math.random() * 2 - 1) * 11, vy: 2 + Math.random() * 9, vz: (Math.random() * 2 - 1) * 11,
|
||
t: 0.7 + Math.random() * 1.1, dark: k % 3 === 0,
|
||
});
|
||
G.hitstop = 0.18; boom();
|
||
G.shake = { t: 0.45, mag: 9 }; // camera kick
|
||
// a warm, brief bloom instead of a white-out — the blinding frame was doing the work the gore
|
||
// should be doing, and on a phone it just hurt (see render.js for the colour)
|
||
G.boomFlash = 0.06;
|
||
if (G.idleT - G.lastOrderT > 3) { voice('order', 0.35); G.lastOrderT = G.idleT; } // the umpire loses composure
|
||
}
|
||
|
||
// wounded zombies bleed from every open wound — a fine, sparse trickle (a small spurt from the
|
||
// neck stump on the headless boss). Anchors are approximate body offsets [x, y, rise]; most
|
||
// frames a wound drips nothing, and the tight spread keeps each thread thin. Bounded low.
|
||
function bleed(zb) {
|
||
if (parts.length > 90) return;
|
||
let wounds;
|
||
if (zb.variant === 'g' && zb.hp < TUNE.bruteHp) {
|
||
// the brute opens up stage by stage: one arm, then both, then the head. Still sparse —
|
||
// more ANCHORS, not a heavier flow (the settled feel note: blood stays thin).
|
||
wounds = [[-0.3, 1.95, 1.1]];
|
||
if (zb.hp <= TUNE.bruteHp - 2) wounds.push([0.42, 1.9, 1.0]);
|
||
if (zb.hp <= TUNE.bruteHp - 3) wounds.push([0.05, 2.35, 2.0]);
|
||
if (zb.hp <= 1) wounds.push([0.0, 1.2, 0.7]);
|
||
}
|
||
// the boss reads as a FRACTION of full health, not against hardcoded hp numbers: his hp scales
|
||
// with the run now (racketHpPerGame), so `hp === 2` would leave a late-run boss bleeding from
|
||
// nothing until the very last hit. Must stay in step with drawZombie's skin thresholds.
|
||
else if (zb.variant === 'r' && zb.hp / (zb.hpMax || TUNE.racketHp) <= 0.34)
|
||
wounds = [[0.05, 1.5, 2.4], [0.4, 1.15, 0.9]]; // headless: neck spurt + torn arm
|
||
else if (zb.variant === 'r' && zb.hp / (zb.hpMax || TUNE.racketHp) <= 0.67)
|
||
wounds = [[0.4, 1.2, 1.0]]; // racket: torn-off arm
|
||
else if ((zb.variant === 'a' || zb.variant === 'b') && zb.hp < TUNE.shamblerHp) wounds = [[0.28, 1.35, 0.85]]; // shambler: gashed shoulder
|
||
else return;
|
||
for (const w of wounds) {
|
||
if (Math.random() > 0.4) continue; // sparse: most frames this wound emits nothing
|
||
parts.push({
|
||
x: zb.x + w[0] + (Math.random() * 2 - 1) * 0.03, y: w[1] + (Math.random() * 2 - 1) * 0.03, z: zb.z + (Math.random() * 2 - 1) * 0.03,
|
||
vx: (Math.random() * 2 - 1) * 0.3, vy: w[2] * (0.6 + Math.random() * 0.5), vz: (Math.random() * 2 - 1) * 0.28,
|
||
t: 0.3 + Math.random() * 0.3, dark: Math.random() < 0.55 });
|
||
}
|
||
}
|
||
|
||
export function updateZombies(dt) {
|
||
moanT -= dt;
|
||
if (moanT <= 0) { moan(); moanT = 2.5 + Math.random() * 4; }
|
||
|
||
if (G.mode === 'splatter') { // transition spawns are scripted, not timed
|
||
G.splatT += dt;
|
||
if (G.horde) tickHorde(dt); // horde: dense spawns + machine gun, ignores the cap
|
||
else if (G.mgT > 0) { // machine-gun tin: horde firepower, regular rules
|
||
// The burst clock ticks in EVERY phase. It used to tick only during 'rally', so anything that
|
||
// moved the phase mid-burst (a duel calling setupPoint) froze mgT above zero forever — and
|
||
// `G.mgT > 0` blocks serving, so the game locked up with the gun racket stuck on screen.
|
||
G.mgT -= dt;
|
||
if (G.phase === 'rally' && (G.mgCool -= dt) <= 0) { firePellet(); G.mgCool = 1 / TUNE.mgRate; }
|
||
if (G.mgT <= 0) setupPoint(); // ammo dry — the serve loop resumes
|
||
}
|
||
if (!G.horde && !G.changeover && !G.interlude && !G.clearing) { // breathers, duels AND the mop-up after a won game get a quiet court (no new spawns)
|
||
spawnT -= dt;
|
||
// The spawn director: games finished sets both crowd size and tempo. Both curves used to hit a
|
||
// wall — the cap pinned at 14 by game 11 and the gap floored at 1.0 s by game 10, after which
|
||
// the game literally stopped changing. The gap is hyperbolic now so it keeps tightening on its
|
||
// own instead of running into a floor; zSpawnMin is only a safety stop.
|
||
const cap = Math.min(TUNE.zMaxCap, TUNE.zMax + Math.floor(G.runGames * TUNE.zMaxPerGame));
|
||
if (spawnT <= 0 && zombies.length < cap) {
|
||
spawnZombie((Math.random() * 2 - 1) * 4.8, -1.5 - Math.random(), pickVariant());
|
||
spawnT = Math.max(TUNE.zSpawnMin, TUNE.zSpawnEvery / (1 + G.runGames * TUNE.zSpawnAccel));
|
||
}
|
||
}
|
||
}
|
||
|
||
// ponytail: crude swept collision — grow the contact window by half the distance the ball
|
||
// covers this frame. A full-draw smash moves ~0.7 m per frame (1.6 m on a 25 fps device, where
|
||
// main.js clamps dt), which is wider than a shambler, so a discrete point test tunnels straight
|
||
// through bodies. Upgrade to a real segment-vs-circle test if the fudge ever reads as a phantom
|
||
// hit; at these speeds and radii it doesn't.
|
||
const ballSweep = ball.active ? Math.hypot(ball.vx, ball.vz) * dt * 0.5 : 0;
|
||
|
||
// The flame ball lights everything it FLIES PAST, not just what it kills. Without this the
|
||
// fire never actually spread: full pierce meant the ball killed its whole lane outright, and
|
||
// the only bodies left to catch were the ones it had already removed.
|
||
if (ball.active && ball.flame && ball.y < 2.6) ignite(ball.x, ball.z, TUNE.burnBallR);
|
||
|
||
// The umpire called time. The changeover is a MANDATORY breather for the player — no serving, no
|
||
// walking — so it is one for the dead too, which is the joke: they wait, because it's still a
|
||
// tennis match. They stand where they are, still bleeding, still burning, still lit by anything
|
||
// in the air, but nothing advances and nothing can eat you. (The alternative — letting the player
|
||
// walk freely during the beat — was tried and vetoed: he never walks freely during play either.)
|
||
const held = !!G.changeover;
|
||
|
||
for (let i = zombies.length - 1; i >= 0; i--) {
|
||
const zb = zombies[i];
|
||
if (!zb) continue; // a bomb detonation splices several out mid-loop and can gut the array under us
|
||
zb.walkT += dt;
|
||
if (zb.burnT > 0 && burnTick(zb, i, dt)) continue; // the fire finished it — the array moved under us
|
||
if (!held) zb.z += zb.v * (zb.burnT > 0 ? TUNE.burnPanic : 1) * dt;
|
||
bleed(zb); // open wounds bleed every frame they're standing
|
||
|
||
if (zb.shieldT > 0) zb.shieldT -= dt; // staggered chair comes back up when this runs out
|
||
if (held || zb.variant === 'r') { /* the racket boss holds station — its AI owns its x */ }
|
||
else if (G.mode === 'splatter' && zb.z > COURT.netZ) { // on YOUR half they close in — each on its own lane, not a column
|
||
const tx = P.x + zb.homeOff;
|
||
zb.x += Math.sign(tx - zb.x) * Math.min(Math.abs(tx - zb.x), zb.v * 0.7 * dt)
|
||
+ Math.sin(zb.walkT * 2.3) * 0.25 * dt; // shamble wobble — the approach reads organic, not tracked
|
||
} else
|
||
zb.x += Math.sin(zb.walkT * 1.7) * 0.15 * dt; // far half: aimless shamble
|
||
if (!held && G.mode === 'splatter' && Math.hypot(zb.x - P.x, (zb.z - P.z) * 0.75) < TUNE.eatenR + (zb.variant === 'g' ? 0.2 : 0)) { // z weighted down: depth is foreshortened, so a head-on shambler eats you when it LOOKS on top of you
|
||
gore.push({ x: P.x, z: P.z, r: 0.9, a: 0.9 });
|
||
for (let k = 0; k < 30; k++) parts.push({
|
||
x: P.x, y: 1.1, z: P.z,
|
||
vx: (Math.random() * 2 - 1) * 4.5, vy: 1 + Math.random() * 4, vz: (Math.random() * 2 - 1) * 4.5,
|
||
t: 0.5 + Math.random() * 0.5,
|
||
});
|
||
splat(1);
|
||
voice('game_set_massacre', 0.8); aww(1); // the run is over — the crowd groans
|
||
// the death animation runs off G.eatenT: thrash here, burst at EATEN_BURST (playerGore), summary after
|
||
G.eatenT = 0; G.eatenAt = { x: P.x, z: P.z };
|
||
G.mode = 'eaten'; ball.active = false; G.flash = null; G.modal = null; // zombies keep shambling for ambience
|
||
G.horde = null; pellets.length = 0; extras.length = 0; G.mgT = 0; // everything stops; the eaten screen takes over
|
||
try { // the run is over — settle it against the best (games survived, sets as tiebreak)
|
||
const b = JSON.parse(localStorage.splatterBest || 'null') || { games: 0, sets: 0 };
|
||
G.newBest = G.runGames > b.games; // beat it → the summary crows about it
|
||
if (G.newBest) { b.games = G.runGames; b.sets = G.sets[0]; localStorage.splatterBest = JSON.stringify(b); }
|
||
G.best = b;
|
||
} catch (e) { G.best = null; } // private mode etc. — the summary just skips the best line
|
||
}
|
||
if (ball.active && ball.lastHit === 'P' && ball.y < 1.9) {
|
||
const d = Math.hypot(ball.x - zb.x, ball.z - zb.z);
|
||
if (d < hitR(zb) + ballSweep) { // brute and boss are bigger targets
|
||
if (ball.bomb) { // detonate on first contact, whatever the pace
|
||
explode(ball.x, ball.z); ball.bomb = false;
|
||
spentBall(); break; // zombies mutated — stop this frame's loop
|
||
}
|
||
if (ball.flame) { // burns through anything it touches — no quality gate, no chair, no pace tax
|
||
if (zb.variant === 'r') { // the boss takes a heavy wound AND catches light
|
||
if (wound(zb, TUNE.dmgFlame)) splatter(i);
|
||
else zb.burnT = TUNE.burnTime;
|
||
continue;
|
||
}
|
||
const vx0 = ball.vx, vz0 = ball.vz, bx = zb.x, bz = zb.z;
|
||
splatter(i); ball.vx = vx0; ball.vz = vz0; // undo splatter's pierce tax: full pace through the lane
|
||
ignite(bx, bz, TUNE.burnIgniteR); // ...and everyone standing near the body goes up
|
||
continue;
|
||
}
|
||
if (zb.variant === 'r') { // mini-boss: splat-quality wounds it; soft balls it rallies (racketAI)
|
||
if ((ball.pow || 0) >= TUNE.zSplatQ) {
|
||
const dead = wound(zb, TUNE.dmgBall);
|
||
pock(0.6, 300);
|
||
ball.vx *= 0.3; ball.vz *= 0.3; ball.lastHit = 'X'; // spent on the hit
|
||
if (dead) { splatter(i); continue; } // killing blow: full gore + point
|
||
}
|
||
continue; // soft balls pass through ON PURPOSE, for racketAI to return — that rally IS the
|
||
// feedback that it wasn't hard enough, so no clank here; see HANDOFF
|
||
}
|
||
if (zb.variant === 'g') { // brute: soaks splat-quality hits, never staggers back
|
||
if ((ball.pow || 0) >= TUNE.zSplatQ) {
|
||
zb.hp--; splat(0.5); pock(0.6, 220);
|
||
ball.vx *= 0.3; ball.vz *= 0.3; ball.lastHit = 'X';
|
||
if (zb.hp <= 0) { splatter(i); continue; } // timber
|
||
} else { pock(0.6, 300); ball.vx *= 0.6; ball.vz *= 0.6; ball.lastHit = 'X'; } // soft ball bounces off
|
||
continue;
|
||
}
|
||
if (zb.variant === 's' && ball.vz < 0 && !(zb.shieldT > 0)) { // chair up, ball at its face: BLOCKED
|
||
zb.shieldT = TUNE.shieldDown; // ...but the block staggers it — the chair drops, kill window opens
|
||
zb.z -= TUNE.zPushback * 0.5;
|
||
pock(0.9, 1800); // wooden clank
|
||
ball.vx *= 0.4; ball.vz *= -0.2; ball.lastHit = 'X'; // ball caroms off the chair, spent
|
||
continue;
|
||
}
|
||
if (zb.variant === 'f') { splatter(i); continue; } // the sprinter is GLASS — any touch, any quality, it bursts
|
||
if (zb.variant === 'a' || zb.variant === 'b') { // classic shamblers soak a splat-quality wound before they drop
|
||
if ((ball.pow || 0) >= TUNE.zSplatQ) {
|
||
if (--zb.hp <= 0) { splatter(i); continue; } // the second splat is the killing blow
|
||
woundBurst(zb); splat(0.5); pock(0.6, 280); // first splat: a bloody wound, not a death
|
||
zb.z -= TUNE.zPushback * 0.5; ball.vx *= 0.3; ball.vz *= 0.3; ball.lastHit = 'X'; continue; // ball spent on the wound
|
||
}
|
||
zb.z -= TUNE.zPushback; pock(0.6, 300); ball.vx *= 0.6; ball.vz *= 0.6; ball.lastHit = 'X'; continue; // soft ball just staggers
|
||
}
|
||
// chair-down shield zombies (and anything hit from behind) obey the normal rules:
|
||
if ((ball.pow || 0) >= TUNE.zSplatQ) { splatter(i); continue; }
|
||
zb.z -= TUNE.zPushback; // weak sitters only stagger them
|
||
pock(0.6, 300);
|
||
ball.vx *= 0.6; ball.vz *= 0.6; ball.lastHit = 'X'; // spent — one stagger per ball
|
||
}
|
||
}
|
||
if (zb.z >= COURT.L + 0.7) { zombies.splice(i, 1); if (G.mode !== 'eaten' && !G.horde && !G.clearing) splatPoint('O'); } // it reached your baseline (during a mop-up, a straggler that reaches the line just despawns — no point for them)
|
||
}
|
||
|
||
for (let i = pellets.length - 1; i >= 0; i--) { // machine-gun rounds: flat, fast, one-shot kills
|
||
const pe = pellets[i];
|
||
pe.t -= dt; pe.x += pe.vx * dt; pe.z += pe.vz * dt;
|
||
let hit = false;
|
||
for (let j = zombies.length - 1; j >= 0; j--) {
|
||
const zb = zombies[j];
|
||
if (!zb) continue;
|
||
if (Math.hypot(zb.x - pe.x, zb.z - pe.z) < hitR(zb)) {
|
||
// Pellets used to skip the boss entirely, so a GUN burst (and every horde) did literally
|
||
// nothing to him with no feedback at all. They CHIP him now: dmgPellet is fractional, so
|
||
// three rounds take a point off and the gun is a slow, committed answer rather than a no-op.
|
||
if (zb.variant === 'r') { if (wound(zb, TUNE.dmgPellet, false)) killZombie(j, true); else pock(0.45, 240); }
|
||
else if (zb.hp > 1) { zb.hp--; pock(0.5, 260); } // brutes AND shamblers soak pellets — wound, don't kill
|
||
else killZombie(j, true);
|
||
hit = true; break;
|
||
}
|
||
}
|
||
if (hit || pe.t <= 0) pellets.splice(i, 1);
|
||
}
|
||
|
||
for (let i = extras.length - 1; i >= 0; i--) { // triple-serve side balls: full ballistic clones
|
||
const e = extras[i];
|
||
e.t -= dt; e.vy -= (e.g || TUNE.gravity) * dt; // e.g: a clone flies under the SAME topspin as the ball it came from
|
||
e.x += e.vx * dt; e.y += e.vy * dt; e.z += e.vz * dt;
|
||
if (e.y <= 0 && e.vy < 0) { e.y = 0; e.vy = -e.vy * TUNE.bounceY; e.vx *= TUNE.bounceXZ; e.vz *= TUNE.bounceXZ; }
|
||
let dead = e.t <= 0 || Math.abs(e.x) > 7.5 || e.z < -2 || e.z > 25.5;
|
||
if (!dead && e.y < 1.9) for (let j = zombies.length - 1; j >= 0; j--) {
|
||
const zb = zombies[j];
|
||
if (!zb) continue; // killZombie can sweep the court mid-loop
|
||
if (Math.hypot(zb.x - e.x, zb.z - e.z) < hitR(zb)
|
||
+ Math.hypot(e.vx, e.vz) * dt * 0.5) { // same sweep: clones inherit the smash pace
|
||
// Side balls used to pass THROUGH the boss doing nothing at all, which is most of why a
|
||
// TRIPLE serve read as "he can't be hurt". They wound him like the main ball now.
|
||
if (zb.variant === 'r') {
|
||
if (e.pow >= TUNE.zSplatQ) { if (wound(zb, TUNE.dmgSide)) killZombie(j, !!G.horde); }
|
||
else pock(0.5, 300);
|
||
}
|
||
else if (zb.variant === 's' && e.vz < 0 && !(zb.shieldT > 0)) { zb.shieldT = TUNE.shieldDown; pock(0.9, 1800); } // chair blocks these too
|
||
else if (e.pow >= TUNE.zSplatQ || zb.variant === 'f') {
|
||
if (zb.hp > 1) { zb.hp--; splat(0.4); } // wounds brutes AND shamblers
|
||
else killZombie(j, !!G.horde);
|
||
} else { zb.z -= TUNE.zPushback; pock(0.5, 300); }
|
||
dead = true; break; // a side ball is spent on its first touch
|
||
}
|
||
}
|
||
if (dead) extras.splice(i, 1);
|
||
}
|
||
|
||
for (let i = parts.length - 1; i >= 0; i--) {
|
||
const p = parts[i];
|
||
p.t -= dt; p.vy -= 14 * dt;
|
||
p.x += p.vx * dt; p.y += p.vy * dt; p.z += p.vz * dt;
|
||
if (p.y < 0) { p.y = 0; p.vy = 0; p.vx *= 0.5; p.vz *= 0.5; }
|
||
if (p.t <= 0) parts.splice(i, 1);
|
||
}
|
||
|
||
const boy = G.boy; // the boy mops any gore he passes over
|
||
for (let i = gore.length - 1; i >= 0; i--) {
|
||
const d = gore[i];
|
||
// He scrubs HARD only while stopped and working the mop; walking past barely touches it, so
|
||
// the stain visibly dies under him rather than fading as he drifts by.
|
||
if (boy && Math.abs(boy.x - d.x) < 0.8 && Math.abs(boy.z - d.z) < 1.3)
|
||
d.a -= dt * (d.scorch ? 0.16 : boy.mopT > 0 ? 0.7 : 0.2); // craters scar the lawn far longer
|
||
if (d.a <= 0) gore.splice(i, 1);
|
||
}
|
||
for (let i = piles.length - 1; i >= 0; i--) { // piles shave far slower than stains — net growth wins
|
||
const pl = piles[i];
|
||
if (boy && Math.abs(boy.x - pl.x) < 0.7 && Math.abs(boy.z - pl.z) < 1.2) pl.size -= dt * 0.25;
|
||
if (pl.size <= 0.3) piles.splice(i, 1);
|
||
}
|
||
}
|