Phone panels (reviewed + QA'd, matrix of 22 layouts with real taps/bounding boxes): - selected-tower action bar over the board (Upgrade/Sell/Target/close), info panel updated in place so taps are never lost, scrollable palette for 7+ towers, overlays with pinned footers (Help "Got it", Play solo, Join always visible), tappable room chip to invite, reduced-motion/contrast/forced-colors fixes, paused state, partner cursor labels, bigger level pips and owner flags - touch input rewritten around "pointerdown commits nothing": pinch never builds, 10px tap slop, palm-proof pinch, long-press pings with any tool armed, nudge arrows for precise placement, hotkey repeat guard, proportional wheel zoom - new e2e: select/sell, info-panel stability, UI states, touch precision; camera unit tests Proxy/server (reproduced against real nginx 1.26 with NPM v2.16 config): - Origin check works when the proxy drops a non-default port, TRUSTED_PROXIES for proxies on global IPv6/CGNAT addresses, service worker no longer serves nginx's 502 page, DEPLOY.md corrected (NPM default read timeout is 90 s, Advanced-tab limits, path-prefix, cookie size, per-IP cap behaviour) Content: - Orbital Uplink: 4-level endgame tower (450 + 500/800/1200 credits): piercing armour-ignoring beam, blast and lingering slow, ground+air, range 11-14; glyph, beam effect, sound, help text, unit tests - Maps: The Canyon, Archipelago, Fortress, Pinwheel (7 maps total) Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Tb8pW2KAN4oFkh1aK1BfD8
1127 lines
66 KiB
JavaScript
1127 lines
66 KiB
JavaScript
/*
|
||
* NETWALL main: screens, HUD, input (mouse + touch), lobby, glue between controllers, renderer and audio.
|
||
*/
|
||
(function (root) {
|
||
'use strict';
|
||
const TD = root.TD, NW = root.NW, Audio = NW.Audio;
|
||
const $ = (id) => document.getElementById(id);
|
||
const clamp = (v, a, b) => Math.min(b, Math.max(a, v));
|
||
|
||
// ------------------------------------------------------------------ storage (every access guarded)
|
||
const store = {
|
||
get(k, d) { try { const v = root.localStorage.getItem(k); return v === null ? d : JSON.parse(v); } catch (e) { return d; } },
|
||
set(k, v) { try { root.localStorage.setItem(k, JSON.stringify(v)); } catch (e) { /* ignore */ } },
|
||
del(k) { try { root.localStorage.removeItem(k); } catch (e) { /* ignore */ } },
|
||
};
|
||
const sess = {
|
||
get(k) { try { return root.sessionStorage.getItem(k); } catch (e) { return null; } },
|
||
set(k, v) { try { root.sessionStorage.setItem(k, v); } catch (e) { /* ignore */ } },
|
||
del(k) { try { root.sessionStorage.removeItem(k); } catch (e) { /* ignore */ } },
|
||
};
|
||
function randomId(n) {
|
||
const abc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
|
||
let out = '';
|
||
const buf = new Uint8Array(n);
|
||
if (root.crypto && root.crypto.getRandomValues) root.crypto.getRandomValues(buf); else for (let i = 0; i < n; i++) buf[i] = Math.random() * 256;
|
||
for (let i = 0; i < n; i++) out += abc[buf[i] & 63];
|
||
return out;
|
||
}
|
||
function getPid() { let p = sess.get('nw.pid'); if (!p || !/^[A-Za-z0-9_-]{8,40}$/.test(p)) { p = randomId(22); sess.set('nw.pid', p); } return p; }
|
||
|
||
const REASONS = {
|
||
bounds: 'Out of bounds', obstacle: 'That node is dead. Pick another cell', occupied: 'Something is already there', spawn: "Can't build on a gateway",
|
||
core: "Can't build on the server", monster: 'A packet is in the way', blocks: 'That would seal the route. Leave a path!', gold: 'Not enough credits',
|
||
over: 'The game is over', no_tower: 'That tower no longer exists', max: 'Already at max level', not_host: 'Only the host can do that',
|
||
bad_map: 'Unknown map', bad_type: 'Unknown tower', bad_cmd: 'Invalid command', not_won: 'Nothing to continue',
|
||
};
|
||
const MODE_NAMES = { first: 'First', last: 'Last', strong: 'Strongest', close: 'Closest' };
|
||
|
||
// ------------------------------------------------------------------ app state
|
||
const app = {
|
||
ctrl: null, renderer: null, screen: 'menu', inGame: false,
|
||
mapId: store.get('nw.map', 'open'),
|
||
selType: null, selTower: 0,
|
||
hover: null, pending: null, preview: null, valid: true, previewDirty: true, lastPreviewAt: 0,
|
||
zoomed: false, last: {}, names: {}, started: false, lastBossCheck: 0, bossMusic: false,
|
||
endShown: false, prevPlayers: null,
|
||
};
|
||
const ui = { hover: null, selType: null, selTower: 0, preview: null, valid: true, coop: false, names: {} };
|
||
|
||
const canvas = $('board');
|
||
const renderer = new NW.Renderer(canvas);
|
||
app.renderer = renderer;
|
||
if (!TD.MAPS[app.mapId]) app.mapId = 'open';
|
||
|
||
// ------------------------------------------------------------------ small UI helpers
|
||
let lastToast = '', lastToastAt = 0;
|
||
function toast(text, kind) {
|
||
const now = performance.now();
|
||
if (text === lastToast && now - lastToastAt < 900) return;
|
||
lastToast = text; lastToastAt = now;
|
||
const d = document.createElement('div');
|
||
d.className = 'toast' + (kind ? ' ' + kind : '');
|
||
d.textContent = text;
|
||
$('toasts').appendChild(d);
|
||
setTimeout(() => d.remove(), 2700);
|
||
while ($('toasts').children.length > 3) $('toasts').firstChild.remove();
|
||
}
|
||
let bannerT = 0;
|
||
function banner(text, boss) {
|
||
const b = $('banner');
|
||
b.textContent = text; b.className = 'banner show' + (boss ? ' boss' : '');
|
||
clearTimeout(bannerT);
|
||
bannerT = setTimeout(() => { b.className = 'banner' + (boss ? ' boss' : ''); }, 1500);
|
||
}
|
||
let hintText = '', hintKind = '';
|
||
function hint(text, kind) {
|
||
const h = $('hint'), ch = $('confirmHint');
|
||
hintText = text || ''; hintKind = kind || 'info';
|
||
if (!$('confirm').hidden && $('app').dataset.barrows !== '0') { // the touch build bar carries the route text itself: one overlay on the board instead of two (not when it is too small for it)
|
||
h.hidden = true; h.textContent = hintText; ch.textContent = hintText; ch.className = 'chint ' + hintKind; return; // (#hint keeps the text, hidden, for readers and tests)
|
||
}
|
||
if (!text) { h.hidden = true; return; }
|
||
h.hidden = false; h.textContent = text; h.className = 'hint ' + hintKind;
|
||
}
|
||
const fmtLen = (v) => String(Math.round(v / Math.max(1, ui.spawns || 1)));
|
||
|
||
function showOverlay(id) {
|
||
for (const o of document.querySelectorAll('.overlay')) {
|
||
const wasHidden = o.hidden; o.hidden = o.id !== id;
|
||
if (wasHidden && !o.hidden) { const body = o.querySelector('.card-body'); if (body) body.scrollTop = 0; }
|
||
}
|
||
}
|
||
function setScreen(name) {
|
||
app.screen = name;
|
||
$('app').dataset.screen = name;
|
||
}
|
||
|
||
// ------------------------------------------------------------------ controller switching
|
||
function useController(ctrl) {
|
||
if (app.ctrl && app.ctrl !== ctrl && app.ctrl.kind === 'remote') { /* closed by caller */ }
|
||
app.ctrl = ctrl;
|
||
ctrl.on('events', onEvents);
|
||
ctrl.on('reject', onReject);
|
||
ctrl.on('mark', (m) => { renderer.addMark(m.x, m.y, m.slot); Audio.sfx('ping'); });
|
||
ctrl.on('players', onPlayers);
|
||
ctrl.on('newgame', () => { resetSelection(); app.endShown = false; app.last.state = 'playing'; adoptBoard(); $('end').hidden = true; });
|
||
adoptBoard(true);
|
||
}
|
||
function adoptBoard(force) {
|
||
const b = app.ctrl.board;
|
||
if (b && (force || renderer.board !== b)) {
|
||
renderer.setBoard(b);
|
||
$('app').style.setProperty('--aspect', b.cols + ' / ' + b.rows);
|
||
$('app').style.setProperty('--aspect-p', b.rows + ' / ' + b.cols);
|
||
ui.spawns = b.spawns.length;
|
||
resizeCanvas();
|
||
}
|
||
}
|
||
function resetSelection() {
|
||
app.selType = null; app.selTower = 0; app.pending = null; app.hover = null; app.preview = null; app.previewDirty = true;
|
||
syncPalette(); renderInfo(true); updateConfirm();
|
||
}
|
||
|
||
function startSolo(mapId) {
|
||
leaveRemote(true);
|
||
app.mapId = mapId; store.set('nw.map', mapId);
|
||
const c = new NW.LocalController({ map: mapId });
|
||
useController(c);
|
||
app.inGame = true; app.started = true; app.endShown = false; app.last = {};
|
||
resetSelection(); setScreen('playing'); showOverlay(null);
|
||
$('players').hidden = true; $('netChip').hidden = true; $('reconnect').hidden = true;
|
||
renderInfo(true);
|
||
Audio.music('battle');
|
||
requestWakeLock();
|
||
if (!store.get('nw.helped', false)) { store.set('nw.helped', true); showOverlay('help'); }
|
||
}
|
||
function previewMap(mapId) {
|
||
const c = new NW.LocalController({ map: mapId });
|
||
c.paused = true;
|
||
useController(c);
|
||
app.inGame = false;
|
||
}
|
||
|
||
function leaveRemote(silent) {
|
||
const c = app.ctrl;
|
||
if (c && c.kind === 'remote') { c.close(); }
|
||
sess.del('nw.room'); store.del('nw.session');
|
||
clearRoomFromUrl();
|
||
if (!silent) { /* caller handles screens */ }
|
||
}
|
||
function clearRoomFromUrl() {
|
||
try { if (root.location.search) root.history.replaceState(null, '', root.location.pathname); } catch (e) { /* ignore */ }
|
||
}
|
||
|
||
// ------------------------------------------------------------------ events from the controller
|
||
function onEvents(evs) {
|
||
renderer.addEvents(evs);
|
||
for (const e of evs) {
|
||
switch (e.e) {
|
||
case 'place': Audio.sfx(e.type === 'wall' ? 'wall' : 'place'); break;
|
||
case 'sell': Audio.sfx('sell'); break;
|
||
case 'up': Audio.sfx('up'); break;
|
||
case 'shot': Audio.sfx('shot_' + e.k); break;
|
||
case 'arc': Audio.sfx('arc'); break;
|
||
case 'boom': Audio.sfx('boom'); break;
|
||
case 'kill': Audio.sfx('kill'); break;
|
||
case 'leak': Audio.sfx('leak'); break;
|
||
case 'wave': banner(e.boss ? 'BOSS WAVE ' + e.n : 'WAVE ' + e.n, e.boss); Audio.sfx(e.boss ? 'boss' : 'wave'); break;
|
||
case 'clear': toast('Wave ' + e.n + ' cleared +' + e.bonus + ' credits', 'good'); Audio.sfx('clear'); break;
|
||
default: break;
|
||
}
|
||
}
|
||
}
|
||
let errSfxAt = -1e9;
|
||
function onReject(r) {
|
||
toast(REASONS[r.reason] || ('Not possible: ' + r.reason), 'bad');
|
||
// One buzzer per wall stroke (a stroke can reject dozens of cells), and never a burst: co-op rejects arrive after the finger has lifted (touch-16)
|
||
const now = performance.now();
|
||
if (now - errSfxAt > 450 && !(painting && strokeErr)) { errSfxAt = now; Audio.sfx('error'); }
|
||
if (painting) strokeErr = true;
|
||
}
|
||
|
||
// ------------------------------------------------------------------ palette + info panel
|
||
function buildPalette() {
|
||
const pal = $('palette');
|
||
pal.textContent = '';
|
||
pal.classList.toggle('many', TD.TOWER_ORDER.length > 6);
|
||
for (const type of TD.TOWER_ORDER) {
|
||
const def = TD.TOWERS[type];
|
||
const b = document.createElement('button');
|
||
b.className = 'tbtn'; b.dataset.type = type; b.type = 'button';
|
||
b.setAttribute('aria-label', def.name + ', ' + def.levels[0].cost + ' credits');
|
||
b.innerHTML = '<span class="key">' + def.key + '</span><canvas></canvas><span class="nm"></span><span class="cost"></span>';
|
||
b.querySelector('.nm').textContent = def.name;
|
||
b.querySelector('.cost').textContent = String(def.levels[0].cost);
|
||
b.addEventListener('click', () => { Audio.sfx('click'); selectType(app.selType === type ? null : type); });
|
||
pal.appendChild(b);
|
||
}
|
||
drawPaletteIcons(); updatePaletteHint();
|
||
}
|
||
// A palette that does not fit scrolls (sideways when stacked, down in the narrow landscape column). data-more says on which
|
||
// side more tiles are hidden; the CSS fades that edge so the player can see there is more.
|
||
function updatePaletteHint() {
|
||
const p = $('palette'); let more = '';
|
||
const edge = (pos, size, view) => { const a = pos > 2, b = pos < size - view - 2; return a && b ? 'both' : a ? 'start' : b ? 'end' : ''; };
|
||
if (p.scrollWidth > p.clientWidth + 2) more = edge(p.scrollLeft, p.scrollWidth, p.clientWidth);
|
||
else if (p.scrollHeight > p.clientHeight + 2) more = edge(p.scrollTop, p.scrollHeight, p.clientHeight);
|
||
if (more) { if (p.dataset.more !== more) p.dataset.more = more; } else if (p.dataset.more) delete p.dataset.more;
|
||
}
|
||
function revealTile(b) { // scroll the palette (only the palette, never the page) so this tile is fully in view
|
||
const p = $('palette'); if (!b) return;
|
||
const pr = p.getBoundingClientRect(), br = b.getBoundingClientRect(), m = 34; // keep clear of the edge fade
|
||
if (p.scrollWidth > p.clientWidth + 2) {
|
||
if (br.left < pr.left + m) p.scrollLeft -= pr.left + m - br.left; else if (br.right > pr.right - m) p.scrollLeft += br.right - (pr.right - m);
|
||
} else if (p.scrollHeight > p.clientHeight + 2) {
|
||
if (br.top < pr.top + m) p.scrollTop -= pr.top + m - br.top; else if (br.bottom > pr.bottom - m) p.scrollTop += br.bottom - (pr.bottom - m);
|
||
}
|
||
updatePaletteHint();
|
||
}
|
||
$('palette').addEventListener('scroll', updatePaletteHint, { passive: true });
|
||
function drawPaletteIcons() {
|
||
for (const b of $('palette').children) NW.drawIcon(b.querySelector('canvas'), b.dataset.type, 1);
|
||
}
|
||
function syncPalette() {
|
||
for (const b of $('palette').children) {
|
||
const sel = b.dataset.type === app.selType;
|
||
b.classList.toggle('sel', sel);
|
||
b.setAttribute('aria-pressed', sel ? 'true' : 'false');
|
||
if (sel) revealTile(b);
|
||
}
|
||
}
|
||
function selectType(type) {
|
||
app.selType = type; app.selTower = 0; app.pending = null; app.previewDirty = true;
|
||
syncPalette(); renderInfo(true); updateConfirm();
|
||
if (!type) { ui.preview = null; hint(null); }
|
||
}
|
||
function selectTower(id) {
|
||
app.selTower = id; app.selType = null; app.pending = null; app.preview = null; ui.preview = null;
|
||
syncPalette(); renderInfo(true); updateConfirm(); hint(null);
|
||
}
|
||
|
||
function statsFor(type, lv) {
|
||
const L = TD.TOWERS[type].levels[lv], out = [];
|
||
if (L.dmg) out.push(['Damage', String(Math.round(L.dmg))]);
|
||
if (L.rate) out.push(['Fire rate', L.rate.toFixed(1) + '/s']);
|
||
if (L.dmg && L.rate) out.push(['DPS', String(Math.round(L.dmg * L.rate))]);
|
||
if (L.range) out.push(['Range', L.range.toFixed(1)]);
|
||
if (L.splash) out.push(['Splash', L.splash.toFixed(1)]);
|
||
if (L.slow) out.push(['Slows', Math.round(L.slow * 100) + '%']);
|
||
if (L.chains) out.push(['Chains', String(L.chains)]);
|
||
return out;
|
||
}
|
||
function targetsText(def) { return def.ground && def.air ? 'ground + air' : def.ground ? 'ground only' : 'none'; }
|
||
|
||
// The info panel is built ONCE per selection (tower id + owner, or armed build type) and then updated in place, so a
|
||
// button is never replaced under a finger: partner actions bump view.rev constantly in co-op (code-2). A rebuild that
|
||
// would replace nodes is deferred while a pointer is down inside the panel.
|
||
const info = { shape: '', sig: '', lv: 0, pressed: false, dirty: false };
|
||
|
||
function renderInfo(force) {
|
||
const box = $('info'), ctrl = app.ctrl, view = ctrl.view;
|
||
let tower = null, ownerP = null, shape = '';
|
||
if (app.selTower) {
|
||
tower = view.towers.find((t) => t.id === app.selTower) || null;
|
||
if (!tower) app.selTower = 0;
|
||
}
|
||
if (tower) {
|
||
if (ctrl.kind === 'remote' && ctrl.players.length > 1) ownerP = ctrl.players.find((p) => p.slot === tower.owner) || null;
|
||
shape = 't' + tower.id + tower.type + ':' + (ownerP ? ownerP.slot + ownerP.name : '');
|
||
} else if (app.selType) shape = 'b' + app.selType;
|
||
if (!force && shape === info.shape) { if (tower) syncInfo(); return; }
|
||
if (info.pressed) { info.dirty = true; return; } // never replace a node while a pointer is down on it
|
||
info.shape = shape; info.sig = ''; info.lv = 0; info.dirty = false;
|
||
if (!shape) { box.textContent = ''; return; }
|
||
if (tower) {
|
||
const def = TD.TOWERS[tower.type], wall = tower.type === 'wall';
|
||
box.innerHTML =
|
||
'<div class="panel info"><div class="info-head"><canvas></canvas><div><div class="nm"></div><div class="lv"></div></div></div>' +
|
||
'<div class="desc"></div><div class="kv"></div><div class="actions">' +
|
||
(wall ? '' : '<button type="button" data-act="up"><svg class="ic"><use href="#i-up"/></svg><span class="w"></span><span class="cost" id="upCost"></span></button>') +
|
||
'<button type="button" data-act="sell" class="danger"><svg class="ic"><use href="#i-trash"/></svg><span class="w">Sell</span><span class="cost"></span></button>' +
|
||
(wall ? '' : '<button type="button" data-act="mode" title="Which packet to shoot"><svg class="ic"><use href="#i-target"/></svg><span class="w">Target:</span><span class="mv"></span></button>') +
|
||
'<button type="button" data-act="close" class="icon" aria-label="Close" title="Close"><svg class="ic"><use href="#i-x"/></svg></button></div>' +
|
||
'<div class="byline">' + (wall ? '' : '<span id="infoKills"></span>') + (ownerP ? '<span class="dot" style="background:' + NW.SLOT_COLORS[ownerP.slot] + '"></span><span id="infoOwner"></span>' : '') + '</div></div>';
|
||
box.querySelector('.nm').textContent = def.name;
|
||
box.querySelector('.desc').textContent = def.desc;
|
||
if (ownerP) box.querySelector('#infoOwner').textContent = 'Built by ' + ownerP.name;
|
||
syncInfo();
|
||
} else {
|
||
const def = TD.TOWERS[app.selType];
|
||
let kv = '';
|
||
for (const row of statsFor(app.selType, 0)) kv += '<div class="kvp"><span>' + row[0] + '</span><span>' + row[1] + '</span></div>';
|
||
if (app.selType !== 'wall') kv += '<div class="kvp"><span>Targets</span><span>' + targetsText(def) + '</span></div>';
|
||
box.innerHTML = '<div class="panel info"><div class="info-head"><canvas></canvas><div><div class="nm"></div><div class="lv"></div></div></div><div class="desc"></div><div class="kv">' + kv + '</div></div>';
|
||
box.querySelector('.nm').textContent = def.name;
|
||
box.querySelector('.lv').textContent = def.levels[0].cost + ' credits';
|
||
box.querySelector('.desc').textContent = def.desc;
|
||
NW.drawIcon(box.querySelector('canvas'), app.selType, 1);
|
||
}
|
||
}
|
||
// numbers of the selected tower: only text/disabled changes, never a replaced element
|
||
function syncInfo() {
|
||
if (!app.selTower) return;
|
||
const box = $('info'), view = app.ctrl.view, t = view.towers.find((x) => x.id === app.selTower);
|
||
if (!t || !box.firstChild) return;
|
||
const def = TD.TOWERS[t.type], wall = t.type === 'wall', i = t.level - 1;
|
||
const canUp = t.level < def.levels.length, upCost = canUp ? def.levels[t.level].cost : 0;
|
||
const affordable = canUp && view.gold >= upCost;
|
||
const sellVal = def.refund ? t.spent : Math.floor(t.spent * TD.SELL_RATIO);
|
||
const sig = t.level + ':' + t.mode + ':' + sellVal + ':' + t.kills + ':' + (affordable ? 1 : 0);
|
||
if (sig === info.sig) return;
|
||
info.sig = sig;
|
||
const setText = (el, v) => { if (el && el.textContent !== v) el.textContent = v; };
|
||
if (info.lv !== t.level) { // level changed: stats table and icon
|
||
info.lv = t.level;
|
||
const cur = statsFor(t.type, i), nxt = canUp ? statsFor(t.type, i + 1) : null;
|
||
let kv = '';
|
||
cur.forEach((row, k) => {
|
||
const n = nxt && nxt[k] && nxt[k][1] !== row[1] ? ' <span class="up">→ ' + nxt[k][1] + '</span>' : '';
|
||
kv += '<div class="kvp"><span>' + row[0] + '</span><span>' + row[1] + n + '</span></div>';
|
||
});
|
||
if (!wall) kv += '<div class="kvp"><span>Targets</span><span>' + targetsText(def) + '</span></div>';
|
||
box.querySelector('.kv').innerHTML = kv;
|
||
setText(box.querySelector('.lv'), wall ? '' : 'Level ' + t.level + ' / ' + def.levels.length);
|
||
NW.drawIcon(box.querySelector('canvas'), t.type, t.level);
|
||
}
|
||
const up = box.querySelector('[data-act="up"]');
|
||
if (up) {
|
||
setText(up.querySelector('.w'), canUp ? 'Upgrade' : 'Max level');
|
||
setText(up.querySelector('.cost'), canUp ? String(upCost) : '');
|
||
up.disabled = !affordable;
|
||
up.setAttribute('aria-label', canUp ? 'Upgrade for ' + upCost + ' credits' : 'Max level');
|
||
}
|
||
const sell = box.querySelector('[data-act="sell"]');
|
||
setText(sell.querySelector('.cost'), String(sellVal));
|
||
sell.setAttribute('aria-label', 'Sell for ' + sellVal + ' credits');
|
||
const mode = box.querySelector('[data-act="mode"]');
|
||
if (mode) { setText(mode.querySelector('.mv'), MODE_NAMES[t.mode]); mode.setAttribute('aria-label', 'Target: ' + MODE_NAMES[t.mode] + '. Tap to change'); }
|
||
setText(box.querySelector('#infoKills'), t.kills + (t.kills === 1 ? ' kill' : ' kills'));
|
||
}
|
||
let infoTimer = 0;
|
||
$('info').addEventListener('pointerdown', () => { clearTimeout(infoTimer); info.pressed = true; }); // (a new press cancels the previous release timer)
|
||
const infoRelease = () => {
|
||
if (!info.pressed) return;
|
||
clearTimeout(infoTimer);
|
||
infoTimer = setTimeout(() => { info.pressed = false; if (info.dirty) renderInfo(false); }, 90); // after the click has been delivered
|
||
};
|
||
document.addEventListener('pointerup', infoRelease, true);
|
||
document.addEventListener('pointercancel', infoRelease, true);
|
||
$('info').addEventListener('click', (e) => {
|
||
const btn = e.target.closest('button[data-act]'); if (!btn || !app.selTower) return;
|
||
info.pressed = false;
|
||
const ctrl = app.ctrl, tower = ctrl.view.towers.find((t) => t.id === app.selTower);
|
||
if (!tower) return;
|
||
Audio.sfx('click');
|
||
switch (btn.dataset.act) {
|
||
case 'up': ctrl.send({ c: 'upgrade', id: tower.id }); break;
|
||
case 'sell': ctrl.send({ c: 'sell', id: tower.id }); app.selTower = 0; renderInfo(true); app.previewDirty = true; break;
|
||
case 'close': selectTower(0); break;
|
||
case 'mode': {
|
||
const modes = TD.TARGET_MODES; ctrl.send({ c: 'target', id: tower.id, mode: modes[(modes.indexOf(tower.mode) + 1) % modes.length] });
|
||
break;
|
||
}
|
||
default: break;
|
||
}
|
||
});
|
||
|
||
function renderWavePanel(view) {
|
||
const n = view.wave + 1;
|
||
const key = n + ':' + view.state;
|
||
if (app.last.waveKey === key) return;
|
||
app.last.waveKey = key;
|
||
const box = $('nextwave');
|
||
if (view.state !== 'playing') { box.textContent = ''; return; }
|
||
const sum = TD.waveSummary(n);
|
||
let html = '<div class="panel"><h4>Next · wave ' + n + '</h4><div class="wv">';
|
||
let air = false;
|
||
for (const g of sum) {
|
||
const d = TD.ENEMIES[g.k];
|
||
if (d.air) air = true;
|
||
html += '<span class="e" title="' + d.name + (d.air ? ' (flies)' : '') + '"><i class="sh-' + g.k + '" style="--c:' + d.color + '"></i>' + g.c + '× ' + d.name + '</span>';
|
||
}
|
||
if (air) html += '<span class="tag air">AIR</span>';
|
||
if (n % 10 === 0) html += '<span class="tag boss">BOSS</span>';
|
||
html += '</div></div>';
|
||
box.innerHTML = html;
|
||
}
|
||
|
||
function onPlayers(list) {
|
||
const ctrl = app.ctrl;
|
||
ui.names = {}; for (const p of list) ui.names[p.slot] = p.name;
|
||
ui.coop = list.length > 1;
|
||
// join / leave toasts
|
||
if (app.prevPlayers) {
|
||
for (const p of list) if (!app.prevPlayers.find((q) => q.pid === p.pid)) { toast(p.name + ' joined', 'good'); Audio.sfx('join'); }
|
||
for (const q of app.prevPlayers) if (!list.find((p) => p.pid === q.pid)) toast(q.name + ' left');
|
||
for (const p of list) { const q = app.prevPlayers.find((x) => x.pid === p.pid); if (q && q.online && !p.online) toast(p.name + ' lost connection'); if (q && !q.online && p.online) toast(p.name + ' is back', 'good'); }
|
||
}
|
||
app.prevPlayers = list.map((p) => Object.assign({}, p));
|
||
renderPlayers();
|
||
if (ctrl.kind === 'remote') renderInfo(false); // the shape includes the owner, so only a changed roster rebuilds
|
||
}
|
||
function renderPlayers() {
|
||
const ctrl = app.ctrl, box = $('players');
|
||
if (!ctrl || ctrl.kind !== 'remote') { box.hidden = true; return; }
|
||
box.hidden = false;
|
||
let html = '<div class="panel"><h4>Room ' + (ctrl.room || '') + ' <span id="plPing" class="muted"></span></h4>';
|
||
for (const p of ctrl.players) {
|
||
html += '<div class="pl"><span class="dot" style="background:' + NW.SLOT_COLORS[p.slot] + '"></span><span class="pn"></span>' +
|
||
(ctrl.you && p.pid === ctrl.you.pid ? '<span class="you">(you)</span>' : '') + (p.host ? '<span class="you">host</span>' : '') + (p.online ? '' : '<span class="off">offline</span>') + '</div>';
|
||
}
|
||
if (ctrl.players.length < 2) html += '<div class="muted small">Waiting for a partner… share the invite link.</div>';
|
||
html += '<div class="actions"><button type="button" data-act="invite"><svg class="ic"><use href="#i-share"/></svg>Invite</button><button type="button" data-act="leave" class="danger">Leave</button></div></div>';
|
||
box.innerHTML = html;
|
||
const names = box.querySelectorAll('.pn');
|
||
ctrl.players.forEach((p, i) => { names[i].textContent = p.name; });
|
||
}
|
||
$('players').addEventListener('click', (e) => {
|
||
const b = e.target.closest('button[data-act]'); if (!b) return;
|
||
if (b.dataset.act === 'invite') invite();
|
||
if (b.dataset.act === 'leave') { leaveToMenu(); }
|
||
});
|
||
function inviteUrl() { return root.location.origin + root.location.pathname + '?room=' + app.ctrl.room; }
|
||
function invite() {
|
||
const url = inviteUrl(), text = 'Join my Netwall game (room ' + app.ctrl.room + ')';
|
||
if (root.navigator.share) { root.navigator.share({ title: 'Netwall', text, url }).catch(() => {}); return; }
|
||
const done = () => toast('Invite link copied', 'good');
|
||
if (root.navigator.clipboard && root.navigator.clipboard.writeText) root.navigator.clipboard.writeText(url).then(done, () => root.prompt('Copy this link', url));
|
||
else root.prompt('Copy this link', url);
|
||
}
|
||
|
||
// ------------------------------------------------------------------ HUD
|
||
function updateHud(view) {
|
||
const L = app.last, ctrl = app.ctrl;
|
||
if (L.gold !== view.gold) { L.gold = view.gold; $('vGold').textContent = String(view.gold); }
|
||
if (L.lives !== view.lives) {
|
||
L.lives = view.lives; $('vLives').textContent = String(view.lives);
|
||
$('statLives').classList.toggle('low', view.maxLives > 0 && view.lives <= view.maxLives * 0.25);
|
||
}
|
||
if (L.wave !== view.wave) { L.wave = view.wave; $('vWave').textContent = String(view.wave); }
|
||
if (L.winWave !== view.winWave) { L.winWave = view.winWave; $('vWaveMax').textContent = view.winWave ? '/' + view.winWave : ''; }
|
||
const idle = view.queued === 0 && view.monsters.length === 0;
|
||
const timer = view.auto && view.nextWaveIn >= 0 ? ' · ' + Math.ceil(view.nextWaveIn) + 's' : '';
|
||
const wtxt = 'Wave ' + (view.wave + 1) + timer;
|
||
if (L.wtxt !== wtxt) { L.wtxt = wtxt; $('btnWaveText').textContent = wtxt; }
|
||
const wdis = view.state !== 'playing';
|
||
if (L.wdis !== wdis) { L.wdis = wdis; $('btnWave').disabled = wdis; }
|
||
const attn = idle && view.wave === 0 && view.state === 'playing';
|
||
if (L.attn !== attn) { L.attn = attn; $('btnWave').classList.toggle('attn', attn); }
|
||
if (L.auto !== view.auto) { L.auto = view.auto; $('btnAuto').setAttribute('aria-pressed', view.auto ? 'true' : 'false'); }
|
||
if (L.speed !== view.speed) { L.speed = view.speed; $('speedText').textContent = view.speed + '×'; }
|
||
if (L.paused !== view.paused) { // paused: dimmed board, a resume pill, and an amber pressed pause button (not a second play triangle)
|
||
L.paused = view.paused; $('pausedTag').hidden = !view.paused; $('stage').classList.toggle('paused', !!view.paused);
|
||
$('btnPause').setAttribute('aria-pressed', view.paused ? 'true' : 'false'); $('btnPause').setAttribute('aria-label', view.paused ? 'Resume' : 'Pause');
|
||
}
|
||
const offline = !$('reconnect').hidden;
|
||
if (L.offline !== offline) { L.offline = offline; $('app').classList.toggle('offline', offline); }
|
||
if (L.muted !== Audio.muted) { L.muted = Audio.muted; $('btnSound').innerHTML = '<svg class="ic"><use href="#i-' + (Audio.muted ? 'mute' : 'sound') + '"/></svg>'; }
|
||
// palette affordability
|
||
const gold = view.gold;
|
||
if (L.palGold !== gold) {
|
||
L.palGold = gold;
|
||
for (const b of $('palette').children) b.classList.toggle('poor', gold < TD.TOWERS[b.dataset.type].levels[0].cost);
|
||
}
|
||
if (ctrl.kind === 'remote') {
|
||
const chip = $('netChip');
|
||
chip.hidden = false;
|
||
$('netRoom').textContent = ctrl.room || '';
|
||
const alone = ctrl.players.length < 2;
|
||
if (L.alone !== alone || L.room !== ctrl.room) {
|
||
L.alone = alone; L.room = ctrl.room; chip.classList.toggle('waiting', alone);
|
||
chip.setAttribute('aria-label', 'Co-op room ' + (ctrl.room || '') + (alone ? '. Waiting for a partner: tap to invite them' : '. Tap to invite your partner'));
|
||
}
|
||
const p = ctrl.rtt ? ctrl.rtt + ' ms' : '';
|
||
if (L.ping !== p) { L.ping = p; $('netPing').textContent = p; chip.classList.toggle('bad', ctrl.rtt > 220); const pp = $('plPing'); if (pp) pp.textContent = p ? '\u00b7 ' + p : ''; }
|
||
}
|
||
renderWavePanel(view);
|
||
syncInfo();
|
||
}
|
||
|
||
function endScreen(view) {
|
||
const ctrl = app.ctrl;
|
||
const won = view.state === 'won';
|
||
$('endTitle').textContent = won ? 'Server secured!' : 'Breach!';
|
||
$('endTitle').style.color = won ? 'var(--green)' : 'var(--red)';
|
||
const best = store.get('nw.best.' + ctrl.board.mapId, 0);
|
||
if (!won && view.wave > best) store.set('nw.best.' + ctrl.board.mapId, view.wave);
|
||
$('endText').textContent = won ? 'You held the line through wave ' + view.wave + '. Every packet was filtered.' : 'The server fell on wave ' + view.wave + '.';
|
||
const walls = view.towers.filter((t) => t.type === 'wall').length;
|
||
const rows = [['Wave', view.wave], ['Packets killed', view.kills], ['Turrets', view.towers.length - walls], ['Firewalls', walls], ['Integrity left', view.lives], ['Best (map)', Math.max(best, view.wave)]];
|
||
$('endStats').innerHTML = rows.map((r) => '<div><span>' + r[0] + '</span><b>' + r[1] + '</b></div>').join('');
|
||
const remoteGuest = ctrl.kind === 'remote' && !(ctrl.you && ctrl.you.host);
|
||
$('btnAgain').hidden = remoteGuest; $('endWait').hidden = !remoteGuest;
|
||
$('btnContinue').hidden = !won;
|
||
showOverlay('end');
|
||
Audio.music(null); Audio.stinger(won ? 'win' : 'lose');
|
||
}
|
||
|
||
// ------------------------------------------------------------------ placement + previews
|
||
function cellFromEvent(e) {
|
||
const r = canvas.getBoundingClientRect();
|
||
return renderer.screenToCell(e.clientX - r.left, e.clientY - r.top);
|
||
}
|
||
function placeAt(cell) {
|
||
const ctrl = app.ctrl;
|
||
if (!app.selType || !cell || !ctrl.board.inBounds(cell.x, cell.y)) return false;
|
||
const cost = TD.TOWERS[app.selType].levels[0].cost;
|
||
if (ctrl.view.gold < cost) { onReject({ reason: 'gold' }); return false; }
|
||
ctrl.send({ c: 'place', type: app.selType, x: cell.x, y: cell.y });
|
||
app.previewDirty = true;
|
||
return true;
|
||
}
|
||
function refreshPreview(force) {
|
||
const ctrl = app.ctrl, now = performance.now();
|
||
const cell = app.pending || app.hover;
|
||
if (cell && app.selType && ui.noGhost) { if (ui.preview || !$('hint').hidden) { ui.preview = null; ui.valid = true; hint(null); } return; }
|
||
if (!app.selType || !cell || !ctrl.board.inBounds(cell.x, cell.y)) {
|
||
if (ui.preview || !$('hint').hidden) { ui.preview = null; ui.valid = true; hint(null); }
|
||
return;
|
||
}
|
||
if (!force && !app.previewDirty && now - app.lastPreviewAt < 250) return;
|
||
app.previewDirty = false; app.lastPreviewAt = now;
|
||
const pv = ctrl.preview(cell.x, cell.y, true);
|
||
const cost = TD.TOWERS[app.selType].levels[0].cost;
|
||
const poor = ctrl.view.gold < cost;
|
||
ui.preview = pv; ui.valid = pv.ok && !poor;
|
||
if (!pv.ok) hint('✕ ' + (REASONS[pv.reason] || pv.reason), 'bad');
|
||
else if (poor) hint('Need ' + cost + ' credits (have ' + ctrl.view.gold + ')', 'bad');
|
||
else {
|
||
const d = Math.round(pv.after - pv.before) / 1;
|
||
const a = Math.round(pv.before / (ui.spawns || 1)), b = Math.round(pv.after / (ui.spawns || 1));
|
||
hint(b === a ? 'Route ' + a : 'Route ' + a + ' → ' + b + (b > a ? ' (+' + (b - a) + ')' : ' (' + (b - a) + ')'), d > 0.5 ? 'ok' : 'info');
|
||
}
|
||
}
|
||
|
||
// touch placement bar
|
||
function updateConfirm() {
|
||
const show = !!(app.pending && app.selType && app.selType !== 'wall');
|
||
$('confirm').hidden = !show;
|
||
if (show) { const cost = TD.TOWERS[app.selType].levels[0].cost; $('confirmText').textContent = 'Build · ' + cost; $('btnConfirmBuild').setAttribute('aria-label', 'Build for ' + cost + ' credits'); hint(hintText, hintKind); }
|
||
else if (!ptrs.size) clearCursor(); // (no pending cell, no finger down: the partner's view of our touch cursor goes)
|
||
layoutBars(true);
|
||
}
|
||
// Where the floating bars go (the touch confirm bar and the selected-tower action bar): on the half of the stage away from the
|
||
// cell they act on, so they never cover it. Runs every frame (cheap, writes only on change) so rotation, resize, pan and zoom
|
||
// keep it right (touch-14). The stage rectangle goes into CSS variables because the tower bar is position:fixed.
|
||
// The bar does not hop to the other half while the same cell is being worked on (nudging across the middle must not move the buttons
|
||
// out from under the thumb): it flips only when the cell would end up under it.
|
||
let barKey = '', barSide = '', barSubject = '';
|
||
function layoutBars(force) {
|
||
const r = $('stage').getBoundingClientRect(), a = $('app'), conf = !$('confirm').hidden && !!app.pending;
|
||
let cell = null;
|
||
if (conf) cell = app.pending;
|
||
else if (app.selTower && app.ctrl) cell = app.ctrl.view.towers.find((t) => t.id === app.selTower) || null;
|
||
let side = '';
|
||
if (cell) {
|
||
const sp = renderer.cellToScreen(cell.x, cell.y), bar = conf ? $('confirm') : $('info').querySelector('.actions');
|
||
const guard = (bar ? bar.offsetHeight : 54) + 8 + renderer.cellSizePx() / 2 + 8; // the strip a bar there would cover, plus the cell itself
|
||
const hit = (s) => (s === 'top' ? sp.y < guard : sp.y > r.height - guard);
|
||
const subject = conf ? 'pending' : 'tower' + app.selTower;
|
||
const mid = sp.y > r.height * 0.5 ? 'top' : 'bottom', other = mid === 'top' ? 'bottom' : 'top';
|
||
side = subject === barSubject && barSide && !hit(barSide) ? barSide : hit(mid) && !hit(other) ? other : mid;
|
||
barSubject = subject; barSide = side;
|
||
} else { barSubject = ''; barSide = ''; }
|
||
const key = side + '|' + (conf ? 1 : 0) + '|' + Math.round(r.left) + ',' + Math.round(r.top) + ',' + Math.round(r.width) + ',' + Math.round(r.height);
|
||
if (!force && key === barKey) return;
|
||
barKey = key;
|
||
const st = a.style;
|
||
st.setProperty('--st-l', r.left.toFixed(1) + 'px'); st.setProperty('--st-t', r.top.toFixed(1) + 'px');
|
||
st.setProperty('--st-w', r.width.toFixed(1) + 'px'); st.setProperty('--st-h', r.height.toFixed(1) + 'px');
|
||
if (side) a.dataset.bar = side; else delete a.dataset.bar;
|
||
if (conf) a.dataset.conf = '1'; else delete a.dataset.conf; // the build bar is taller than the tower bar (it has the nudge row)
|
||
a.dataset.barrows = r.width >= 484 ? '1' : r.height >= 262 ? '2' : '0'; // build bar: nudge buttons in the bar's row on a wide stage, a second row on a phone, no text at all on a tiny one
|
||
a.dataset.barw = r.width < 440 ? 's' : 'm'; // narrow stage: the bar drops the words, keeps icons + numbers
|
||
$('confirm').classList.toggle('top', side === 'top');
|
||
}
|
||
$('btnConfirmBuild').addEventListener('click', () => { if (app.pending && placeAt(app.pending)) setPending(null); });
|
||
$('btnCancelBuild').addEventListener('click', () => { selectType(null); });
|
||
|
||
// ------------------------------------------------------------------ pointer input
|
||
// Touch rules. pointerdown never builds and never selects: every pinch starts with one finger down. A TAP (the finger stays within
|
||
// TAP_SLOP of where it landed and lifts before the long press) acts on the cell it LANDED on, when it lifts. A DRAG acts as soon as it
|
||
// passes the slop: it paints a Firewall line, aims the pending turret, or pans a zoomed board. A second finger turns the whole gesture
|
||
// into pinch/pan and undoes whatever the first finger had begun; extra fingers (a palm) are ignored. A long press pings the map,
|
||
// whatever is armed, and never builds. Cells are only 12 to 20 px on a phone, which is why the build bar also has nudge buttons.
|
||
const TAP_SLOP = 10, MOUSE_SLOP = 8, LONG_MS = 520;
|
||
const ptrs = new Map();
|
||
let painting = false, paintCell = null, panning = false, longT = 0, longFired = false, rightDown = null, pinch = null;
|
||
let multi = false; // a second finger landed: pinch/pan owns the gesture until every finger is up
|
||
let tg = null; // the one-finger touch gesture in progress: { id, cell (where it landed), pend (pending cell then), hover0, dragged }
|
||
let tapSelectOnUp = false;
|
||
let tapTowerId = 0; // a wall stroke that began on a turret: a stationary click or tap selects that turret instead (touch-17)
|
||
let pendFree = true; // the pending cell held no tower when it was chosen (a tower appearing there later is the partner's, coop-7)
|
||
let curSent = false; // a touch cursor is showing on the partner's board
|
||
let strokeErr = false; // this wall stroke already played its error sound (touch-16)
|
||
|
||
function cancelLong() { clearTimeout(longT); longT = 0; }
|
||
function setHover(cell) {
|
||
const c = cell && app.ctrl.board.inBounds(cell.x, cell.y) ? { x: cell.x, y: cell.y } : null;
|
||
if (!c && !app.hover) return;
|
||
if (c && app.hover && c.x === app.hover.x && c.y === app.hover.y) return;
|
||
app.hover = c; app.previewDirty = true;
|
||
}
|
||
// The partner's view of where this touch is aiming. `force` skips the 70 ms throttle (the last position must get through).
|
||
function touchCursor(cell, force) {
|
||
if (!cell || !app.ctrl.board.inBounds(cell.x, cell.y)) return;
|
||
app.ctrl.sendCursor(cell.x + 0.5, cell.y + 0.5, force); curSent = true;
|
||
}
|
||
function clearCursor() { if (curSent) { curSent = false; app.ctrl.sendCursor(null, null); } }
|
||
// The only way the touch-pending build cell changes. An off-board cell is no cell (code-23).
|
||
function setPending(cell, commit) {
|
||
const c = cell && app.ctrl.board.inBounds(cell.x, cell.y) ? { x: cell.x, y: cell.y } : null;
|
||
app.pending = c; pendFree = !c || !towerAtCell(c); app.previewDirty = true;
|
||
if (c) { setHover(c); touchCursor(c, commit); }
|
||
updateConfirm();
|
||
}
|
||
// the finger-down preview ends without a commit (long press, second finger, cancel): hover goes back, the touch cursor goes away
|
||
function unaim() {
|
||
if (tg) { app.hover = tg.hover0; app.previewDirty = true; }
|
||
if (!app.pending) clearCursor();
|
||
}
|
||
function abortTouch() { // forget what the first finger began: a second finger landed, or the touch was cancelled
|
||
cancelLong(); painting = false; paintCell = null; tapSelectOnUp = false; tapTowerId = 0; longFired = false;
|
||
if (tg) { if (tg.dragged) setPending(tg.pend); unaim(); tg = null; }
|
||
}
|
||
function startStroke(cell) { painting = true; paintCell = cell; strokeErr = false; }
|
||
function seedPinch() { // pinch/pan between the first two fingers only; the pair is re-seeded when one of them lifts
|
||
const ids = [...ptrs.keys()].slice(0, 2), a = ptrs.get(ids[0]), b = ptrs.get(ids[1]);
|
||
pinch = { ids, d: Math.hypot(a.x - b.x, a.y - b.y) || 1, mx: (a.x + b.x) / 2, my: (a.y + b.y) / 2 };
|
||
}
|
||
// nudge buttons: move the pending cell one cell in a screen direction (rotation-safe), and keep it in view when zoomed in
|
||
function nudge(dx, dy) {
|
||
const p = app.pending; if (!p) return;
|
||
const c = renderer.stepCell(p.x, p.y, dx, dy);
|
||
if (!app.ctrl.board.inBounds(c.x, c.y)) return; // the edge of the board: stay put
|
||
setPending(c, true);
|
||
if (renderer.zoom > 1.01) {
|
||
const s = renderer.cellToScreen(c.x, c.y), m = renderer.cellSizePx() * 1.5;
|
||
const mx = s.x < m ? m - s.x : s.x > renderer.W - m ? renderer.W - m - s.x : 0, my = s.y < m ? m - s.y : s.y > renderer.H - m ? renderer.H - m - s.y : 0;
|
||
if (mx || my) { renderer.panBy(mx, my); updateFit(); }
|
||
}
|
||
}
|
||
$('nudge').addEventListener('click', (e) => {
|
||
const b = e.target.closest('button[data-dx]'); if (!b) return;
|
||
Audio.sfx('click'); nudge(+b.dataset.dx, +b.dataset.dy);
|
||
});
|
||
|
||
function paintLine(from, to) { // place on every cell crossed by a fast drag (Bresenham)
|
||
let x0 = from.x, y0 = from.y; const x1 = to.x, y1 = to.y;
|
||
const dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0), sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
|
||
let err = dx + dy;
|
||
for (let guard = 0; guard < 80; guard++) {
|
||
if (x0 !== from.x || y0 !== from.y) placeAt({ x: x0, y: y0 });
|
||
if (x0 === x1 && y0 === y1) break;
|
||
const e2 = 2 * err;
|
||
if (e2 >= dy) { err += dy; x0 += sx; }
|
||
if (e2 <= dx) { err += dx; y0 += sy; }
|
||
}
|
||
}
|
||
function markAt(cell) {
|
||
if (!cell || !app.ctrl.board.inBounds(cell.x, cell.y)) return;
|
||
app.ctrl.sendMark(cell.x, cell.y);
|
||
if (navigator.vibrate) try { navigator.vibrate(15); } catch (e) { /* ignore */ }
|
||
}
|
||
function towerAtCell(cell) {
|
||
return app.ctrl.view.towers.find((x) => x.x === cell.x && x.y === cell.y) || null;
|
||
}
|
||
function tapSelect(cell) {
|
||
const ctrl = app.ctrl;
|
||
if (!ctrl.board.inBounds(cell.x, cell.y)) { selectTower(0); return; }
|
||
const t = ctrl.view.towers.find((x) => x.x === cell.x && x.y === cell.y);
|
||
if (t) { selectTower(t.id); Audio.sfx('click'); } else selectTower(0);
|
||
}
|
||
|
||
canvas.addEventListener('contextmenu', (e) => e.preventDefault());
|
||
canvas.addEventListener('pointerdown', (e) => {
|
||
if (!app.inGame) return;
|
||
e.preventDefault();
|
||
try { canvas.setPointerCapture(e.pointerId); } catch (err) { /* ignore */ }
|
||
Audio.unlock();
|
||
const touch = e.pointerType !== 'mouse';
|
||
if (touch && e.isPrimary) { ptrs.clear(); abortTouch(); multi = false; pinch = null; } // (a lost pointerup must never leave half a gesture behind)
|
||
const r = canvas.getBoundingClientRect(), sx = e.clientX - r.left, sy = e.clientY - r.top;
|
||
ptrs.set(e.pointerId, { x: sx, y: sy, sx, sy, type: e.pointerType, moved: false, btn: e.button });
|
||
if (ptrs.size >= 2) { // second finger: pinch/pan; whatever the first finger had begun is undone, a third finger is ignored
|
||
if (!multi) { multi = true; abortTouch(); }
|
||
if (!pinch) seedPinch();
|
||
return;
|
||
}
|
||
const cell = renderer.screenToCell(sx, sy);
|
||
longFired = false;
|
||
if (!touch) {
|
||
if (e.button === 2) { rightDown = { x: sx, y: sy, moved: false }; return; }
|
||
if (e.button === 1) { panning = true; return; }
|
||
if (e.altKey) { markAt(cell); return; }
|
||
const ex = towerAtCell(cell);
|
||
if (app.selType === 'wall' && ex && ex.type !== 'wall') { setHover(cell); startStroke(cell); tapTowerId = ex.id; } // a Firewall stroke may start on a turret; a plain click selects it
|
||
else if (app.selType && ex && !(app.selType === 'wall' && ex.type === 'wall')) { selectTower(ex.id); Audio.sfx('click'); }
|
||
else if (app.selType) {
|
||
setHover(cell);
|
||
if (!ex) placeAt(cell);
|
||
if (app.selType === 'wall') startStroke(cell);
|
||
} else {
|
||
tapSelectOnUp = true; panning = renderer.zoom > 1.01;
|
||
}
|
||
return;
|
||
}
|
||
// touch / pen: remember what is under the finger and preview it; commit nothing until the finger lifts or drags
|
||
tg = { id: e.pointerId, cell, pend: app.pending ? { x: app.pending.x, y: app.pending.y } : null, hover0: app.hover, dragged: false };
|
||
if (app.selType) { setHover(cell); touchCursor(cell); }
|
||
tapSelectOnUp = !app.selType;
|
||
longT = setTimeout(() => { // a long press pings the map, whatever is armed
|
||
longT = 0; if (!tg || multi || tg.id !== e.pointerId) return;
|
||
longFired = true; tapSelectOnUp = false; unaim(); markAt(tg.cell);
|
||
}, LONG_MS);
|
||
});
|
||
|
||
canvas.addEventListener('pointermove', (e) => {
|
||
const r = canvas.getBoundingClientRect(), sx = e.clientX - r.left, sy = e.clientY - r.top;
|
||
const p = ptrs.get(e.pointerId);
|
||
if (!app.inGame) return;
|
||
if (!p) { // hovering mouse
|
||
if (e.pointerType === 'mouse') {
|
||
const cell = renderer.screenToCell(sx, sy);
|
||
setHover(cell);
|
||
app.ctrl.sendCursor(cell.fx, cell.fy);
|
||
}
|
||
return;
|
||
}
|
||
const dx = sx - p.x, dy = sy - p.y;
|
||
p.x = sx; p.y = sy;
|
||
if (Math.hypot(sx - p.sx, sy - p.sy) > (e.pointerType === 'mouse' ? MOUSE_SLOP : TAP_SLOP)) p.moved = true;
|
||
if (pinch) {
|
||
if (!pinch.ids.includes(e.pointerId)) return; // a third finger (palm) neither pans nor zooms
|
||
const a = ptrs.get(pinch.ids[0]), b = ptrs.get(pinch.ids[1]); if (!a || !b) return;
|
||
const d = Math.hypot(a.x - b.x, a.y - b.y) || 1, mx = (a.x + b.x) / 2, my = (a.y + b.y) / 2;
|
||
renderer.panBy(mx - pinch.mx, my - pinch.my);
|
||
renderer.setZoom(renderer.zoom * d / pinch.d, mx, my);
|
||
pinch.d = d; pinch.mx = mx; pinch.my = my;
|
||
updateFit();
|
||
return;
|
||
}
|
||
if (multi) return; // one finger of a pinch is still down: it must not paint, aim or pan
|
||
const cell = renderer.screenToCell(sx, sy);
|
||
if (e.pointerType === 'mouse') {
|
||
if (rightDown) { if (Math.hypot(sx - rightDown.x, sy - rightDown.y) > 5) rightDown.moved = true; if (rightDown.moved) { renderer.panBy(dx, dy); updateFit(); } rightDown.x = rightDown.moved ? sx : rightDown.x; return; }
|
||
if (panning && p.moved) { renderer.panBy(dx, dy); updateFit(); tapSelectOnUp = false; return; }
|
||
setHover(cell);
|
||
app.ctrl.sendCursor(cell.fx, cell.fy);
|
||
if (painting && app.selType === 'wall' && paintCell && (cell.x !== paintCell.x || cell.y !== paintCell.y)) { tapTowerId = 0; paintLine(paintCell, cell); paintCell = cell; }
|
||
return;
|
||
}
|
||
// touch / pen
|
||
if (!tg || tg.id !== e.pointerId || !p.moved) return; // inside the tap slop it is still a tap: nothing moves
|
||
cancelLong(); tapSelectOnUp = false;
|
||
if (app.selType === 'wall') {
|
||
if (!painting) { // the stroke starts here; paintLine skips its first cell, so the origin goes in now (unless a tower is on it)
|
||
startStroke(tg.cell);
|
||
if (!towerAtCell(tg.cell)) placeAt(tg.cell);
|
||
}
|
||
setHover(cell);
|
||
if (cell.x !== paintCell.x || cell.y !== paintCell.y) { paintLine(paintCell, cell); paintCell = cell; }
|
||
} else if (app.selType) { // aim: the pending cell follows the finger (off the board it stays on the last cell)
|
||
if (app.ctrl.board.inBounds(cell.x, cell.y)) { tg.dragged = true; setPending(cell); }
|
||
} else if (renderer.zoom > 1.01) {
|
||
renderer.panBy(dx, dy); updateFit();
|
||
}
|
||
});
|
||
|
||
function endPointer(e) {
|
||
const p = ptrs.get(e.pointerId), cancelled = e.type === 'pointercancel';
|
||
ptrs.delete(e.pointerId);
|
||
try { canvas.releasePointerCapture(e.pointerId); } catch (err) { /* ignore */ }
|
||
if (!p || !app.inGame) { if (!ptrs.size) { multi = false; pinch = null; } return; }
|
||
cancelLong();
|
||
if (e.pointerType === 'mouse') {
|
||
const r = canvas.getBoundingClientRect(), cell = renderer.screenToCell(e.clientX - r.left, e.clientY - r.top);
|
||
if (e.button === 2 && rightDown) { if (!rightDown.moved) { selectType(null); selectTower(0); } rightDown = null; return; }
|
||
if (e.button === 1) { panning = false; return; }
|
||
if (tapSelectOnUp && !p.moved && e.type === 'pointerup') tapSelect(cell);
|
||
if (tapTowerId && !p.moved && e.type === 'pointerup') { selectTower(tapTowerId); Audio.sfx('click'); }
|
||
tapSelectOnUp = false; tapTowerId = 0; painting = false; panning = false;
|
||
return;
|
||
}
|
||
// touch / pen
|
||
if (pinch && pinch.ids.includes(e.pointerId)) { if (ptrs.size >= 2) seedPinch(); else pinch = null; }
|
||
const wasMulti = multi;
|
||
if (!ptrs.size) multi = false;
|
||
if (wasMulti) return; // the end of a pinch/pan is never a tap
|
||
const g = tg;
|
||
if (!g || g.id !== e.pointerId) return;
|
||
if (cancelled) { abortTouch(); return; } // pointercancel: no action, nothing half done
|
||
tg = null;
|
||
const wasPainting = painting; painting = false; paintCell = null;
|
||
if (wasPainting || p.moved || longFired) { // a stroke, an aim drag, a pan or a long press: lifting the finger adds nothing
|
||
tapSelectOnUp = false;
|
||
if (longFired) unaim(); else if (!app.pending) clearCursor();
|
||
return;
|
||
}
|
||
// a tap, on the cell the finger landed on (not wherever it drifted to)
|
||
const cell = g.cell, ex = towerAtCell(cell);
|
||
if (app.selType === 'wall') {
|
||
if (ex && ex.type !== 'wall') { selectTower(ex.id); Audio.sfx('click'); } // (a drag that starts on a turret is a stroke: it keeps the tool)
|
||
else if (!ex) placeAt(cell);
|
||
} else if (app.selType) {
|
||
if (ex) { selectTower(ex.id); Audio.sfx('click'); }
|
||
else if (!app.ctrl.board.inBounds(cell.x, cell.y)) setPending(null);
|
||
else if (g.pend && g.pend.x === cell.x && g.pend.y === cell.y) { if (placeAt(cell)) setPending(null); } // tapping the previewed cell again builds
|
||
else setPending(cell, true);
|
||
} else if (tapSelectOnUp) tapSelect(cell);
|
||
tapSelectOnUp = false;
|
||
if (!app.pending) clearCursor();
|
||
}
|
||
canvas.addEventListener('pointerup', endPointer);
|
||
canvas.addEventListener('pointercancel', endPointer);
|
||
canvas.addEventListener('pointerleave', (e) => { if (e.pointerType === 'mouse' && !ptrs.size) { app.hover = null; app.previewDirty = true; app.ctrl.sendCursor(null, null); } });
|
||
canvas.addEventListener('wheel', (e) => {
|
||
if (!app.inGame) return;
|
||
e.preventDefault();
|
||
const r = canvas.getBoundingClientRect();
|
||
// proportional to the scroll distance (a mouse notch is about the old 1.15x; a trackpad glides). ctrl+wheel is a trackpad pinch: much smaller deltas.
|
||
const dy = clamp(e.deltaY * (e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? 400 : 1), -300, 300);
|
||
renderer.setZoom(renderer.zoom * Math.exp(-dy * (e.ctrlKey ? 0.01 : 0.0015)), e.clientX - r.left, e.clientY - r.top);
|
||
updateFit();
|
||
}, { passive: false });
|
||
// (the window lost focus mid-gesture: the pointerup may never arrive)
|
||
root.addEventListener('blur', () => { ptrs.clear(); abortTouch(); multi = false; pinch = null; rightDown = null; panning = false; });
|
||
|
||
function updateFit() {
|
||
const z = renderer.zoom > 1.02;
|
||
if (z !== app.zoomed) { app.zoomed = z; $('btnFit').hidden = !z; }
|
||
}
|
||
$('btnFit').addEventListener('click', () => { renderer.resetCamera(); updateFit(); });
|
||
|
||
// ------------------------------------------------------------------ keyboard
|
||
root.addEventListener('keydown', (e) => {
|
||
if (e.target && (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA')) return;
|
||
if (e.ctrlKey || e.metaKey) return;
|
||
if (e.repeat) return; // holding a key is one press: Space must not start 20 waves (code-6)
|
||
if (!app.inGame) return;
|
||
if (document.querySelector('.overlay:not([hidden])')) { if (e.key === 'Escape') { closeOverlayToGame(); } return; }
|
||
const ctrl = app.ctrl, view = ctrl.view;
|
||
const k = e.key.toLowerCase();
|
||
// Space / Enter on a focused button or link press THAT control (keyboard users), not the next-wave hotkey (code-8)
|
||
if ((k === ' ' || k === 'enter') && e.target && e.target.closest && e.target.closest('button, a, select, [role="button"]')) return;
|
||
const keyType = k.length === 1 ? TD.TOWER_ORDER.find((t) => TD.TOWERS[t].key === k) : null; // 1-9, 0: one key per tower in the palette
|
||
if (keyType) { selectType(app.selType === keyType ? null : keyType); Audio.sfx('click'); e.preventDefault(); return; }
|
||
switch (k) {
|
||
case 'escape': case 'q': selectType(null); selectTower(0); app.pending = null; updateConfirm(); break;
|
||
case ' ': case 'enter': ctrl.send({ c: 'wave' }); e.preventDefault(); break;
|
||
case 'p': ctrl.ctl('pause', !view.paused); break;
|
||
case 'f': ctrl.ctl('speed', view.speed % 3 + 1); break;
|
||
case 'a': ctrl.send({ c: 'auto', v: !view.auto }); break;
|
||
case 'm': Audio.toggleMuted(); break;
|
||
case 'u': if (app.selTower) $('info').querySelector('[data-act="up"]') && $('info').querySelector('[data-act="up"]').click(); break;
|
||
case 'x': case 'delete': case 'backspace': if (app.selTower) { $('info').querySelector('[data-act="sell"]') && $('info').querySelector('[data-act="sell"]').click(); e.preventDefault(); } break;
|
||
case 't': if (app.selTower) $('info').querySelector('[data-act="mode"]') && $('info').querySelector('[data-act="mode"]').click(); break;
|
||
case '?': case 'h': showOverlay('help'); break;
|
||
default: break;
|
||
}
|
||
});
|
||
|
||
document.addEventListener('click', (e) => { const b = e.target.closest && e.target.closest('button'); if (b && e.detail > 0) b.blur(); });
|
||
|
||
// ------------------------------------------------------------------ top bar buttons
|
||
$('btnWave').addEventListener('click', () => { Audio.sfx('click'); app.ctrl.send({ c: 'wave' }); });
|
||
$('btnAuto').addEventListener('click', () => { Audio.sfx('click'); app.ctrl.send({ c: 'auto', v: !app.ctrl.view.auto }); });
|
||
$('btnSpeed').addEventListener('click', () => { Audio.sfx('click'); app.ctrl.ctl('speed', app.ctrl.view.speed % 3 + 1); });
|
||
$('btnPause').addEventListener('click', () => { Audio.sfx('click'); app.ctrl.ctl('pause', !app.ctrl.view.paused); });
|
||
$('btnSound').addEventListener('click', () => { Audio.unlock(); Audio.toggleMuted(); Audio.sfx('click'); });
|
||
$('btnMenu').addEventListener('click', () => { Audio.sfx('click'); openMenu(); });
|
||
$('pausedTag').addEventListener('click', () => { Audio.sfx('click'); app.ctrl.ctl('pause', false); });
|
||
$('netChip').addEventListener('click', () => { if (app.ctrl && app.ctrl.kind === 'remote') { Audio.sfx('click'); invite(); } }); // room code chip: tap to invite
|
||
|
||
// ------------------------------------------------------------------ menu / lobby
|
||
function buildMapPicker() {
|
||
const box = $('mapPick'); box.textContent = '';
|
||
for (const id of TD.MAP_ORDER) {
|
||
const def = TD.MAPS[id];
|
||
const b = document.createElement('button');
|
||
b.type = 'button'; b.className = 'mapcard'; b.dataset.map = id; b.setAttribute('role', 'radio');
|
||
b.innerHTML = '<canvas width="208" height="128"></canvas><span class="nm"></span><span class="df">DIFFICULTY <b></b></span>';
|
||
b.querySelector('.nm').textContent = def.name;
|
||
b.querySelector('.df b').textContent = '●'.repeat(def.difficulty) + '○'.repeat(3 - def.difficulty);
|
||
drawMapPreview(b.querySelector('canvas'), def);
|
||
b.addEventListener('click', () => { Audio.sfx('click'); chooseMap(id); });
|
||
box.appendChild(b);
|
||
}
|
||
chooseMap(app.mapId, true);
|
||
}
|
||
function drawMapPreview(cv, def) {
|
||
const p = TD.parseMap(def), ctx = cv.getContext('2d'), w = cv.width / p.cols, h = cv.height / p.rows;
|
||
ctx.fillStyle = '#09101f'; ctx.fillRect(0, 0, cv.width, cv.height);
|
||
ctx.fillStyle = '#26304f';
|
||
for (let y = 0; y < p.rows; y++) for (let x = 0; x < p.cols; x++) if (p.obst[y * p.cols + x]) ctx.fillRect(x * w + 1, y * h + 1, w - 2, h - 2);
|
||
ctx.fillStyle = '#ff5c7a'; for (const s of p.spawns) { ctx.beginPath(); ctx.arc((s.x + 0.5) * w, (s.y + 0.5) * h, h * 0.6, 0, Math.PI * 2); ctx.fill(); }
|
||
ctx.fillStyle = '#4de3ff'; ctx.fillRect(p.core.x * w - 2, p.core.y * h - 2, w + 4, h + 4);
|
||
}
|
||
function chooseMap(id, silent) {
|
||
app.mapId = id; store.set('nw.map', id);
|
||
for (const b of $('mapPick').children) b.setAttribute('aria-checked', b.dataset.map === id ? 'true' : 'false');
|
||
$('mapDesc').textContent = TD.MAPS[id].desc;
|
||
$('lobbyMapName').textContent = 'Map: ' + TD.MAPS[id].name;
|
||
if (!silent && !app.inGame) previewMap(id);
|
||
}
|
||
|
||
function openMenu() {
|
||
if (app.inGame && app.ctrl.kind === 'local') app.ctrl.ctl('pause', true);
|
||
setScreen(app.inGame ? 'playing' : 'menu');
|
||
$('btnCloseMenu').hidden = !app.inGame;
|
||
$('btnSolo').lastChild.textContent = app.inGame ? 'New solo game' : 'Play solo';
|
||
showOverlay('menu');
|
||
if (!app.inGame) Audio.music('theme');
|
||
updateResumeButton();
|
||
}
|
||
function closeOverlayToGame() {
|
||
if (!app.inGame) return;
|
||
showOverlay(null);
|
||
if (app.ctrl.kind === 'local' && app.ctrl.view.paused) app.ctrl.ctl('pause', false);
|
||
}
|
||
function leaveToMenu() {
|
||
leaveRemote(true);
|
||
app.prevPlayers = null;
|
||
app.inGame = false;
|
||
$('reconnect').hidden = true; $('players').hidden = true; $('netChip').hidden = true;
|
||
previewMap(app.mapId);
|
||
setScreen('menu'); openMenu();
|
||
}
|
||
|
||
$('btnSolo').addEventListener('click', () => { Audio.unlock(); startSolo(app.mapId); });
|
||
$('btnCloseMenu').addEventListener('click', closeOverlayToGame);
|
||
$('btnHelp').addEventListener('click', () => showOverlay('help'));
|
||
$('btnHelpClose').addEventListener('click', () => { if (app.inGame) closeOverlayToGame(); else showOverlay('menu'); });
|
||
$('btnFullscreen').addEventListener('click', () => {
|
||
const d = document, el = d.documentElement;
|
||
if (d.fullscreenElement) d.exitFullscreen(); else if (el.requestFullscreen) el.requestFullscreen().catch(() => {});
|
||
});
|
||
if (!document.documentElement.requestFullscreen || (root.matchMedia && root.matchMedia('(display-mode: standalone)').matches)) $('btnFullscreen').hidden = true; else $('btnFullscreen').hidden = false;
|
||
|
||
$('btnAgain').addEventListener('click', () => {
|
||
Audio.sfx('click');
|
||
if (app.ctrl.kind === 'local') { app.ctrl.newGame(app.ctrl.mapId); Audio.music('battle'); }
|
||
else { app.ctrl.newGame(app.ctrl.board.mapId); }
|
||
});
|
||
$('btnContinue').addEventListener('click', () => { app.ctrl.send({ c: 'continue' }); $('end').hidden = true; app.endShown = false; Audio.music('battle'); });
|
||
$('btnEndMenu').addEventListener('click', () => { if (app.ctrl.kind === 'remote') leaveToMenu(); else { app.inGame = false; previewMap(app.mapId); setScreen('menu'); openMenu(); } });
|
||
|
||
// lobby
|
||
function lobbyMsg(text, bad) { const m = $('lobbyMsg'); m.textContent = text || ''; m.className = 'msg' + (bad ? ' bad' : ''); }
|
||
function openLobby(code) {
|
||
showOverlay('lobby'); setScreen(app.inGame ? 'playing' : 'menu');
|
||
$('inName').value = store.get('nw.name', '') || '';
|
||
if (code) $('inCode').value = code;
|
||
lobbyMsg(root.location.protocol === 'file:' ? 'Co-op needs the Netwall server: run "npm start" and open its address (the page is currently opened as a file).' : '', root.location.protocol === 'file:');
|
||
}
|
||
$('btnCoop').addEventListener('click', () => { Audio.unlock(); openLobby(); });
|
||
$('btnLobbyBack').addEventListener('click', () => { if (app.inGame) closeOverlayToGame(); else openMenu(); });
|
||
$('inCode').addEventListener('input', (e) => { e.target.value = e.target.value.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 4); });
|
||
$('btnCreate').addEventListener('click', () => connectRemote({ room: null, map: app.mapId }));
|
||
$('btnJoin').addEventListener('click', () => {
|
||
const code = $('inCode').value.trim().toUpperCase();
|
||
if (!/^[A-Z0-9]{4}$/.test(code)) { lobbyMsg('Enter the 4 character room code.', true); return; }
|
||
connectRemote({ room: code });
|
||
});
|
||
$('inCode').addEventListener('keydown', (e) => { if (e.key === 'Enter') $('btnJoin').click(); });
|
||
|
||
function connectRemote(opts) {
|
||
if (root.location.protocol === 'file:') { lobbyMsg('Open the game through the Netwall server to play online.', true); return; }
|
||
const name = ($('inName').value || store.get('nw.name', '') || '').trim().slice(0, 16) || 'Player';
|
||
store.set('nw.name', name);
|
||
if (app.ctrl && app.ctrl.kind === 'remote') app.ctrl.close();
|
||
lobbyMsg('Connecting…');
|
||
const rc = new NW.RemoteController({ pid: getPid(), name, room: opts.room, map: opts.map });
|
||
let first = true;
|
||
rc.on('joined', () => {
|
||
sess.set('nw.room', rc.room); store.set('nw.session', { pid: getPid(), room: rc.room, name, ts: Date.now() });
|
||
$('reconnect').hidden = true;
|
||
if (first) {
|
||
first = false;
|
||
useController(rc);
|
||
app.inGame = true; app.started = true; app.last = {}; app.endShown = false; app.prevPlayers = null;
|
||
resetSelection(); setScreen('playing'); showOverlay(null);
|
||
onPlayers(rc.players);
|
||
try { root.history.replaceState(null, '', root.location.pathname + '?room=' + rc.room); } catch (e) { /* ignore */ }
|
||
toast('Room ' + rc.room + (rc.players.length < 2 ? '. Send the invite link to your partner!' : ''), 'good');
|
||
Audio.music('battle'); requestWakeLock();
|
||
} else { toast('Reconnected', 'good'); adoptBoard(); }
|
||
lobbyMsg('');
|
||
});
|
||
rc.on('status', (s) => { if (app.ctrl === rc && app.inGame) $('reconnect').hidden = s !== 'reconnecting'; });
|
||
rc.on('fatal', (f) => {
|
||
sess.del('nw.room'); store.del('nw.session');
|
||
if (app.ctrl === rc && app.inGame) { toast(f.msg, 'bad'); leaveToMenu(); openLobby(); lobbyMsg(f.msg, true); }
|
||
else lobbyMsg(f.msg, true);
|
||
});
|
||
rc.connect();
|
||
}
|
||
|
||
function updateResumeButton() {
|
||
const s = store.get('nw.session', null), b = $('btnResume');
|
||
const fresh = s && s.room && Date.now() - s.ts < 15 * 60 * 1000 && !(app.ctrl && app.ctrl.kind === 'remote');
|
||
b.hidden = !fresh || root.location.protocol === 'file:';
|
||
if (fresh) b.textContent = 'Resume co-op game · room ' + s.room;
|
||
}
|
||
$('btnResume').addEventListener('click', () => {
|
||
const s = store.get('nw.session', null); if (!s) return;
|
||
sess.set('nw.pid', s.pid);
|
||
$('inName').value = s.name || '';
|
||
connectRemote({ room: s.room });
|
||
});
|
||
|
||
// ------------------------------------------------------------------ misc platform bits
|
||
let wakeLock = null;
|
||
function requestWakeLock() {
|
||
try { if (navigator.wakeLock && !wakeLock) navigator.wakeLock.request('screen').then((l) => { wakeLock = l; l.addEventListener('release', () => { wakeLock = null; }); }).catch(() => {}); } catch (e) { /* ignore */ }
|
||
}
|
||
document.addEventListener('visibilitychange', () => { if (!document.hidden && app.inGame) requestWakeLock(); });
|
||
|
||
// ------------------------------------------------------------------ app layout (the JS half of the layout modes in style.css)
|
||
const mq = (q) => (root.matchMedia ? root.matchMedia(q) : { matches: false, addEventListener() {} });
|
||
const mqStacked = mq('(orientation: portrait), (max-width: 760px) and (min-height: 521px)');
|
||
const mqCompact = mq('(pointer: coarse), (orientation: portrait), (max-width: 760px) and (min-height: 521px), (orientation: landscape) and (max-height: 520px)');
|
||
// Stacked (portrait / narrow) layout: the stage hugs the board, so there is no dead band above and below it and the side panel gets
|
||
// everything else. The board is drawn turned 90 degrees when that makes the cells clearly bigger (tall phones), otherwise upright
|
||
// and short (small phones: the freed height goes to the palette and info panel). Inputs are the viewport and top bar only (never
|
||
// the stage's own size), so this cannot feed back into the ResizeObserver.
|
||
function layoutApp() {
|
||
const a = $('app'), b = app.ctrl && app.ctrl.board;
|
||
a.dataset.ui = mqCompact.matches ? 'compact' : 'wide';
|
||
if (!mqStacked.matches || !b) { a.style.removeProperty('--stage-h'); app.rotate = null; return; }
|
||
const cs = root.getComputedStyle(a);
|
||
const W = a.clientWidth - (parseFloat(cs.paddingLeft) || 0) - (parseFloat(cs.paddingRight) || 0);
|
||
const H = a.clientHeight - (parseFloat(cs.paddingTop) || 0) - (parseFloat(cs.paddingBottom) || 0) - $('topbar').offsetHeight;
|
||
const mg = (NW.BOARD_MARGIN || 0) * 2, dw = b.cols * NW.CELL + mg, dh = b.rows * NW.CELL + mg, pad = 8;
|
||
const minSide = clamp(Math.round(H * 0.25), 140, 210); // room for the palette row and a window onto the info panel
|
||
const maxStage = Math.max(120, H - minSide);
|
||
const sU = Math.min((W - pad) / dw, (maxStage - pad) / dh), sR = Math.min((W - pad) / dh, (maxStage - pad) / dw);
|
||
const rot = sR > sU * 1.08;
|
||
const bh = rot ? dw : dh, bw = rot ? dh : dw;
|
||
const stageH = Math.round(Math.min(maxStage, Math.ceil(bh * ((W - pad) / bw) + pad)));
|
||
app.rotate = rot;
|
||
if (a.style.getPropertyValue('--stage-h') !== stageH + 'px') a.style.setProperty('--stage-h', stageH + 'px');
|
||
}
|
||
function resizeCanvas() {
|
||
layoutApp();
|
||
const st = $('stage'), r = st.getBoundingClientRect();
|
||
renderer.setRotation(app.rotate !== null && app.rotate !== undefined ? app.rotate : r.height > r.width * 1.05); // portrait: board turned 90 degrees (bigger cells)
|
||
const dpr = Math.min(root.devicePixelRatio || 1, root.matchMedia && root.matchMedia('(pointer: coarse)').matches ? 2 : 2.5);
|
||
renderer.resize(r.width, r.height, dpr);
|
||
updatePaletteHint(); layoutBars(true); updateFit(); // (a rotation or board swap resets the camera: hide a stale Reset-zoom button)
|
||
}
|
||
let resizeRaf = 0;
|
||
function scheduleResize() { if (!resizeRaf) resizeRaf = root.requestAnimationFrame(() => { resizeRaf = 0; resizeCanvas(); }); } // (a frame later: never resize inside the observer callback)
|
||
if (root.ResizeObserver) { const ro = new ResizeObserver(scheduleResize); ro.observe($('stage')); ro.observe($('topbar')); ro.observe($('palette')); }
|
||
root.addEventListener('resize', scheduleResize);
|
||
mqStacked.addEventListener && mqStacked.addEventListener('change', scheduleResize);
|
||
mqCompact.addEventListener && mqCompact.addEventListener('change', scheduleResize);
|
||
root.addEventListener('orientationchange', () => setTimeout(() => { resizeCanvas(); drawPaletteIcons(); }, 250));
|
||
// keep the page from scrolling/bouncing or zooming on iOS
|
||
document.addEventListener('gesturestart', (e) => e.preventDefault());
|
||
document.addEventListener('touchmove', (e) => { if (e.target === canvas || e.target.closest('#stage')) e.preventDefault(); }, { passive: false });
|
||
|
||
// ------------------------------------------------------------------ main loop
|
||
function frame(now) {
|
||
root.requestAnimationFrame(frame);
|
||
const ctrl = app.ctrl; if (!ctrl) return;
|
||
ctrl.update(now);
|
||
const view = ctrl.view;
|
||
if (app.inGame) {
|
||
if (app.last.state !== view.state) {
|
||
app.last.state = view.state;
|
||
if (view.state === 'won' || view.state === 'lost') { if (!app.endShown) { app.endShown = true; endScreen(view); } }
|
||
else if (app.endShown) { app.endShown = false; $('end').hidden = true; }
|
||
}
|
||
if (app.selTower && !view.towers.some((t) => t.id === app.selTower)) { app.selTower = 0; renderInfo(true); }
|
||
if (app.pending && pendFree) { // the partner built on the cell being previewed: drop it and say so (coop-7)
|
||
const t = towerAtCell(app.pending);
|
||
if (t) { setPending(null); toast(((ui.names && ui.names[t.owner]) || 'Someone') + ' just built there', 'bad'); }
|
||
}
|
||
if (app.last.rev !== view.rev) { app.last.rev = view.rev; app.previewDirty = true; if (app.selTower) renderInfo(false); }
|
||
updateHud(view);
|
||
layoutBars(false);
|
||
if (now - app.lastBossCheck > 600 && view.state === 'playing') {
|
||
app.lastBossCheck = now;
|
||
const boss = view.monsters.some((m) => m.kind === 'rootkit');
|
||
if (boss !== app.bossMusic) { app.bossMusic = boss; if (!app.endShown) Audio.music(boss ? 'boss' : 'battle'); }
|
||
}
|
||
}
|
||
ui.hover = app.pending || app.hover; ui.selType = app.selType; ui.selTower = app.selTower;
|
||
// hovering an existing tower while a build type is active: a click selects it, so show no ghost
|
||
ui.noGhost = !!(ui.hover && app.selType && view.towers.some((t) => t.x === ui.hover.x && t.y === ui.hover.y));
|
||
refreshPreview(false);
|
||
renderer.frame(now, view, ui);
|
||
}
|
||
|
||
// ------------------------------------------------------------------ boot
|
||
function boot() {
|
||
buildPalette(); buildMapPicker();
|
||
{ const keys = TD.TOWER_ORDER.map((t) => TD.TOWERS[t].key); $('helpKeys').textContent = keys[0] + '\u2013' + keys[keys.length - 1]; }
|
||
previewMap(app.mapId);
|
||
setScreen('menu'); showOverlay('menu');
|
||
$('btnCloseMenu').hidden = true;
|
||
resizeCanvas(); drawPaletteIcons();
|
||
root.requestAnimationFrame(frame);
|
||
|
||
const q = new URLSearchParams(root.location.search), codeParam = (q.get('room') || '').toUpperCase();
|
||
const savedRoom = sess.get('nw.room');
|
||
if (savedRoom && /^[A-Z0-9]{4}$/.test(savedRoom) && root.location.protocol !== 'file:' && (!codeParam || codeParam === savedRoom)) {
|
||
// page reload in the same tab: slip straight back into the room
|
||
$('inName').value = store.get('nw.name', '') || '';
|
||
connectRemote({ room: savedRoom });
|
||
} else if (/^[A-Z0-9]{4}$/.test(codeParam)) {
|
||
openLobby(codeParam);
|
||
lobbyMsg('Enter your name and press Join.');
|
||
} else {
|
||
updateResumeButton();
|
||
Audio.music('theme');
|
||
}
|
||
// installable + offline-capable solo play (service workers need https or localhost)
|
||
if (root.navigator.serviceWorker && (root.location.protocol === 'https:' || /^(localhost|127\.0\.0\.1|\[::1\])$/.test(root.location.hostname))) {
|
||
root.navigator.serviceWorker.register('sw.js').catch(() => {});
|
||
}
|
||
}
|
||
if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', boot); else boot();
|
||
|
||
NW.app = app; // handy for debugging and automated tests
|
||
})(typeof self !== 'undefined' ? self : this);
|