towerdef/public/js/render.js
Claude 2098d59c1f Versus mode: attack vs defend (sim, bots, server, client)
One player defends, the other plays the Internet: earns credits over time and
spends them on packets, upgrades and sabotage. Two rounds with swapped roles,
timed (the faster fall wins). Built end to end, NOT yet QA'd or balanced.

Sim (public/js/sim.js, TD.VS table): attacker economy (income, lifetime bonus,
leak payback), spawn / stage / launch convoys, 7 tech tracks, abilities (EMP,
decoy, surge, DDoS), defender tools (scan, patch, repair, quarantine), role-checked
commands, round result, role-private state. Co-op/solo unchanged (24 scripted
games replay identically).

Bots (public/js/bot.js, tools/versus.js): defender (maze + turrets) and attacker
(budgeted spender reading the tower mix); headless bot-vs-bot runner.

Server (server/versus.js, protocol doc): versus rooms with lobby / countdown /
playing / roundover / matchover, role stamping, cross-role refusal, role-private
priv messages at 4 Hz, computer seat, freeze/forfeit rules, no pause/speed.

Client (public/js/versus.js): setup dialog (role, length, vs computer or online),
countdown, defender tools row, attacker unit shop with convoy + launch, tech and
abilities, gateway choice, round/match screens, sounds, phone-first dock rows.

Status and next steps (balance: the attacker currently wins ~100% of bot rounds;
QA with two browsers; layout matrix rerun) are in docs/NEXT.md and docs/VERSUS.md.
The full planned workflow incl. balance/QA prompts is in docs/workflows/versus-full.js.

253 unit tests pass; one smoke e2e run; no other e2e per the user's request.

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

1005 lines
58 KiB
JavaScript

/*
* NETWALL renderer: canvas 2D, world units = 40 px per cell, camera (zoom + pan) maps world -> CSS px.
* No shadowBlur / per-frame gradients so it stays smooth on phones.
*/
(function (root) {
'use strict';
const NW = root.NW = root.NW || {};
const TD = root.TD;
const C = 40; // world px per cell
const TAU = Math.PI * 2;
const SLOT_COLORS = ['#4de3ff', '#ffd24d'];
const BG = '#050810', BOARD = '#09101f';
const MARGIN = 10; // world px kept free on every side of the board so the gateway / server rings are never cut off
const clamp = (v, a, b) => Math.min(b, Math.max(a, v));
const lerpAngle = (a, b, k) => { let d = ((b - a + Math.PI * 3) % TAU) - Math.PI; return a + d * k; };
function rr(ctx, x, y, w, h, r) {
ctx.beginPath();
ctx.moveTo(x + r, y);
ctx.arcTo(x + w, y, x + w, y + h, r);
ctx.arcTo(x + w, y + h, x, y + h, r);
ctx.arcTo(x, y + h, x, y, r);
ctx.arcTo(x, y, x + w, y, r);
ctx.closePath();
}
function poly(ctx, n, r, rot) {
ctx.beginPath();
for (let i = 0; i < n; i++) {
const a = rot + (i / n) * TAU;
i ? ctx.lineTo(Math.cos(a) * r, Math.sin(a) * r) : ctx.moveTo(Math.cos(a) * r, Math.sin(a) * r);
}
ctx.closePath();
}
function rgba(hex, a) {
const n = parseInt(hex.slice(1), 16);
return 'rgba(' + (n >> 16) + ',' + ((n >> 8) & 255) + ',' + (n & 255) + ',' + a + ')';
}
// ------------------------------------------------------------------ tower glyphs (also used for UI icons)
// S = tile size, (cx,cy) = centre, ang = barrel angle (radians), t = seconds (animation), fx = 0..1 flash right after a Sandbox pulse
function drawGlyph(ctx, type, level, cx, cy, S, ang, t, alpha, rot, fx) {
const def = TD.TOWERS[type]; if (!def) return;
const col = def.color;
ctx.save();
ctx.globalAlpha *= alpha === undefined ? 1 : alpha;
ctx.translate(cx, cy);
if (rot) { ctx.rotate(-rot); ang = (ang || 0) + rot; } // board is drawn rotated: keep glyphs upright
const h = S * 0.43;
if (type === 'wall') {
ctx.fillStyle = '#10305f'; rr(ctx, -h * 0.92, -h * 0.92, h * 1.84, h * 1.84, S * 0.09); ctx.fill();
ctx.lineWidth = S * 0.05; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = 'rgba(90,169,255,.28)';
ctx.fillRect(-h * 0.55, -h * 0.55, h * 1.1, h * 0.5);
ctx.fillRect(-h * 0.55, h * 0.05, h * 0.5, h * 0.5);
ctx.fillRect(h * 0.05, h * 0.05, h * 0.5, h * 0.5);
ctx.restore(); return;
}
ctx.fillStyle = '#0c1426'; rr(ctx, -h, -h, h * 2, h * 2, S * 0.12); ctx.fill();
if (level >= 2) { ctx.fillStyle = rgba(col, level >= 3 ? 0.3 : 0.16); ctx.fill(); } // upgraded towers are tinted (level 3 clearly)
ctx.lineWidth = S * (level >= 3 ? 0.075 : 0.05); ctx.strokeStyle = col; ctx.stroke();
ctx.lineCap = 'round'; ctx.lineJoin = 'round';
switch (type) {
case 'filter':
ctx.fillStyle = rgba(col, 0.22); ctx.beginPath(); ctx.arc(0, 0, S * 0.2, 0, TAU); ctx.fill();
ctx.lineWidth = S * 0.04; ctx.stroke();
ctx.save(); ctx.rotate(ang); ctx.fillStyle = col; ctx.fillRect(0, -S * 0.05, S * 0.34, S * 0.1); ctx.restore();
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, 0, S * 0.07, 0, TAU); ctx.fill();
break;
case 'ids':
ctx.lineWidth = S * 0.035;
ctx.beginPath(); ctx.arc(0, 0, S * 0.19, 0, TAU); ctx.stroke();
ctx.save(); ctx.rotate(ang);
ctx.fillStyle = col; ctx.fillRect(0, -S * 0.03, S * 0.46, S * 0.06);
ctx.fillRect(S * 0.36, -S * 0.07, S * 0.05, S * 0.14);
ctx.restore();
ctx.beginPath(); ctx.moveTo(-S * 0.26, 0); ctx.lineTo(-S * 0.12, 0); ctx.moveTo(0, -S * 0.26); ctx.lineTo(0, -S * 0.12); ctx.moveTo(0, S * 0.26); ctx.lineTo(0, S * 0.12); ctx.stroke();
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, 0, S * 0.05, 0, TAU); ctx.fill();
break;
case 'mortar':
ctx.fillStyle = rgba(col, 0.25); ctx.beginPath(); ctx.arc(0, 0, S * 0.22, 0, TAU); ctx.fill();
ctx.lineWidth = S * 0.04; ctx.stroke();
ctx.save(); ctx.rotate(ang); ctx.fillStyle = col; rr(ctx, -S * 0.02, -S * 0.1, S * 0.3, S * 0.2, S * 0.04); ctx.fill(); ctx.restore();
ctx.fillStyle = '#0c1426'; ctx.beginPath(); ctx.arc(0, 0, S * 0.08, 0, TAU); ctx.fill();
break;
case 'throttle': {
const pulse = ((t * 0.9) % 1);
ctx.lineWidth = S * 0.04;
for (let i = 0; i < 3; i++) {
const r = S * (0.08 + 0.085 * i) + (i === 2 ? pulse * S * 0.05 : 0);
ctx.strokeStyle = rgba(col, 1 - i * 0.28 - (i === 2 ? pulse * 0.3 : 0));
ctx.beginPath(); ctx.arc(0, 0, r, -2.3, -0.84); ctx.stroke();
ctx.beginPath(); ctx.arc(0, 0, r, 0.84, 2.3); ctx.stroke();
}
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, 0, S * 0.05, 0, TAU); ctx.fill();
ctx.strokeStyle = col;
break;
}
case 'arc':
ctx.fillStyle = col;
ctx.beginPath();
ctx.moveTo(-S * 0.03, -S * 0.26); ctx.lineTo(-S * 0.14, S * 0.02); ctx.lineTo(-S * 0.01, S * 0.02);
ctx.lineTo(-S * 0.07, S * 0.27); ctx.lineTo(S * 0.15, -S * 0.07); ctx.lineTo(S * 0.02, -S * 0.07); ctx.lineTo(S * 0.11, -S * 0.26);
ctx.closePath(); ctx.fill();
break;
case 'uplink': {
// satellite dish with a feed horn and two pulsing signal arcs
const pulse = (t * 0.8) % 1;
ctx.lineWidth = S * 0.07; ctx.strokeStyle = col;
ctx.beginPath(); ctx.arc(0, S * 0.07, S * 0.23, Math.PI * 0.12, Math.PI * 0.88); ctx.stroke();
ctx.lineWidth = S * 0.045;
ctx.beginPath(); ctx.moveTo(0, S * 0.07); ctx.lineTo(0, -S * 0.15); ctx.stroke();
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, -S * 0.17, S * 0.05, 0, TAU); ctx.fill();
for (let i = 0; i < 2; i++) {
const k = (pulse + i * 0.5) % 1;
ctx.strokeStyle = rgba(col, 1 - k); ctx.lineWidth = S * 0.035;
ctx.beginPath(); ctx.arc(0, -S * 0.17, S * (0.1 + 0.2 * k), -Math.PI * 0.85, -Math.PI * 0.15); ctx.stroke();
}
break;
}
case 'sandbox': {
// containment cell: four corner brackets round a core that hums, held by thin tethers; it flashes when it pulses
const g = fx || 0, p = 0.5 + 0.5 * Math.sin(t * 3), a = S * 0.22, k = S * 0.11;
ctx.save(); ctx.translate(0, -S * 0.04);
ctx.strokeStyle = rgba(col, 0.45); ctx.lineWidth = S * 0.03;
ctx.beginPath();
for (const [sx, sy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) { ctx.moveTo(sx * S * 0.09, sy * S * 0.09); ctx.lineTo(sx * (a - k * 0.35), sy * (a - k * 0.35)); }
ctx.stroke();
ctx.strokeStyle = col; ctx.lineWidth = S * 0.06;
ctx.beginPath();
for (const [sx, sy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) { ctx.moveTo(sx * a, sy * (a - k)); ctx.lineTo(sx * a, sy * a); ctx.lineTo(sx * (a - k), sy * a); }
ctx.stroke();
const c = S * (0.095 + 0.015 * p + 0.05 * g);
ctx.beginPath(); ctx.moveTo(0, -c); ctx.lineTo(c, 0); ctx.lineTo(0, c); ctx.lineTo(-c, 0); ctx.closePath();
ctx.fillStyle = g > 0 ? '#fff3dd' : rgba(col, 0.55 + 0.3 * p); ctx.fill();
ctx.lineWidth = S * 0.035; ctx.stroke();
ctx.restore();
break;
}
case 'balancer': {
// scales: post, a gently rocking beam and two hanging pans
const dy = S * 0.27 * Math.sin(Math.sin(t * 1.4) * 0.07), ex = S * 0.27, top = -S * 0.21;
ctx.save(); ctx.translate(0, -S * 0.02);
ctx.lineWidth = S * 0.05; ctx.strokeStyle = col;
ctx.beginPath(); ctx.moveTo(0, top); ctx.lineTo(0, S * 0.14); ctx.moveTo(-S * 0.12, S * 0.15); ctx.lineTo(S * 0.12, S * 0.15); ctx.stroke();
ctx.beginPath(); ctx.moveTo(-ex, top - dy); ctx.lineTo(ex, top + dy); ctx.stroke();
for (const sx of [-1, 1]) {
const px = sx * ex, py = top + sx * dy, w = S * 0.1, d = S * 0.14;
ctx.lineWidth = S * 0.03;
ctx.beginPath(); ctx.moveTo(px - w, py + d); ctx.lineTo(px, py); ctx.lineTo(px + w, py + d); ctx.stroke();
ctx.fillStyle = rgba(col, 0.55); ctx.beginPath(); ctx.arc(px, py + d, w, 0, Math.PI); ctx.closePath(); ctx.fill();
ctx.lineWidth = S * 0.04; ctx.beginPath(); ctx.arc(px, py + d, w, 0, Math.PI); ctx.stroke();
}
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, top, S * 0.05, 0, TAU); ctx.fill();
ctx.restore();
break;
}
default: break;
}
// level pips: big enough to read at 14 px cells, with a dark halo so they show on any tile colour
for (let i = 0; i < level; i++) {
const px = (i - (level - 1) / 2) * S * 0.25, py = h - S * 0.11;
ctx.fillStyle = '#04101a'; ctx.beginPath(); ctx.arc(px, py, S * 0.125, 0, TAU); ctx.fill();
ctx.fillStyle = '#ffffff'; ctx.beginPath(); ctx.arc(px, py, S * 0.085, 0, TAU); ctx.fill();
}
ctx.restore();
}
// ------------------------------------------------------------------ monsters
// Hit points and shield of one enemy, from either kind of view object. Solo hands the sim's monsters over (hp and shield apart:
// m.shield / m.maxShield); co-op gets hp + shield out of maxhp + maxShield from the wire, and the split follows the kind's table
// (the shield soaks first, so what is above the hit point part of the total is shield). Result is a shared scratch object.
const VIT = { hp: 0, mh: 1, sh: 0, ms: 0 };
function vitals(m, def) {
if (!def.shield) { VIT.hp = m.hp; VIT.mh = m.maxhp; VIT.sh = 0; VIT.ms = 0; }
else if (m.maxShield !== undefined) { VIT.hp = m.hp; VIT.mh = m.maxhp; VIT.sh = m.shield; VIT.ms = m.maxShield; }
else {
const mh = m.maxhp * def.hp / (def.hp + def.shield);
VIT.mh = mh; VIT.ms = m.maxhp - mh; VIT.hp = Math.min(m.hp, mh); VIT.sh = Math.max(0, m.hp - mh);
}
return VIT;
}
const SWARM = { botnet: 1 }; // swarm units die in a hit or two: no bar, no ground shadow, few particles (there can be 100+)
// stun: true while the enemy is frozen by a Sandbox (the caller knows: the sim's stunT in solo, "slow flag and not moving" in co-op)
function drawMonster(ctx, m, ang, t, flash, rot, stun) {
const def = TD.ENEMIES[m.kind], r = def.r * C, col = def.color;
const v = vitals(m, def), sf = v.ms > 0 ? clamp(v.sh / v.ms, 0, 1) : 0;
const lift = m.kind === 'ghost' ? -7 : 0;
ctx.save();
ctx.translate(m.x * C, m.y * C);
if (rot) { ctx.rotate(-rot); ang += rot; }
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
switch (m.kind) {
case 'ping':
ctx.fillStyle = '#2a0b16'; ctx.beginPath(); ctx.arc(0, 0, r, 0, TAU); ctx.fill();
ctx.lineWidth = 2.4; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(Math.cos(ang) * r * 0.35, Math.sin(ang) * r * 0.35, r * 0.38, 0, TAU); ctx.fill();
break;
case 'worm': {
ctx.fillStyle = col;
for (let i = 2; i >= 0; i--) {
const k = i * r * 1.05, w = Math.sin(t * 11 + m.id + i * 1.3) * r * 0.35;
const px = -Math.cos(ang) * k - Math.sin(ang) * w, py = -Math.sin(ang) * k + Math.cos(ang) * w;
ctx.globalAlpha = 1 - i * 0.22;
ctx.beginPath(); ctx.arc(px, py, r * (1 - i * 0.18), 0, TAU); ctx.fill();
}
ctx.globalAlpha = 1;
ctx.fillStyle = '#2a1204'; ctx.beginPath(); ctx.arc(Math.cos(ang) * r * 0.3, Math.sin(ang) * r * 0.3, r * 0.28, 0, TAU); ctx.fill();
break;
}
case 'trojan':
poly(ctx, 6, r, ang); ctx.fillStyle = '#2a0e1a'; ctx.fill();
ctx.lineWidth = 3; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = col; rr(ctx, -r * 0.32, -r * 0.1, r * 0.64, r * 0.5, 2); ctx.fill();
ctx.lineWidth = 2.2; ctx.strokeStyle = col; ctx.beginPath(); ctx.arc(0, -r * 0.1, r * 0.22, Math.PI, 0); ctx.stroke();
break;
case 'spam':
ctx.save(); ctx.rotate(ang);
ctx.beginPath(); ctx.moveTo(r * 1.25, 0); ctx.lineTo(-r, r * 0.9); ctx.lineTo(-r, -r * 0.9); ctx.closePath();
ctx.fillStyle = col; ctx.fill(); ctx.restore();
break;
case 'ghost': {
const bob = Math.sin(t * 5 + m.id) * 2;
ctx.translate(0, -7 + bob);
ctx.globalAlpha = 0.72 + Math.sin(t * 9 + m.id) * 0.18;
poly(ctx, 4, r * 1.25, Math.PI / 4); ctx.fillStyle = rgba(col, 0.28); ctx.fill();
ctx.lineWidth = 2.2; ctx.strokeStyle = col; ctx.stroke();
ctx.beginPath(); ctx.arc(0, 0, r * 0.42, 0, TAU); ctx.fillStyle = col; ctx.fill();
ctx.globalAlpha = 1;
break;
}
case 'rootkit': {
ctx.save(); ctx.rotate(t * 0.6);
ctx.fillStyle = col;
for (let i = 0; i < 8; i++) {
ctx.rotate(TAU / 8);
ctx.beginPath(); ctx.moveTo(r * 0.8, -r * 0.18); ctx.lineTo(r * 1.28, 0); ctx.lineTo(r * 0.8, r * 0.18); ctx.closePath(); ctx.fill();
}
ctx.restore();
poly(ctx, 8, r, 0.39); ctx.fillStyle = '#240609'; ctx.fill();
ctx.lineWidth = 3.2; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = rgba('#ff3b3b', 0.55 + Math.sin(t * 4) * 0.3); ctx.beginPath(); ctx.arc(0, 0, r * 0.45, 0, TAU); ctx.fill();
break;
}
case 'daemon': {
// healer: an upright plus (a medic cross), its core breathing in time with the heal pulse
const a = r * 1.3, w = r * 0.38, br = 0.5 + 0.5 * Math.sin(t * 5 + m.id);
ctx.beginPath();
ctx.moveTo(-w, -a); ctx.lineTo(w, -a); ctx.lineTo(w, -w); ctx.lineTo(a, -w); ctx.lineTo(a, w); ctx.lineTo(w, w);
ctx.lineTo(w, a); ctx.lineTo(-w, a); ctx.lineTo(-w, w); ctx.lineTo(-a, w); ctx.lineTo(-a, -w); ctx.lineTo(-w, -w); ctx.closePath();
ctx.fillStyle = '#0d2b17'; ctx.fill(); ctx.lineWidth = 2.8; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = rgba('#d6ffe0', 0.5 + 0.4 * br);
ctx.fillRect(-w * 0.45, -a * 0.62, w * 0.9, a * 1.24); ctx.fillRect(-a * 0.62, -w * 0.45, a * 1.24, w * 0.9);
break;
}
case 'proxy': {
// shielded relay: a heater-shield badge (never a hexagon: the Trojan is one) inside a bubble that thins as the shield goes
if (sf > 0.01) {
ctx.fillStyle = rgba('#7ab8ff', 0.07 + 0.2 * sf); ctx.beginPath(); ctx.arc(0, 0, r * 1.55, 0, TAU); ctx.fill();
ctx.lineWidth = 0.9 + 2.3 * sf; ctx.strokeStyle = rgba('#b9dcff', 0.3 + 0.65 * sf); ctx.stroke();
}
ctx.beginPath();
ctx.moveTo(-r * 0.92, -r * 0.8); ctx.lineTo(r * 0.92, -r * 0.8); ctx.lineTo(r * 0.92, r * 0.12); ctx.lineTo(0, r * 1.05); ctx.lineTo(-r * 0.92, r * 0.12); ctx.closePath();
ctx.fillStyle = '#0d1a3a'; ctx.fill(); ctx.lineWidth = 2.8; ctx.strokeStyle = col; ctx.stroke();
ctx.fillStyle = rgba(col, 0.9); ctx.beginPath(); ctx.arc(0, -r * 0.12, r * 0.3, 0, TAU); ctx.fill();
ctx.lineWidth = 2; ctx.beginPath(); ctx.moveTo(0, r * 0.2); ctx.lineTo(0, r * 0.72); ctx.stroke();
break;
}
case 'botnet': {
// a drone of a swarm: spinning X of two struts with a rotor at each tip, wobbling about its path
const a = Math.max(r * 1.7, 8), wb = 2.5;
ctx.translate(Math.sin(t * 6 + m.id * 1.9) * wb, Math.cos(t * 5 + m.id * 2.3) * wb);
ctx.rotate(t * 7 + m.id);
ctx.lineWidth = 3; ctx.strokeStyle = col;
ctx.beginPath(); ctx.moveTo(-a, -a); ctx.lineTo(a, a); ctx.moveTo(a, -a); ctx.lineTo(-a, a); ctx.stroke();
ctx.fillStyle = '#a6f2ea';
ctx.beginPath();
for (const [sx, sy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) { ctx.moveTo(sx * a + 2.6, sy * a); ctx.arc(sx * a, sy * a, 2.6, 0, TAU); }
ctx.fill();
ctx.fillStyle = '#e8fffd'; ctx.beginPath(); ctx.arc(0, 0, r * 0.6, 0, TAU); ctx.fill();
break;
}
default:
ctx.fillStyle = col; ctx.beginPath(); ctx.arc(0, 0, r, 0, TAU); ctx.fill();
}
if (flash > 0) { ctx.globalAlpha = Math.min(0.85, flash * 9); ctx.fillStyle = '#fff'; ctx.beginPath(); ctx.arc(0, lift, r * 1.05, 0, TAU); ctx.fill(); ctx.globalAlpha = 1; }
if (stun) {
// frozen by a Sandbox: an ice shell with crackling crystal spikes (the cyan ring below is only a slow)
const swarm = SWARM[m.kind], s = swarm ? 7 : Math.max(r * 1.3, 7) + 2;
ctx.fillStyle = 'rgba(200,240,255,.24)'; ctx.beginPath(); ctx.arc(0, lift, s, 0, TAU); ctx.fill();
ctx.lineWidth = swarm ? 1.4 : 2; ctx.strokeStyle = '#eefbff'; ctx.stroke();
if (!swarm) {
ctx.lineWidth = 2.2; ctx.beginPath();
for (let i = 0; i < 6; i++) {
const a = i * TAU / 6 + 0.5, len = s + (Math.sin(t * 31 + i * 2.1 + m.id) > 0 ? 6 : 3.5);
ctx.moveTo(Math.cos(a) * s, lift + Math.sin(a) * s); ctx.lineTo(Math.cos(a) * len, lift + Math.sin(a) * len);
}
ctx.stroke();
}
} else if (m.slow > 0) { ctx.lineWidth = 1.6; ctx.strokeStyle = 'rgba(77,227,255,.85)'; ctx.beginPath(); ctx.arc(0, lift, r + 3.5, 0, TAU); ctx.stroke(); }
ctx.restore();
// health bar (a blue shield strip above it for shielded kinds)
if (!SWARM[m.kind] && (v.hp < v.mh || v.sh < v.ms)) {
const w = Math.max(15, r * 2.3), y = -r * (sf > 0.01 ? 1.55 : 1) - (m.kind === 'ghost' ? 16 : 9), x = -w / 2;
const f = clamp(v.hp / v.mh, 0, 1);
ctx.save(); ctx.translate(m.x * C, m.y * C); if (rot) ctx.rotate(-rot);
ctx.fillStyle = 'rgba(0,0,0,.65)'; ctx.fillRect(x - 1, y - 1, w + 2, v.ms > 0 ? 8 : 5);
ctx.fillStyle = f > 0.5 ? '#35e0a1' : f > 0.25 ? '#ffd24d' : '#ff5c7a';
ctx.fillRect(x, y + (v.ms > 0 ? 3 : 0), w * f, 3);
if (v.ms > 0) { ctx.fillStyle = '#6fb4ff'; ctx.fillRect(x, y, w * sf, 2); }
ctx.restore();
}
}
// ------------------------------------------------------------------ renderer
class Renderer {
constructor(canvas) {
this.cv = canvas;
this.ctx = canvas.getContext('2d', { alpha: false });
this.W = 300; this.H = 200; this.dpr = 1;
this.cam = { zoom: 1, px: 0, py: 0 };
this.board = null;
this.parts = []; this.rings = []; this.lines = []; this.texts = []; this.marks = [];
this.pulses = []; // heal / stun pulses: their own small pool, so a swarm of daemons can never starve the leak and boom rings
this.glow = new Map(); // Sandbox cell index -> seconds of flash left after its pulse
this.aim = new Map(); this.trk = new Map();
this.wallGrid = null;
this.shake = 0; this.flashCore = 0; this.lastNow = 0;
this.rot = 0; // 0, or PI/2 when the board is drawn rotated for portrait screens
this.fx = (root.matchMedia && root.matchMedia('(pointer: coarse)').matches) ? 0.55 : 1; // fewer particles on phones
this.names = {};
// versus cues (all stay empty in solo / co-op): screen effects with seconds left, Scan zones, gateway pulses, the tower list for events that name a tower
this.fxT = { surge: 0, ddos: 0, freeze: 0 }; this.scans = []; this.gatePulse = new Map(); this._towers = [];
}
setBoard(board) {
this.board = board;
this.wallGrid = new Uint8Array(board.cols * board.rows);
this.parts.length = 0; this.rings.length = 0; this.lines.length = 0; this.texts.length = 0; this.marks.length = 0; this.pulses.length = 0;
this.aim.clear(); this.trk.clear(); this.glow.clear();
this.fxT.surge = this.fxT.ddos = this.fxT.freeze = 0; this.scans.length = 0; this.gatePulse.clear();
this.resetCamera();
}
resize(w, h, dpr) {
this.W = Math.max(50, w); this.H = Math.max(50, h); this.dpr = dpr || 1;
this.cv.width = Math.round(this.W * this.dpr); this.cv.height = Math.round(this.H * this.dpr);
this._layout();
}
resetCamera() { this.cam.zoom = 1; this.cam.px = 0; this.cam.py = 0; this._layout(); }
get zoom() { return this.cam.zoom; }
setRotation(on) {
const r = on ? Math.PI / 2 : 0;
if (r === this.rot) return;
this.rot = r; this.cam.zoom = 1; this.cam.px = 0; this.cam.py = 0; this._layout();
}
_dims() {
const b = this.board;
return this.rot ? { w: b.rows * C, h: b.cols * C } : { w: b.cols * C, h: b.rows * C };
}
_layout() {
const b = this.board; if (!b) return;
const d = this._dims(), pad = 4;
this.fit = Math.min((this.W - pad * 2) / (d.w + MARGIN * 2), (this.H - pad * 2) / (d.h + MARGIN * 2));
this.scale = this.fit * this.cam.zoom;
const sw = d.w * this.scale, sh = d.h * this.scale;
const mx = sw > this.W ? (sw - this.W) / 2 + 24 : 0, my = sh > this.H ? (sh - this.H) / 2 + 24 : 0;
this.cam.px = clamp(this.cam.px, -mx, mx); this.cam.py = clamp(this.cam.py, -my, my);
this.ox = (this.W - sw) / 2 + this.cam.px; this.oy = (this.H - sh) / 2 + this.cam.py;
}
// CSS px <-> world px (world is always unrotated: 40 px per cell)
_s2w(sx, sy) {
const u = (sx - this.ox) / this.scale, v = (sy - this.oy) / this.scale;
return this.rot ? { x: v, y: this.board.rows * C - u } : { x: u, y: v };
}
_w2s(wx, wy) {
return this.rot
? { x: this.ox + (this.board.rows * C - wy) * this.scale, y: this.oy + wx * this.scale }
: { x: this.ox + wx * this.scale, y: this.oy + wy * this.scale };
}
setZoom(z, ax, ay) {
z = clamp(z, 1, 4);
const w = this._s2w(ax, ay);
this.cam.zoom = z; this._layout();
const s = this._w2s(w.x, w.y);
this.cam.px += ax - s.x; this.cam.py += ay - s.y;
this._layout();
}
panBy(dx, dy) { this.cam.px += dx; this.cam.py += dy; this._layout(); }
// CSS px (relative to the canvas) -> cell coordinates
screenToCell(sx, sy) {
const w = this._s2w(sx, sy), fx = w.x / C, fy = w.y / C;
return { x: Math.floor(fx), y: Math.floor(fy), fx, fy };
}
cellToScreen(cx, cy) { return this._w2s((cx + 0.5) * C, (cy + 0.5) * C); }
// The cell one step away in a SCREEN direction (dx, dy each -1, 0 or 1). The board is drawn turned 90 degrees on tall screens,
// so screen right is not world +x there: this is what the touch nudge buttons use.
stepCell(cx, cy, dx, dy) { return this.rot ? { x: cx + dy, y: cy - dx } : { x: cx + dx, y: cy + dy }; }
cellSizePx() { return C * this.scale; }
// ---------------------------------------------------------------- effects
_burst(x, y, col, n, speed, life) {
n = Math.max(1, Math.round(n * this.fx));
if (this.parts.length > 260) return;
for (let i = 0; i < n; i++) {
const a = Math.random() * TAU, s = (0.4 + Math.random()) * speed;
this.parts.push({ x, y, vx: Math.cos(a) * s, vy: Math.sin(a) * s, life: life * (0.6 + Math.random() * 0.6), max: life, s: 2 + Math.random() * 2.5, c: col });
}
}
_ring(x, y, r0, r1, col, life, w) { if (this.rings.length < 40) this.rings.push({ x, y, r0, r1, col, life, max: life, w: w || 2 }); }
_pulse(x, y, r0, r1, col, life, w, fill) { if (this.pulses.length < 24) this.pulses.push({ x, y, r0, r1, col, life, max: life, w, fill }); }
_text(x, y, txt, col) { if (this.texts.length < 24) this.texts.push({ x, y, txt, col, life: 0.9, max: 0.9 }); }
addMark(x, y, slot) { this.marks.push({ x, y, slot: slot | 0, life: 1.6, max: 1.6 }); if (this.marks.length > 12) this.marks.shift(); }
addEvents(evs) {
for (const e of evs) {
switch (e.e) {
case 'kill': {
const d = TD.ENEMIES[e.k];
this._burst(e.x * C, e.y * C, d ? d.color : '#fff', e.k === 'rootkit' ? 26 : SWARM[e.k] ? 2 : 6, 90, 0.5);
if (e.rw >= 3) this._text(e.x * C, e.y * C - 8, '+' + e.rw, '#ffd24d');
break;
}
case 'leak': {
const b = this.board;
this.flashCore = 1; this.shake = Math.min(2, this.shake + 0.9);
if (b) this._ring((b.core.x + 0.5) * C, (b.core.y + 0.5) * C, 10, 48, '#ff5c7a', 0.5, 3);
break;
}
case 'boom': this._ring(e.x * C, e.y * C, 4, e.r * C, '#d4f04a', 0.32, 3); this._burst(e.x * C, e.y * C, '#d4f04a', 8, 110, 0.4); break;
case 'shot':
if (e.k === 'ids') this.lines.push({ pts: [[e.x * C, e.y * C], [e.tx * C, e.ty * C]], col: '#b78cff', w: 2.5, life: 0.16, max: 0.16, jit: 0 });
else if (e.k === 'filter') this._burst(e.x * C + Math.cos(e.a) * 14, e.y * C + Math.sin(e.a) * 14, '#35e0a1', 1, 30, 0.12);
else if (e.k === 'mortar') this._burst(e.x * C + Math.cos(e.a) * 16, e.y * C + Math.sin(e.a) * 16, '#d4f04a', 3, 40, 0.25);
break;
case 'beam': {
const x1 = e.x * C, y1 = e.y * C, x2 = e.tx * C, y2 = e.ty * C, wpx = (e.w || 0.5) * C;
this.lines.push({ pts: [[x1, y1], [x2, y2]], col: 'rgba(255,226,122,.35)', w: wpx * 2.6, life: 0.42, max: 0.42, jit: 0 });
this.lines.push({ pts: [[x1, y1], [x2, y2]], col: '#ffe27a', w: wpx * 1.1, life: 0.34, max: 0.34, jit: 0 });
this.lines.push({ pts: [[x1, y1], [x2, y2]], col: '#ffffff', w: wpx * 0.45, life: 0.26, max: 0.26, jit: 0 });
this._ring(e.bx * C, e.by * C, 6, (e.br || 1.3) * C, '#ffe27a', 0.45, 4);
this._burst(e.bx * C, e.by * C, '#ffe27a', 10, 130, 0.45);
this._ring(x1, y1, 4, 30, '#ffffff', 0.25, 3);
this.shake = Math.min(2, this.shake + 0.35);
break;
}
case 'arc': this.lines.push({ pts: e.pts.map((p) => [p[0] * C, p[1] * C]), col: '#ff7ad9', w: 2.4, life: 0.18, max: 0.18, jit: 5 }); break;
case 'place': { const d = TD.TOWERS[e.type]; this._ring((e.x + 0.5) * C, (e.y + 0.5) * C, 6, 34, d ? d.color : '#fff', 0.35, 2.5); this._burst((e.x + 0.5) * C, (e.y + 0.5) * C, d ? d.color : '#fff', 5, 60, 0.35); break; }
case 'sell': this._burst((e.x + 0.5) * C, (e.y + 0.5) * C, '#9db4d8', 6, 70, 0.35); break;
case 'up': this._ring((e.x + 0.5) * C, (e.y + 0.5) * C, 6, 38, '#ffffff', 0.4, 2.5); break;
case 'stun': { // Sandbox pulse: an amber wave out to its range, a white one inside it, and the glyph flashes
const d = TD.TOWERS.sandbox, col = d ? d.color : '#ffa447', b = this.board;
const rg = (e.r || 3) * C;
this._pulse(e.x * C, e.y * C, 10, rg, col, 0.55, 3.5, 0.13);
this._pulse(e.x * C, e.y * C, 8, rg * 0.6, '#fff3dd', 0.35, 2, 0);
if (b) this.glow.set(Math.floor(e.y) * b.cols + Math.floor(e.x), 0.4);
break;
}
case 'heal': this._pulse(e.x * C, e.y * C, 10, (e.r || 2.2) * C, '#7ee08a', 0.7, 2.2, 0.07); break; // soft green wave out to the daemon's range
// ---- versus
case 'emp': { // the attacker disabled a tower: a yellow burst on it (the disabled look itself follows tower.empT)
const tw = this._towers.find((x) => x.id === e.id);
if (tw) { const cx = (tw.x + 0.5) * C, cy = (tw.y + 0.5) * C; this._ring(cx, cy, 6, 44, '#ffe27a', 0.55, 3); this._ring(cx, cy, 4, 26, '#ffffff', 0.3, 2); this._burst(cx, cy, '#ffe27a', 12, 120, 0.5); this.shake = Math.min(2, this.shake + 0.3); }
break;
}
case 'surge': this.fxT.surge = e.d || 6; break;
case 'ddos': this.fxT.ddos = e.d || 4; break;
case 'quarantine': this.fxT.freeze = e.d || 2; break;
case 'scan': {
const sc = TD.VS && TD.VS.TOOLS.scan, rd = (sc ? sc.radius : 4), rv = sc ? sc.reveal : 3;
this.scans.push({ x: e.x, y: e.y, t: rv, max: rv, r: rd });
this._pulse(e.x * C, e.y * C, 8, rd * C, '#7ee8ff', 0.6, 3, 0.1);
break;
}
case 'repair': { const b = this.board; if (b) { this._ring((b.core.x + 0.5) * C, (b.core.y + 0.5) * C, 10, 52, '#35e0a1', 0.6, 3); this._burst((b.core.x + 0.5) * C, (b.core.y + 0.5) * C, '#35e0a1', 8, 80, 0.5); } break; }
default: break;
}
}
}
// ---------------------------------------------------------------- frame
// ui: { hover:{x,y}|null, selType, selTower, preview, valid, coop, mySlot, names:{slot:name} }
frame(now, view, ui) {
const b = this.board; if (!b) return;
const ctx = this.ctx, dpr = this.dpr;
const t = now / 1000;
const dt = clamp((now - (this.lastNow || now)) / 1000, 0, 0.1); this.lastNow = now;
const sc = this.scale;
const vsui = ui && ui.vs ? ui.vs : null; // versus-only cues (null in solo / co-op)
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.fillStyle = BG; ctx.fillRect(0, 0, this.W, this.H);
let shx = 0, shy = 0;
if (this.shake > 0.02) { shx = (Math.random() - 0.5) * this.shake * 5; shy = (Math.random() - 0.5) * this.shake * 5; this.shake *= Math.pow(0.02, dt); }
const rot = this.rot;
if (rot) ctx.setTransform(0, dpr * sc, -dpr * sc, 0, dpr * (this.ox + shx + b.rows * C * sc), dpr * (this.oy + shy));
else ctx.setTransform(dpr * sc, 0, 0, dpr * sc, dpr * (this.ox + shx), dpr * (this.oy + shy));
const cols = b.cols, rows = b.rows;
// board plate
ctx.fillStyle = BOARD; ctx.fillRect(0, 0, cols * C, rows * C);
ctx.lineWidth = 1 / sc * 1.5; ctx.strokeStyle = 'rgba(77,227,255,.35)'; ctx.strokeRect(0, 0, cols * C, rows * C);
// grid
ctx.lineWidth = 1 / sc; ctx.strokeStyle = 'rgba(80,150,255,.10)';
ctx.beginPath();
for (let x = 1; x < cols; x++) { ctx.moveTo(x * C, 0); ctx.lineTo(x * C, rows * C); }
for (let y = 1; y < rows; y++) { ctx.moveTo(0, y * C); ctx.lineTo(cols * C, y * C); }
ctx.stroke();
ctx.fillStyle = 'rgba(120,200,255,.22)';
ctx.beginPath();
for (let y = 0; y <= rows; y++) for (let x = 0; x <= cols; x++) ctx.rect(x * C - 1.2, y * C - 1.2, 2.4, 2.4);
ctx.fill();
// dead nodes
for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) {
if (!b.obst[y * cols + x]) continue;
const px = x * C, py = y * C;
ctx.fillStyle = '#121828'; rr(ctx, px + 4, py + 4, C - 8, C - 8, 6); ctx.fill();
ctx.lineWidth = 1.5; ctx.strokeStyle = '#2b3556'; ctx.stroke();
ctx.strokeStyle = 'rgba(255,92,122,.32)'; ctx.lineWidth = 2;
ctx.beginPath(); ctx.moveTo(px + 12, py + 12); ctx.lineTo(px + C - 12, py + C - 12); ctx.moveTo(px + C - 12, py + 12); ctx.lineTo(px + 12, py + C - 12); ctx.stroke();
}
this._drawRoutes(ctx, b, ui, t);
this._drawEndpoints(ctx, b, view, t, dt, rot, vsui);
// walls (with trace links) then turrets
const wg = this.wallGrid; wg.fill(0);
const towers = view.towers; this._towers = towers;
for (let i = 0; i < towers.length; i++) if (towers[i].type === 'wall') wg[towers[i].y * cols + towers[i].x] = 1;
ctx.lineCap = 'round';
ctx.strokeStyle = 'rgba(90,169,255,.55)'; ctx.lineWidth = 3.2;
ctx.beginPath();
for (let i = 0; i < towers.length; i++) {
const w = towers[i]; if (w.type !== 'wall') continue;
const cx = (w.x + 0.5) * C, cy = (w.y + 0.5) * C;
if (w.x + 1 < cols && wg[w.y * cols + w.x + 1]) { ctx.moveTo(cx, cy); ctx.lineTo(cx + C, cy); }
if (w.y + 1 < rows && wg[(w.y + 1) * cols + w.x]) { ctx.moveTo(cx, cy); ctx.lineTo(cx, cy + C); }
}
ctx.stroke();
ctx.strokeStyle = 'rgba(90,169,255,.32)'; ctx.lineWidth = 2;
ctx.beginPath();
for (let i = 0; i < towers.length; i++) {
const w = towers[i]; if (w.type !== 'wall') continue;
const cx = (w.x + 0.5) * C, cy = (w.y + 0.5) * C;
if (w.x + 1 < cols && w.y + 1 < rows && wg[(w.y + 1) * cols + w.x + 1]) { ctx.moveTo(cx, cy); ctx.lineTo(cx + C, cy + C); }
if (w.x > 0 && w.y + 1 < rows && wg[(w.y + 1) * cols + w.x - 1]) { ctx.moveTo(cx, cy); ctx.lineTo(cx - C, cy + C); }
}
ctx.stroke();
// monster lookup for aiming
const monById = new Map();
for (let i = 0; i < view.monsters.length; i++) monById.set(view.monsters[i].id, view.monsters[i]);
if (this.glow.size) for (const [k, g] of this.glow) { if (g - dt <= 0) this.glow.delete(k); else this.glow.set(k, g - dt); }
this._drawLinks(ctx, towers, ui, t);
const coop = ui.coop;
for (let i = 0; i < towers.length; i++) {
const tw = towers[i];
let ang = this.aim.get(tw.id);
if (ang === undefined) ang = -Math.PI / 2;
const tg = tw.tgt ? monById.get(tw.tgt) : null;
if (tg) { ang = lerpAngle(ang, Math.atan2(tg.y - (tw.y + 0.5), tg.x - (tw.x + 0.5)), 0.35); this.aim.set(tw.id, ang); }
const cx = (tw.x + 0.5) * C, cy = (tw.y + 0.5) * C;
const gl = tw.type === 'sandbox' && this.glow.size ? this.glow.get(tw.y * cols + tw.x) : 0;
drawGlyph(ctx, tw.type, tw.level, cx, cy, C, ang, t, 1, rot, gl ? Math.min(1, gl / 0.25) : 0);
if (tw.empT > 0) this._drawEmp(ctx, tw, cx, cy, t); // versus: disabled by an EMP
else if (vsui && vsui.empArm && tw.type !== 'wall') { ctx.strokeStyle = 'rgba(255,226,122,' + (0.5 + 0.4 * Math.sin(t * 8)) + ')'; ctx.lineWidth = 2.5; rr(ctx, tw.x * C + 2, tw.y * C + 2, C - 4, C - 4, 6); ctx.stroke(); } // EMP armed: every tower it can hit
if (coop && tw.type !== 'wall') { // owner corner flag: at least ~5 CSS px, dark outline so it shows on a tile of the same colour
const k = Math.max(12, 5.5 / sc), x0 = cx - C * 0.46, y0 = cy - C * 0.46;
ctx.beginPath(); ctx.moveTo(x0, y0); ctx.lineTo(x0 + k, y0); ctx.lineTo(x0, y0 + k); ctx.closePath();
ctx.fillStyle = SLOT_COLORS[tw.owner] || '#fff'; ctx.fill();
ctx.lineWidth = 1.5 / sc; ctx.strokeStyle = '#04101a'; ctx.stroke();
}
}
if (this.aim.size > towers.length + 40) { const live = new Set(towers.map((x) => x.id)); for (const k of this.aim.keys()) if (!live.has(k)) this.aim.delete(k); }
// selection and ranges
if (ui.selTower) {
const st = towers.find((x) => x.id === ui.selTower);
if (st) {
const def = TD.TOWERS[st.type], lv = def.levels[st.level - 1];
const cx = (st.x + 0.5) * C, cy = (st.y + 0.5) * C;
if (lv.range) this._rangeRing(ctx, cx, cy, lv.range * C, def.color);
ctx.strokeStyle = '#fff'; ctx.lineWidth = 2; const k = 3 + Math.sin(t * 5) * 1.2, h = C / 2 + k;
ctx.beginPath();
for (const [sx, sy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) { ctx.moveTo(cx + sx * h, cy + sy * (h - 9)); ctx.lineTo(cx + sx * h, cy + sy * h); ctx.lineTo(cx + sx * (h - 9), cy + sy * h); }
ctx.stroke();
}
}
// ground monsters, then flyers on top
this._drawMonsters(ctx, view, t, dt, false, rot, vsui);
this._drawMonsters(ctx, view, t, dt, true, rot, vsui);
// bullets
for (const bu of view.bullets) {
if (bu.k === 'mortar') {
ctx.fillStyle = 'rgba(0,0,0,.35)'; ctx.beginPath(); ctx.arc(bu.x * C, bu.y * C + 5, 4, 0, TAU); ctx.fill();
ctx.fillStyle = '#d4f04a'; ctx.beginPath(); ctx.arc(bu.x * C, bu.y * C - 2, 4.5, 0, TAU); ctx.fill();
} else {
ctx.fillStyle = 'rgba(53,224,161,.3)'; ctx.beginPath(); ctx.arc(bu.x * C, bu.y * C, 6, 0, TAU); ctx.fill();
ctx.fillStyle = '#d6fff0'; ctx.beginPath(); ctx.arc(bu.x * C, bu.y * C, 2.6, 0, TAU); ctx.fill();
}
}
this._drawFx(ctx, dt, sc, rot);
if (vsui || this.scans.length || this.fxT.surge > 0 || this.fxT.ddos > 0 || this.fxT.freeze > 0) this._drawVsFx(ctx, dt, sc, cols, rows, t, ui);
// placement ghost
if (ui.hover && ui.selType && !ui.noGhost && b.inBounds(ui.hover.x, ui.hover.y)) {
const def = TD.TOWERS[ui.selType], lv = def.levels[0];
const cx = (ui.hover.x + 0.5) * C, cy = (ui.hover.y + 0.5) * C;
const ok = ui.valid !== false;
if (lv.range) this._rangeRing(ctx, cx, cy, lv.range * C, ok ? def.color : '#ff5c7a');
drawGlyph(ctx, ui.selType, 1, cx, cy, C, -Math.PI / 2 - rot, t, ok ? 0.7 : 0.4, rot);
if (!ok) {
ctx.fillStyle = 'rgba(255,60,90,.28)'; ctx.fillRect(ui.hover.x * C + 2, ui.hover.y * C + 2, C - 4, C - 4);
ctx.strokeStyle = '#ff5c7a'; ctx.lineWidth = 3; ctx.beginPath();
ctx.moveTo(cx - 9, cy - 9); ctx.lineTo(cx + 9, cy + 9); ctx.moveTo(cx + 9, cy - 9); ctx.lineTo(cx - 9, cy + 9); ctx.stroke();
} else {
ctx.strokeStyle = rgba(def.color, 0.9); ctx.lineWidth = 2; rr(ctx, ui.hover.x * C + 2, ui.hover.y * C + 2, C - 4, C - 4, 6); ctx.stroke();
}
} else if (ui.hover && (!ui.selType || ui.noGhost) && b.inBounds(ui.hover.x, ui.hover.y)) {
ctx.strokeStyle = 'rgba(255,255,255,.22)'; ctx.lineWidth = 1.5; ctx.strokeRect(ui.hover.x * C + 1, ui.hover.y * C + 1, C - 2, C - 2);
}
// partner cursors and pings
const labels = []; // the cell frame is drawn on the board, the name label later in screen space (clamped to the stage)
for (const cu of view.cursors || []) {
const col = SLOT_COLORS[cu.slot] || '#fff', gx = Math.floor(cu.x), gy = Math.floor(cu.y);
ctx.strokeStyle = col; ctx.lineWidth = 2; ctx.strokeRect(gx * C + 1, gy * C + 1, C - 2, C - 2);
labels.push({ nm: (ui.names && ui.names[cu.slot]) || 'Partner', col, gx, gy });
}
for (let i = this.marks.length - 1; i >= 0; i--) {
const m = this.marks[i]; m.life -= dt;
if (m.life <= 0) { this.marks.splice(i, 1); continue; }
const k = 1 - m.life / m.max, col = SLOT_COLORS[m.slot] || '#fff';
ctx.strokeStyle = col; ctx.lineWidth = 3;
for (let j = 0; j < 3; j++) {
const kk = k - j * 0.16; if (kk <= 0) continue;
ctx.globalAlpha = (1 - kk) * 0.9; ctx.beginPath(); ctx.arc((m.x + 0.5) * C, (m.y + 0.5) * C, 6 + kk * 46, 0, TAU); ctx.stroke();
}
ctx.globalAlpha = 1;
ctx.fillStyle = col; ctx.beginPath(); ctx.arc((m.x + 0.5) * C, (m.y + 0.5) * C, 5, 0, TAU); ctx.fill();
}
if (labels.length) this._cursorLabels(ctx, labels);
}
// Load Balancer links: dashed lines (flowing towards the turret) and an outline on every attack tower it boosts, only for the balancer that is
// selected, hovered or about to be built, so a busy board stays calm. Same rule as the sim's updateAuras: attack role, centre to centre
// within range. (The wire has no per-tower buff flag, so this is worked out here from the tower list.)
_drawLinks(ctx, towers, ui, t) {
let src = null;
if (ui.selTower) { const st = towers.find((x) => x.id === ui.selTower); if (st) src = st; }
if (!src && ui.hover) {
for (let i = 0; i < towers.length; i++) if (towers[i].x === ui.hover.x && towers[i].y === ui.hover.y) { src = towers[i]; break; }
if (!src && ui.selType && !ui.noGhost) src = { type: ui.selType, level: 1, x: ui.hover.x, y: ui.hover.y };
}
const def = src && TD.TOWERS[src.type];
if (!def || def.role !== 'support') return;
const lv = def.levels[src.level - 1] || def.levels[0], r2 = (lv.range || 0) * (lv.range || 0);
const bx = (src.x + 0.5) * C, by = (src.y + 0.5) * C;
let lines = null;
for (let i = 0; i < towers.length; i++) {
const tw = towers[i], d = TD.TOWERS[tw.type];
if (!d || d.role !== 'attack' || tw === src) continue;
const dx = tw.x - src.x, dy = tw.y - src.y;
if (dx * dx + dy * dy > r2) continue;
(lines || (lines = [])).push(tw);
}
if (!lines) return;
const u = Math.max(1, 0.55 / this.scale), lw = Math.max(2, 1.2 / this.scale); // keep the dashes and arrowheads readable when the cells are small
ctx.save();
ctx.lineCap = 'round'; ctx.lineJoin = 'round';
ctx.strokeStyle = rgba(def.color, 0.75); ctx.lineWidth = lw; ctx.setLineDash([6 * u, 5 * u]); ctx.lineDashOffset = -t * 16;
ctx.beginPath();
for (const tw of lines) { ctx.moveTo(bx, by); ctx.lineTo((tw.x + 0.5) * C, (tw.y + 0.5) * C); }
ctx.stroke();
ctx.setLineDash([]);
ctx.fillStyle = rgba(def.color, 0.95); ctx.lineWidth = lw;
for (const tw of lines) { // an arrowhead just outside the tile, and a frame round it
const tx = (tw.x + 0.5) * C, ty = (tw.y + 0.5) * C, a = Math.atan2(ty - by, tx - bx), d = C * 0.62 + 4 * u;
const ax = tx - Math.cos(a) * d, ay = ty - Math.sin(a) * d, ca = Math.cos(a), sa = Math.sin(a);
ctx.beginPath(); ctx.moveTo(ax + ca * 6 * u, ay + sa * 6 * u); ctx.lineTo(ax - ca * 3 * u - sa * 5 * u, ay - sa * 3 * u + ca * 5 * u); ctx.lineTo(ax - ca * 3 * u + sa * 5 * u, ay - sa * 3 * u - ca * 5 * u); ctx.closePath(); ctx.fill();
rr(ctx, tw.x * C + 1.5, tw.y * C + 1.5, C - 3, C - 3, 6); ctx.stroke();
}
ctx.restore();
}
_rangeRing(ctx, cx, cy, r, col) {
ctx.fillStyle = rgba(col, 0.07); ctx.beginPath(); ctx.arc(cx, cy, r, 0, TAU); ctx.fill();
ctx.strokeStyle = rgba(col, 0.55); ctx.lineWidth = 1.5; ctx.stroke();
}
_drawRoutes(ctx, b, ui, t) {
const pv = ui && ui.preview && ui.preview.ok && ui.preview.routes;
const dash = (col, w, speed) => { ctx.strokeStyle = col; ctx.lineWidth = w; ctx.setLineDash([9, 9]); ctx.lineDashOffset = -t * speed; };
ctx.lineJoin = 'round'; ctx.lineCap = 'round';
dash(pv ? 'rgba(77,227,255,.10)' : 'rgba(77,227,255,.34)', 3, 34);
for (const r of b.routes) {
ctx.beginPath();
for (let i = 0; i < r.length; i++) { const px = (r[i][0] + 0.5) * C, py = (r[i][1] + 0.5) * C; i ? ctx.lineTo(px, py) : ctx.moveTo(px, py); }
ctx.stroke();
}
if (pv) {
dash('rgba(255,210,77,.85)', 3.6, 60);
for (const r of ui.preview.routes) {
ctx.beginPath();
for (let i = 0; i < r.length; i++) { const px = (r[i][0] + 0.5) * C, py = (r[i][1] + 0.5) * C; i ? ctx.lineTo(px, py) : ctx.moveTo(px, py); }
ctx.stroke();
}
}
ctx.setLineDash([]);
}
_drawEndpoints(ctx, b, view, t, dt, rot, vsui) {
// spawns: red gateways
for (let gi = 0; gi < b.spawns.length; gi++) {
const sp = b.spawns[gi];
const p = (t * 0.7) % 1;
ctx.save(); ctx.translate((sp.x + 0.5) * C, (sp.y + 0.5) * C); if (rot) ctx.rotate(-rot);
ctx.strokeStyle = rgba('#ff5c7a', 0.5 * (1 - p)); ctx.lineWidth = 2; ctx.beginPath(); ctx.arc(0, 0, 12 + p * 16, 0, TAU); ctx.stroke();
ctx.fillStyle = '#2a0c18'; ctx.beginPath(); ctx.arc(0, 0, 13, 0, TAU); ctx.fill();
ctx.strokeStyle = '#ff5c7a'; ctx.lineWidth = 2; ctx.stroke();
ctx.lineWidth = 1.3; ctx.beginPath(); ctx.ellipse(0, 0, 5.5, 13, 0, 0, TAU); ctx.moveTo(-13, 0); ctx.lineTo(13, 0); ctx.stroke();
if (vsui) this._vsGate(ctx, gi, vsui, t, dt, b.spawns.length);
ctx.restore();
}
// core: server rack with an integrity ring
const c = b.core;
const frac = view.maxLives ? clamp(view.lives / view.maxLives, 0, 1) : 1;
const col = frac > 0.5 ? '#35e0a1' : frac > 0.25 ? '#ffd24d' : '#ff5c7a';
this.flashCore = Math.max(0, this.flashCore - dt * 2.2);
ctx.save(); ctx.translate((c.x + 0.5) * C, (c.y + 0.5) * C); if (rot) ctx.rotate(-rot);
ctx.strokeStyle = 'rgba(255,255,255,.08)'; ctx.lineWidth = 4; ctx.beginPath(); ctx.arc(0, 0, 25, 0, TAU); ctx.stroke();
ctx.strokeStyle = col; ctx.lineWidth = 4; ctx.beginPath(); ctx.arc(0, 0, 25, -Math.PI / 2, -Math.PI / 2 + TAU * frac); ctx.stroke();
if (this.flashCore > 0) { ctx.fillStyle = 'rgba(255,60,90,' + (this.flashCore * 0.4) + ')'; ctx.beginPath(); ctx.arc(0, 0, 29, 0, TAU); ctx.fill(); }
ctx.fillStyle = '#0d2038'; rr(ctx, -13, -16, 26, 32, 5); ctx.fill();
ctx.strokeStyle = '#4de3ff'; ctx.lineWidth = 2; ctx.stroke();
ctx.lineWidth = 1.5; ctx.beginPath();
for (let i = 0; i < 3; i++) { ctx.moveTo(-9, -9 + i * 8); ctx.lineTo(3, -9 + i * 8); }
ctx.stroke();
for (let i = 0; i < 3; i++) { ctx.fillStyle = (Math.floor(t * 3 + i * 1.7) % 2) ? col : rgba(col, 0.35); ctx.beginPath(); ctx.arc(8, -9 + i * 8, 2, 0, TAU); ctx.fill(); }
ctx.restore();
}
_drawMonsters(ctx, view, t, dt, air, rot, vsui) {
const trk = this.trk;
if (!air) { // a Daemon's heal range, faint, all in one stroke
let any = false;
for (const m of view.monsters) {
const d = TD.ENEMIES[m.kind];
if (!d.healRange) continue;
if (!any) { any = true; ctx.beginPath(); }
ctx.moveTo(m.x * C + d.healRange * C, m.y * C); ctx.arc(m.x * C, m.y * C, d.healRange * C, 0, TAU);
}
if (any) { ctx.strokeStyle = rgba(TD.ENEMIES.daemon.color, 0.15); ctx.lineWidth = 1.5; ctx.stroke(); }
}
for (const m of view.monsters) {
if (!!m.air !== air) continue;
const def = TD.ENEMIES[m.kind];
let k = trk.get(m.id);
if (!k) {
k = { x: m.x, y: m.y, ang: 0, hp: m.hp, flash: 0, still: 0, sv: null }; trk.set(m.id, k);
if (vsui) this._vsBorn(k, m, vsui, t);
}
const dm = def.shield && m.maxShield === undefined ? this._shieldView(k, m, def, dt) : m; // co-op: tell hp and shield apart (see there)
const v = vitals(dm, def), cur = v.hp + v.sh;
const dx = m.x - k.x, dy = m.y - k.y;
if (dx * dx + dy * dy > 1e-6) k.ang = lerpAngle(k.ang, Math.atan2(dy, dx), 0.35);
k.still = dx * dx + dy * dy < 1e-8 ? k.still + dt : 0;
k.x = m.x; k.y = m.y;
if (cur < k.hp) k.flash = 0.1;
k.hp = cur; k.flash = Math.max(0, k.flash - dt);
// stunned: solo knows (stunT); in co-op the wire only says "slowed or stunned", and a slowed packet still moves, so a flagged packet that stands still is stunned
const stun = m.stunT !== undefined ? m.stunT > 0 : m.slow > 0 && k.still > 0.2 && !view.paused;
if (air && !SWARM[m.kind]) { const er = def.r * C; ctx.fillStyle = 'rgba(0,0,0,.28)'; ctx.save(); ctx.translate(m.x * C, m.y * C); if (rot) ctx.rotate(-rot); ctx.beginPath(); ctx.ellipse(0, 5, er, er * 0.45, 0, 0, TAU); ctx.fill(); ctx.restore(); }
if (vsui) { this._vsUnit(ctx, dm, k, def, vsui, t, rot, stun); continue; }
drawMonster(ctx, dm, k.ang, t, k.flash, rot, stun);
}
if (air && trk.size > view.monsters.length + 60) { // drop stale trackers
const live = new Set(view.monsters.map((x) => x.id));
for (const id of trk.keys()) if (!live.has(id)) trk.delete(id);
}
}
// Co-op sends a shielded enemy as hp + shield out of maxhp + maxShield. A shield soaks first, so most of the time the split is plain from the
// total, but once the hp is hurt and the shield has regrown the total alone is ambiguous (hp 20 + shield 120 looks like hp 90 + shield 50).
// So the split is followed over time: a drop in the total hits the shield first, a rise after shieldDelay seconds without a hit refills the
// shield, any other rise is a heal. Returns a solo-style view object (hp and shield apart) kept in the tracker entry.
_shieldView(k, m, def, dt) {
const mh = m.maxhp * def.hp / (def.hp + def.shield), ms = m.maxhp - mh;
let s = k.sv;
if (!s) s = k.sv = { id: m.id, kind: m.kind, air: m.air, x: 0, y: 0, hp: 0, maxhp: mh, shield: clamp(m.hp - mh, 0, ms), maxShield: ms, slow: 0, tot: m.hp, idle: 0 };
else {
const d = m.hp - s.tot;
if (d < -0.5) { s.shield -= Math.min(s.shield, -d); s.idle = 0; }
else if (d > 0.5 && s.idle >= def.shieldDelay - 0.25 && s.shield < ms) s.shield = Math.min(ms, s.shield + d);
s.tot = m.hp; s.idle += dt;
}
s.maxhp = mh; s.maxShield = ms;
if (m.hp - s.shield > mh) s.shield = clamp(m.hp - mh, 0, ms); // more than the hp part can hold: the rest is shield
s.hp = clamp(m.hp - s.shield, 0, mh);
s.x = m.x; s.y = m.y; s.slow = m.slow; s.air = m.air;
return s;
}
// ---------------------------------------------------------------- versus cues
// a tower an EMP has switched off: dimmed, hazard stripes, flickering sparks and an arc that runs out with the time left
_drawEmp(ctx, tw, cx, cy, t) {
const total = (TD.VS && TD.VS.ABILITIES.emp.dur) || 6, h = C * 0.43;
ctx.save(); ctx.translate(cx, cy);
ctx.fillStyle = 'rgba(4,7,14,.66)'; rr(ctx, -h, -h, h * 2, h * 2, C * 0.12); ctx.fill();
ctx.save(); ctx.clip();
ctx.strokeStyle = 'rgba(255,210,77,.5)'; ctx.lineWidth = 3;
for (let i = -3; i <= 3; i++) { ctx.beginPath(); ctx.moveTo(i * 9 - 18, 18); ctx.lineTo(i * 9 + 18, -18); ctx.stroke(); }
ctx.restore();
ctx.strokeStyle = '#ffe27a'; ctx.lineWidth = 3; ctx.lineCap = 'round';
ctx.beginPath(); ctx.arc(0, 0, C * 0.5, -Math.PI / 2, -Math.PI / 2 + TAU * clamp(tw.empT / total, 0, 1)); ctx.stroke();
if (Math.sin(t * 26 + tw.id * 3) > 0.2) { // a spark
ctx.strokeStyle = '#fff6c9'; ctx.lineWidth = 2; ctx.beginPath();
const a = (Math.floor(t * 9 + tw.id) % 4) * 1.57;
ctx.moveTo(Math.cos(a) * 6, Math.sin(a) * 6); ctx.lineTo(Math.cos(a + 0.4) * 12, Math.sin(a + 0.4) * 12); ctx.lineTo(Math.cos(a - 0.1) * 15, Math.sin(a - 0.1) * 15); ctx.stroke();
}
ctx.restore();
}
// the gateway the attacker picked (amber ring), numbers on the gateways when there is a choice, and a pulse where a unit has just entered
_vsGate(ctx, gi, vsui, t, dt, n) {
const pl = this.gatePulse.get(gi);
if (pl > 0) {
const k = 1 - pl / 0.7;
ctx.strokeStyle = rgba('#ffffff', 0.85 * (1 - k)); ctx.lineWidth = 3; ctx.beginPath(); ctx.arc(0, 0, 13 + k * 26, 0, TAU); ctx.stroke();
this.gatePulse.set(gi, pl - dt); if (pl - dt <= 0) this.gatePulse.delete(gi);
}
if (vsui.gates > 1 && vsui.role === 'attacker') {
const on = vsui.gate === gi;
if (on) { ctx.strokeStyle = '#ffd24d'; ctx.lineWidth = 3.5; ctx.beginPath(); ctx.arc(0, 0, 18 + Math.sin(t * 6) * 1.5, 0, TAU); ctx.stroke(); }
ctx.fillStyle = on ? '#ffd24d' : 'rgba(8,13,26,.9)'; ctx.beginPath(); ctx.arc(11, -11, 7.5, 0, TAU); ctx.fill();
ctx.lineWidth = 1.5; ctx.strokeStyle = on ? '#ffd24d' : '#ff5c7a'; ctx.stroke();
ctx.fillStyle = on ? '#241a02' : '#ffd1da'; ctx.font = '700 10px system-ui, sans-serif'; ctx.textAlign = 'center'; ctx.textBaseline = 'middle'; ctx.fillText(String(gi + 1), 11, -10.5); ctx.textAlign = 'start';
}
}
// what the attacker knows about its own units, remembered when a unit first shows up (the wire carries neither stealth nor tech): stealth seconds and shield capacity
_vsBorn(k, m, vsui, t) {
k.born = t; k.stl = 0; k.shl = 0;
// a spawn pulse at the gateway it enters from (every client sees it: the defender too)
const b = this.board;
if (b) for (let i = 0; i < b.spawns.length; i++) { const sp = b.spawns[i], dx = m.x - (sp.x + 0.5), dy = m.y - (sp.y + 0.5); if (dx * dx + dy * dy < 1.6) { this.gatePulse.set(i, 0.7); break; } }
if (vsui.role === 'attacker' && vsui.tech && TD.VS) {
const X = TD.VS.TECH;
if (vsui.tech.stealth) k.stl = X.stealth.secs[vsui.tech.stealth - 1] || 0;
if (vsui.tech.shield) k.shl = X.shield.per * vsui.tech.shield;
}
}
_vsUnit(ctx, m, k, def, vsui, t, rot, stun) {
const r = def.r * C, now = t * 1000;
const dec = !!m.decoy || (vsui.decoys && vsui.decoys.size > 0 && (vsui.decoys.get(m.id) || 0) > now);
const hid = vsui.role === 'attacker' && (m.stealthT !== undefined ? m.stealthT > 0 : k.stl > 0 && t - k.born < k.stl);
const lift = m.kind === 'ghost' ? -7 : 0;
ctx.save();
if (dec) ctx.globalAlpha = 0.5; else if (hid) ctx.globalAlpha = 0.38;
drawMonster(ctx, m, k.ang, t, k.flash, rot, stun);
ctx.restore();
if (dec || hid || k.shl > 0 || (m.maxShield > 0 && vsui.role === 'attacker' && !def.shield)) {
ctx.save(); ctx.translate(m.x * C, m.y * C + lift); if (rot) ctx.rotate(-rot);
if (dec) { // bait: a spinning dashed ring
ctx.strokeStyle = 'rgba(126,232,255,.95)'; ctx.lineWidth = 2; ctx.setLineDash([5, 4]); ctx.lineDashOffset = -t * 20;
ctx.beginPath(); ctx.arc(0, 0, r + 7, 0, TAU); ctx.stroke(); ctx.setLineDash([]);
}
if (hid) { // cloaked: a faint shimmer ring
ctx.strokeStyle = 'rgba(190,200,255,' + (0.35 + 0.25 * Math.sin(t * 12 + m.id)) + ')'; ctx.lineWidth = 1.5; ctx.setLineDash([3, 4]); ctx.lineDashOffset = t * 10;
ctx.beginPath(); ctx.arc(0, 0, r + 4, 0, TAU); ctx.stroke(); ctx.setLineDash([]);
}
const ms = m.maxShield !== undefined && !def.shield ? m.maxShield : k.shl; // tech shield (kinds that carry their own shield draw it themselves)
if (ms > 0 && vsui.role === 'attacker' && !def.shield) {
const sh = m.shield !== undefined ? m.shield : clamp(m.hp - (m.maxhp - ms), 0, ms);
if (sh > 0.5) { ctx.strokeStyle = 'rgba(150,200,255,' + (0.3 + 0.55 * clamp(sh / ms, 0, 1)) + ')'; ctx.lineWidth = 1.2 + 1.8 * clamp(sh / ms, 0, 1); ctx.beginPath(); ctx.arc(0, 0, r + 3, 0, TAU); ctx.stroke(); }
}
ctx.restore();
}
}
// screen cues in board space: Quarantine (icy), DDoS (violet scan lines), Surge (hot edge), Scan zones, and the ring of an armed Scan
_drawVsFx(ctx, dt, sc, cols, rows, t, ui) {
const f = this.fxT, W = cols * C, H = rows * C;
if (f.freeze > 0) {
f.freeze -= dt;
ctx.fillStyle = 'rgba(160,220,255,' + (0.1 + 0.05 * Math.sin(t * 9)) + ')'; ctx.fillRect(0, 0, W, H);
ctx.strokeStyle = 'rgba(225,246,255,.85)'; ctx.lineWidth = 6 / sc; ctx.strokeRect(0, 0, W, H);
}
if (f.ddos > 0) {
f.ddos -= dt;
ctx.fillStyle = 'rgba(150,80,255,.07)'; ctx.fillRect(0, 0, W, H);
ctx.strokeStyle = 'rgba(190,130,255,.35)'; ctx.lineWidth = 1.5 / sc; ctx.beginPath();
for (let y = (t * 60) % 24; y < H; y += 24) { ctx.moveTo(0, y); ctx.lineTo(W, y); }
ctx.stroke();
}
if (f.surge > 0) {
f.surge -= dt;
ctx.strokeStyle = 'rgba(255,150,60,' + (0.45 + 0.3 * Math.sin(t * 14)) + ')'; ctx.lineWidth = 8 / sc; ctx.strokeRect(0, 0, W, H);
}
for (let i = this.scans.length - 1; i >= 0; i--) {
const z = this.scans[i]; z.t -= dt;
if (z.t <= 0) { this.scans.splice(i, 1); continue; }
const a = clamp(z.t / z.max, 0, 1), cx = z.x * C, cy = z.y * C;
ctx.fillStyle = 'rgba(126,232,255,' + 0.07 * a + ')'; ctx.beginPath(); ctx.arc(cx, cy, z.r * C, 0, TAU); ctx.fill();
ctx.strokeStyle = 'rgba(126,232,255,' + (0.35 + 0.4 * a) + ')'; ctx.lineWidth = 2; ctx.setLineDash([8, 6]); ctx.lineDashOffset = -t * 18;
ctx.beginPath(); ctx.arc(cx, cy, z.r * C, 0, TAU); ctx.stroke(); ctx.setLineDash([]);
}
const v = ui && ui.vs;
if (v && v.scanArm && ui.hover && this.board && this.board.inBounds(ui.hover.x, ui.hover.y)) {
const rd = (TD.VS && TD.VS.TOOLS.scan.radius) || 4;
this._rangeRing(ctx, (ui.hover.x + 0.5) * C, (ui.hover.y + 0.5) * C, rd * C, '#7ee8ff');
}
}
_drawFx(ctx, dt, sc, rot) {
// lines (tracers, arcs)
ctx.lineCap = 'round'; ctx.lineJoin = 'round';
for (let i = this.lines.length - 1; i >= 0; i--) {
const l = this.lines[i]; l.life -= dt;
if (l.life <= 0) { this.lines.splice(i, 1); continue; }
ctx.globalAlpha = l.life / l.max; ctx.strokeStyle = l.col; ctx.lineWidth = l.w;
ctx.beginPath();
for (let j = 0; j < l.pts.length; j++) {
const jx = l.jit && j > 0 ? (Math.random() - 0.5) * l.jit * 2 : 0, jy = l.jit && j > 0 ? (Math.random() - 0.5) * l.jit * 2 : 0;
j ? ctx.lineTo(l.pts[j][0] + jx, l.pts[j][1] + jy) : ctx.moveTo(l.pts[j][0], l.pts[j][1]);
}
ctx.stroke();
}
ctx.globalAlpha = 1;
for (let i = this.rings.length - 1; i >= 0; i--) {
const r = this.rings[i]; r.life -= dt;
if (r.life <= 0) { this.rings.splice(i, 1); continue; }
const k = 1 - r.life / r.max;
ctx.globalAlpha = 1 - k; ctx.strokeStyle = r.col; ctx.lineWidth = r.w;
ctx.beginPath(); ctx.arc(r.x, r.y, r.r0 + (r.r1 - r.r0) * k, 0, TAU); ctx.stroke();
}
ctx.globalAlpha = 1;
for (let i = this.pulses.length - 1; i >= 0; i--) {
const r = this.pulses[i]; r.life -= dt;
if (r.life <= 0) { this.pulses.splice(i, 1); continue; }
const k = 1 - r.life / r.max;
ctx.beginPath(); ctx.arc(r.x, r.y, r.r0 + (r.r1 - r.r0) * k, 0, TAU);
if (r.fill) { ctx.globalAlpha = (1 - k) * r.fill; ctx.fillStyle = r.col; ctx.fill(); }
ctx.globalAlpha = 1 - k; ctx.strokeStyle = r.col; ctx.lineWidth = r.w; ctx.stroke();
}
ctx.globalAlpha = 1;
for (let i = this.parts.length - 1; i >= 0; i--) {
const p = this.parts[i]; p.life -= dt;
if (p.life <= 0) { this.parts.splice(i, 1); continue; }
p.x += p.vx * dt; p.y += p.vy * dt; p.vx *= 0.94; p.vy *= 0.94;
ctx.globalAlpha = Math.min(1, p.life / p.max * 1.4); ctx.fillStyle = p.c;
ctx.fillRect(p.x - p.s / 2, p.y - p.s / 2, p.s, p.s);
}
ctx.globalAlpha = 1;
if (this.texts.length) {
ctx.font = '700 ' + (12 / sc) + 'px ui-monospace, monospace'; ctx.textAlign = 'center'; ctx.textBaseline = 'middle';
for (let i = this.texts.length - 1; i >= 0; i--) {
const x = this.texts[i]; x.life -= dt;
if (x.life <= 0) { this.texts.splice(i, 1); continue; }
if (rot) x.x -= 22 * dt; else x.y -= 22 * dt; // drift towards the top of the screen
ctx.globalAlpha = Math.min(1, x.life / x.max * 1.6); ctx.fillStyle = x.col;
ctx.save(); ctx.translate(x.x, x.y); if (rot) ctx.rotate(-rot); ctx.fillText(x.txt, 0, 0); ctx.restore();
}
ctx.globalAlpha = 1; ctx.textAlign = 'start';
}
}
// partner name labels: screen space, kept inside the stage, flipped below the cell when there is no room above it
_cursorLabels(ctx, labels) {
ctx.setTransform(this.dpr, 0, 0, this.dpr, 0, 0);
ctx.font = '600 11px system-ui, sans-serif'; ctx.textBaseline = 'middle'; ctx.textAlign = 'center';
const half = C * this.scale / 2;
for (const l of labels) {
const p = this.cellToScreen(l.gx, l.gy), w = ctx.measureText(l.nm).width + 10;
const x = clamp(p.x - w / 2, 2, Math.max(2, this.W - 2 - w));
let y = p.y - half - 17; if (y < 2) y = p.y + half + 2;
y = clamp(y, 2, Math.max(2, this.H - 17));
ctx.fillStyle = l.col; ctx.fillRect(x, y, w, 15);
ctx.fillStyle = '#04101a'; ctx.fillText(l.nm, x + w / 2, y + 7.5);
}
ctx.textAlign = 'start';
}
}
// Draw a tower icon into a small canvas (palette buttons, info panel)
function drawIcon(canvas, type, level) {
const dpr = Math.min(2, root.devicePixelRatio || 1), size = canvas.clientWidth || 34;
canvas.width = canvas.height = Math.round(size * dpr);
const ctx = canvas.getContext('2d');
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
ctx.clearRect(0, 0, size, size);
drawGlyph(ctx, type, level || 1, size / 2, size / 2, size * 1.1, -0.6, 0.3, 1);
}
NW.Renderer = Renderer;
NW.drawIcon = drawIcon;
NW.drawGlyph = drawGlyph;
NW.drawMonster = drawMonster;
NW.SLOT_COLORS = SLOT_COLORS;
NW.CELL = C;
NW.BOARD_MARGIN = MARGIN;
})(typeof self !== 'undefined' ? self : this);