Upstream/public/js/screens/pop.js
jvanvik b18645dca1 Phase 2: client military/social screens, WebSocket push, trade + endgame, review findings pending
Built: units/movements/reports/send/expansion screens, alliance/messages/rankings screens, ws client + server /ws push
(docs/PROTOCOL.md), Internet exchange trade, backbone endgame + world end, shared reports, buildDone relative levels.
Tested: npm test 175/175. Two adversarial reviews found issues (trade-leg recall exploit, __proto__ via validate.js,
rankings DoS, static headers, ...): fixes follow in the next commit.
NOT done: bots/balance, e2e suite, real-device checks.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
2026-10-11 19:05:03 +02:00

497 lines
25 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters

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

'use strict';
/*
* POP screen: header, build queue, power, resource fields (grouped by type), infrastructure; tap a building for
* the detail sheet. All numbers come from GET /towns/:id (the server's "next" plan decides what is buildable); the
* client only ticks values forward with rules.js and re-checks affordability live, so a button wakes up the moment
* the resources are there. Countdowns come from the server clock (App.now()).
*/
(function () {
const { h, clear, icon, toast, openSheet, closeSheet } = UI;
const R = UpstreamRules;
const D = UpstreamData;
const F = D.FORMULAS;
let box = null, dirty = true, visible = false;
let refs = { tiles: new Map(), rows: new Map(), queue: [] };
let offTick = null;
let prevQueue = null;
const refetchTries = new Map(); // queue event id -> refetch attempts after it came due
let sheetCtl = null;
const td = () => App.state.townData;
const find = (key) => (td() ? td().buildings.find((b) => b.key === key) : null);
const resOf = (type) => D.FIELD_PRODUCES[type] || null;
// ------------------------------------------------------------------ building state (live)
// 'queued' | 'ready' | 'locked' | 'max' | 'wait'. `code` is the reason it cannot be built now (null = can).
function stateOf(b, cur) {
const t = td();
if (t.queue.some((q) => q.key === b.key)) return { st: 'queued', code: 'already_queued' };
if (b.level >= b.maxLevel) return { st: 'max', code: 'max_level' };
const n = b.next;
let code = n.code;
if (code === 'not_enough_resources' && cur && n.cost) {
let ok = true;
for (const r of D.RESOURCES) if (cur.amounts[r] + 1e-6 < n.cost[r]) ok = false;
if (ok) code = null;
}
if (code === null) return { st: 'ready', code: null };
if (code === 'requirements_not_met') return { st: 'locked', code };
return { st: 'wait', code };
}
// How long until the resources for `cost` are there (ms), or null if never (rate 0) / Infinity if above the storage cap.
function etaFor(cost, cur) {
let worst = 0;
for (const r of D.RESOURCES) {
const need = cost[r] - cur.amounts[r];
if (need <= 0) continue;
if (cost[r] > cur.caps[r]) return Infinity;
const rate = cur.rates[r];
if (rate <= 0) return null;
worst = Math.max(worst, need / rate * D.HOUR_MS);
}
return worst;
}
// ------------------------------------------------------------------ pieces
function costChips(cost, cur, withHave) {
return h('div', { class: 'costs' }, D.RESOURCES.map((r) => {
const short = cur && cur.amounts[r] + 1e-6 < cost[r];
return h('span', { class: 'cost ' + r + (short ? ' short' : ''), dataset: { res: r } }, icon(r),
h('b', { text: App.fmt.num(cost[r]) }),
withHave && cur ? h('small', { text: App.t('sheet.have', { n: App.fmt.num(cur.amounts[r]) }) }) : null);
}));
}
const fmt2 = (x) => x.toFixed(2).replace('.', App.state.lang === 'nb' ? ',' : '.');
function levelPreview(b, toLevel) {
// [{ text }] lines describing what the next level changes, from rules.js.
const t = td(), rt = App.rulesTown(), world = App.state.world;
const lines = [];
const fmt = App.fmt;
const withLevel = (lvl) => {
const bb = Object.assign({}, rt.buildings);
bb[b.key] = { type: b.type, level: lvl };
return Object.assign({}, rt, { buildings: bb });
};
if (b.kind === 'field') {
const res = resOf(b.type);
const mult = res === 'power' ? 1 : (world.speed || 1) * (1 + ((t.bonus && t.bonus[res]) || 0));
const a = R.fieldOutputPerHour(b.level) * mult, c = R.fieldOutputPerHour(toLevel) * mult;
lines.push(App.t('sheet.preview.output', { a: fmt.dec(a), b: fmt.dec(c) }) + ' ' + App.resName(res));
} else if (b.type === 'rack_hall') {
lines.push(App.t('sheet.preview.storage', { a: fmt.num(R.storageCap(withLevel(b.level))), b: fmt.num(R.storageCap(withLevel(toLevel))) }));
} else if (b.type === 'battery_bank') {
lines.push(App.t('sheet.preview.battery', { a: fmt.num(R.batteryCap(withLevel(b.level))), b: fmt.num(R.batteryCap(withLevel(toLevel))) }));
} else if (b.type === 'core_router') {
const k = (l) => fmt2(1 / (1 + F.coreSpeedPerLevel * l));
lines.push(App.t('sheet.preview.core', { a: k(b.level), b: k(toLevel) }));
if (toLevel === F.secondQueueCoreLevel) lines.push(App.t('sheet.preview.core2', { n: toLevel }));
} else if (b.type === 'firewall') {
lines.push(App.t('sheet.preview.firewall', { a: fmt2(1 + F.firewallPerLevel * b.level), b: fmt2(1 + F.firewallPerLevel * toLevel) }));
}
const def = D.BUILDINGS[b.type];
if (def && def.draw > 0) lines.push(App.t('sheet.preview.draw', { n: def.draw }));
return lines;
}
function requirementList(b) {
const def = D.BUILDINGS[b.type];
const levels = {};
for (const x of td().buildings) if (x.kind === 'infra') levels[x.type] = x.level;
return (def.requires || []).map((rq) => {
const have = levels[rq.type] || 0, ok = have >= rq.level;
return h('li', { class: ok ? 'ok' : 'miss' }, icon(ok ? 'check' : 'lock'),
h('span', { text: App.buildingName(rq.type) + ' ' + App.t('pop.level', { n: rq.level }) }),
h('small', { text: App.t('sheet.have', { n: have }) }));
});
}
// ------------------------------------------------------------------ detail sheet
function openBuilding(key, opts) {
const first = find(key);
if (!first) return;
const R_ = { cur: null };
const body = h('div', { class: 'detail' });
const ctl = openSheet({
title: App.buildingName(first.type), icon: 'b-' + first.type, iconClass: first.kind === 'field' ? 'res-' + resOf(first.type) : '',
closeLabel: App.t('common.close'), body,
onClose: () => { if (offSheetTick) offSheetTick(); offSheetTick = null; sheetCtl = null; },
});
sheetCtl = ctl;
let offSheetTick = null;
const els = {};
function build() {
for (const k of Object.keys(els)) delete els[k];
const b = find(key);
if (!b) { ctl.close(); return; }
const cur = App.resourcesNow();
clear(body);
body.appendChild(h('p', { class: 'detail-desc', text: App.buildingDesc(b.type) }));
body.appendChild(h('div', { class: 'detail-level' },
h('span', { class: 'lvl-now', text: b.level > 0 ? App.t('sheet.level', { n: b.level }) : App.t('pop.notBuilt') }),
b.level < b.maxLevel ? h('span', { class: 'lvl-next' }, icon('up'), App.t('sheet.nextLevel', { n: b.level + 1 })) : h('span', { class: 'lvl-next', text: App.t('sheet.maxed') })));
const queued = td().queue.find((q) => q.key === key);
if (queued) {
els.qbar = h('i');
els.qtime = h('b', { class: 'mono' });
body.appendChild(h('div', { class: 'detail-queue' },
h('div', { class: 'row' }, h('span', { text: App.t('sheet.underway') + ' · ' + App.t('pop.queue.to', { n: queued.toLevel }) }), els.qtime),
h('div', { class: 'bar' }, els.qbar)));
els.cancel = h('button', { class: 'btn danger wide', type: 'button', onclick: () => confirmCancel(queued) }, icon('x'), App.t('sheet.cancel'));
body.appendChild(els.cancel);
updateQueueEls(queued, App.now());
return;
}
if (b.level >= b.maxLevel) return;
const to = b.level + 1;
const next = b.next;
for (const text of levelPreview(b, to)) body.appendChild(h('p', { class: 'preview', text }));
els.costs = costChips(next.cost, cur, true);
body.appendChild(h('h3', { class: 'sub', text: App.t('sheet.cost') }));
body.appendChild(els.costs);
body.appendChild(h('div', { class: 'row meta' }, icon('clock'), h('span', { text: App.t('sheet.time') + ': ' }), h('b', { text: App.fmt.dur(next.durationMs) })));
const reqs = requirementList(b);
if (reqs.length) { body.appendChild(h('h3', { class: 'sub', text: App.t('sheet.requires') })); body.appendChild(h('ul', { class: 'reqs' }, reqs)); }
els.reason = h('p', { class: 'reason', 'aria-live': 'polite' });
els.btn = h('button', { class: 'btn primary wide', type: 'button', onclick: () => doBuild(b.key) }, icon('up'), h('span', { text: App.t(b.level > 0 ? 'sheet.upgrade' : 'sheet.build', { n: to }) }));
body.appendChild(els.reason);
body.appendChild(els.btn);
updateLive();
}
function updateQueueEls(q, now) {
const left = q.dueAt - now;
els.qtime.textContent = App.fmt.clock(left);
els.qbar.style.setProperty('--p', String(Math.max(0, Math.min(1, (now - q.startedAt) / Math.max(1, q.dueAt - q.startedAt)))));
}
let busy = false;
function updateLive() {
const b = find(key);
if (!b || !els.btn) return;
const cur = App.resourcesNow();
const s = stateOf(b, cur);
for (const chip of els.costs.children) chip.classList.toggle('short', cur.amounts[chip.dataset.res] + 1e-6 < b.next.cost[chip.dataset.res]);
const can = s.code === null && !busy;
els.btn.disabled = !can;
let reason = '';
if (s.code) {
reason = App.t('err.' + s.code);
if (s.code === 'not_enough_resources') {
const eta = etaFor(b.next.cost, cur);
if (eta === Infinity) reason = App.t('sheet.capTooLow', { cap: App.fmt.num(cur.caps.fiber) });
else if (eta !== null) reason = App.t('sheet.affordableIn', { t: App.fmt.dur(Math.max(1000, eta)) });
}
}
els.reason.textContent = reason;
els.reason.hidden = !reason;
}
async function doBuild(k) {
if (busy) return;
busy = true; els.btn.disabled = true;
els.btn.querySelector('span').textContent = App.t('sheet.building');
const t = td();
try {
const b = find(k);
await App.api.post('/towns/' + t.id + '/build', { key: k }, { intent: 'build:' + t.id + ':' + k });
toast(App.t('sheet.built', { name: App.buildingName(b.type), n: b.level + 1 }), 'ok');
ctl.close();
await App.refreshTown();
} catch (e) {
toast(App.errMsg(e), 'error');
busy = false;
try { await App.refreshTown(); } catch (e2) { /* shown by the offline chip */ }
if (sheetCtl === ctl) build();
}
}
function confirmCancel(q) {
clear(body);
const b = find(key);
body.appendChild(h('p', { class: 'detail-desc', text: App.t('sheet.cancel.confirm', { name: App.buildingName(b.type), n: q.toLevel }) }));
body.appendChild(h('p', { class: 'preview', text: App.t('sheet.cancel.refund') }));
body.appendChild(h('div', { class: 'btn-row' },
h('button', { class: 'btn', type: 'button', onclick: () => build() }, App.t('sheet.cancel.keep')),
h('button', { class: 'btn danger', type: 'button', onclick: async (ev) => {
ev.currentTarget.disabled = true;
try {
await App.api.del('/towns/' + td().id + '/queue/' + q.id);
toast(App.t('sheet.cancelled'), 'ok');
} catch (e) { toast(App.errMsg(e), 'error'); }
ctl.close();
App.refreshTown().catch(() => {});
} }, icon('x'), App.t('sheet.cancel'))));
}
offSheetTick = App.onTick((now) => {
const q = td() && td().queue.find((x) => x.key === key);
if (q && els.qtime) updateQueueEls(q, now); else if (els.btn) updateLive();
});
const offTown = App.on('town', () => { if (sheetCtl === ctl) build(); });
const prevClose = offSheetTick;
offSheetTick = () => { prevClose(); offTown(); };
build();
if (opts && opts.cancel) { const q = td().queue.find((x) => x.key === key); if (q) confirmCancel(q); }
}
// ------------------------------------------------------------------ main drawing
function tileLabel(b, s) {
const status = s.st === 'queued' ? App.t('pop.inQueue') : s.st === 'ready' ? App.t('pop.upgradeReady') : s.st === 'max' ? App.t('pop.max') : s.st === 'locked' ? App.t('pop.locked') : '';
return App.buildingName(b.type) + ', ' + (b.level > 0 ? App.t('pop.level', { n: b.level }) : App.t('pop.notBuilt')) + (status ? ', ' + status : '');
}
function fieldTile(b) {
const res = resOf(b.type);
const lvl = h('b', { class: 'tile-lvl', text: String(b.level) });
const badge = h('span', { class: 'tile-badge', 'aria-hidden': 'true' });
const bar = h('i');
const el = h('button', { class: 'tile res-' + res, type: 'button', dataset: { key: b.key }, onclick: () => openBuilding(b.key) },
icon('b-' + b.type, 'tile-ic'), lvl, badge, h('span', { class: 'tile-bar', 'aria-hidden': 'true' }, bar));
refs.tiles.set(b.key, { el, badge, bar, b });
return el;
}
function infraRow(b) {
const status = h('span', { class: 'pill' });
const sub = h('span', { class: 'row-sub' });
const bar = h('i');
const el = h('button', { class: 'row-btn', type: 'button', dataset: { key: b.key }, onclick: () => openBuilding(b.key) },
h('span', { class: 'row-ic' }, icon('b-' + b.type)),
h('span', { class: 'row-main' },
h('span', { class: 'row-title' }, h('b', { text: App.buildingName(b.type) }), h('span', { class: 'lv', text: b.level > 0 ? App.t('pop.level', { n: b.level }) : App.t('pop.notBuilt') })),
sub),
status, h('span', { class: 'tile-bar', 'aria-hidden': 'true' }, bar));
refs.rows.set(b.key, { el, status, sub, bar, b });
return el;
}
function header(t) {
const st = App.state;
const bonus = D.RESOURCES.filter((r) => (t.bonus && t.bonus[r] > 0)).map((r) => h('span', { class: 'pill res-' + r }, icon(r), '+' + Math.round(t.bonus[r] * 100) + '% ' + App.resName(r)));
const title = h('h1', { class: 'town-name', text: t.name }); // switching POPs lives in the resource bar (main.js)
return h('section', { class: 'card pop-head' },
h('div', { class: 'pop-title' }, title,
h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('pop.rename'), onclick: openRename }, icon('pencil'))),
h('div', { class: 'pop-meta' },
h('span', { text: App.t('pop.coords', { x: t.x, y: t.y }) }),
t.isCapital ? h('span', { class: 'pill accent', text: App.t('pop.capital') }) : null,
h('span', { class: 'pill' }, icon('shield'), App.t('pop.loyalty') + ' ' + App.fmt.num(t.loyalty)),
h('span', { class: 'pill', text: App.t('pop.footprint') + ' ' + App.fmt.num(t.footprint) + ' (' + App.t('pop.footprintPerDay', { n: App.fmt.num(t.footprintPerDay) }) + ')' }),
bonus.length ? bonus : h('span', { class: 'pill dim', text: App.t('pop.bonus.none') })));
}
function openRename() {
const t = td();
const input = h('input', { type: 'text', value: t.name, maxlength: '40', minlength: '2', 'aria-label': App.t('pop.rename.label'), autocomplete: 'off', enterkeyhint: 'done' });
const err = h('p', { class: 'form-error', role: 'alert', hidden: true });
const save = h('button', { class: 'btn primary wide', type: 'submit' }, icon('check'), App.t('common.save'));
const form = h('form', { class: 'detail', onsubmit: async (ev) => {
ev.preventDefault();
const name = input.value.trim();
if (name.length < 2) { err.textContent = App.t('err.validation_failed'); err.hidden = false; return; }
save.disabled = true;
try {
const r = await App.api.post('/towns/' + t.id + '/rename', { name });
const known = App.state.towns.find((x) => x.id === t.id);
if (known) known.name = r.name;
toast(App.t('pop.rename.done'), 'ok');
sheet.close();
await App.refreshTown();
} catch (e) { err.textContent = App.errMsg(e); err.hidden = false; save.disabled = false; }
} }, h('label', { class: 'field' }, h('span', { class: 'field-lbl', text: App.t('pop.rename.label') }), input), err, save);
const sheet = openSheet({ title: App.t('pop.rename'), icon: 'pencil', closeLabel: App.t('common.close'), body: form });
setTimeout(() => { input.focus(); input.select(); }, 60);
}
function queueCard(t) {
refs.queue = [];
const slots = h('span', { class: 'pill', text: App.t('pop.queue.slots', { used: t.queue.length, total: t.queueSlots }) });
const list = h('div', { class: 'queue' });
for (const q of t.queue) {
const time = h('b', { class: 'mono' }), bar = h('i');
const name = App.buildingName(q.type);
list.appendChild(h('div', { class: 'q-item' },
h('button', { class: 'q-main', type: 'button', onclick: () => openBuilding(q.key), 'aria-label': name + ' ' + App.t('pop.queue.to', { n: q.toLevel }) },
h('span', { class: 'row-ic' }, icon('b-' + q.type)),
h('span', { class: 'row-main' }, h('span', { class: 'row-title' }, h('b', { text: name }), h('span', { class: 'lv', text: App.t('pop.queue.to', { n: q.toLevel }) })),
h('span', { class: 'bar' }, bar)),
time),
h('button', { class: 'icon-btn', type: 'button', 'aria-label': App.t('pop.queue.cancel') + ': ' + name, onclick: () => openBuilding(q.key, { cancel: true }) }, icon('x'))));
refs.queue.push({ q, time, bar });
}
if (!t.queue.length) list.appendChild(h('p', { class: 'empty', text: App.t('pop.queue.empty') }));
return h('section', { class: 'card' }, h('div', { class: 'card-head' }, h('h2', { text: App.t('pop.queue.title') }), slots), list);
}
function powerCard() {
refs.power = { out: h('b'), draw: h('b'), net: h('b'), buf: h('span', { class: 'mono' }), bar: h('i'), status: h('p', { class: 'power-status' }) };
const p = refs.power;
return h('section', { class: 'card power-card' },
h('div', { class: 'card-head' }, h('h2', null, icon('power'), App.t('power.title'))),
h('div', { class: 'stat-row' },
h('div', { class: 'stat' }, h('small', { text: App.t('power.out') }), p.out),
h('div', { class: 'stat' }, h('small', { text: App.t('power.draw') }), p.draw),
h('div', { class: 'stat' }, h('small', { text: App.t('power.net') }), p.net)),
h('div', { class: 'row' }, h('span', { class: 'dimmer', text: App.t('power.buffer') }), p.buf),
h('div', { class: 'bar power-bar', 'aria-hidden': 'true' }, p.bar), p.status);
}
function fieldsCard(t) {
const fields = t.buildings.filter((b) => b.kind === 'field');
const world = App.state.world;
const groups = h('div', { class: 'groups' });
for (const type of D.FIELD_TYPES) {
const list = fields.filter((b) => b.type === type);
if (!list.length) continue;
const res = resOf(type);
const mult = res === 'power' ? 1 : (world.speed || 1) * (1 + ((t.bonus && t.bonus[res]) || 0));
const total = list.reduce((s, b) => s + R.fieldOutputPerHour(b.level) * mult, 0);
groups.appendChild(h('div', { class: 'group res-' + res },
h('div', { class: 'group-head' }, icon(res), h('b', { text: App.buildingName(type) }), h('span', { class: 'dimmer', text: '×' + list.length }),
h('span', { class: 'group-rate', text: App.fmt.dec(total, true) + ' ' + App.resName(res) + App.t('common.perHour') })),
h('div', { class: 'tiles' }, list.map(fieldTile))));
}
return h('section', { class: 'card' }, h('div', { class: 'card-head' }, h('h2', { text: App.t('pop.fields.title') })), groups);
}
function infraCard(t) {
const list = t.buildings.filter((b) => b.kind === 'infra');
return h('section', { class: 'card' }, h('div', { class: 'card-head' }, h('h2', { text: App.t('pop.infra.title') })), h('div', { class: 'rows' }, list.map(infraRow)));
}
function draw() {
dirty = false;
refs = { tiles: new Map(), rows: new Map(), queue: [] };
clear(box);
const t = td();
if (!App.state.townId) { box.appendChild(h('p', { class: 'empty pad', text: App.t('pop.noTown') })); return; }
if (!t) { box.appendChild(h('div', { class: 'boot' }, h('div', { class: 'spinner', 'aria-hidden': 'true' }), h('p', { text: App.t('common.loading') }))); return; }
// other screens add cards here through App.popSections (military: incoming banner on top, expansion below the power card)
const extra = (slot) => (App.popSections || []).filter((s) => s.slot === slot).map((s) => { try { return s.render(t); } catch (e) { console.error(e); return null; } });
const tops = extra('top');
if (tops.some(Boolean)) box.appendChild(h('div', { class: 'pop-top' }, tops));
box.appendChild(h('div', { class: 'cols' },
h('div', { class: 'col' }, header(t), queueCard(t), powerCard(), extra('main')),
h('div', { class: 'col' }, fieldsCard(t), infraCard(t))));
tick(App.now());
}
// ------------------------------------------------------------------ ticking
function tick(now) {
const t = td();
if (!t || !refs.power) return;
const cur = App.resourcesNow(now);
const f = App.fmt;
// queue countdowns + the refetch when something comes due
for (const e of refs.queue) {
const q = e.q, left = q.dueAt - now;
const time = f.clock(left);
if (e.time.textContent !== time) e.time.textContent = time;
e.bar.style.setProperty('--p', String(Math.max(0, Math.min(1, (now - q.startedAt) / Math.max(1, q.dueAt - q.startedAt)))));
if (left <= -300) {
const tries = refetchTries.get(q.id) || { n: 0, at: 0 };
if (Date.now() >= tries.at) {
refetchTries.set(q.id, { n: tries.n + 1, at: Date.now() + Math.min(10000, 1500 * (tries.n + 1)) });
App.refreshTown().catch(() => {});
}
}
}
// tiles and rows
const queueByKey = new Map(t.queue.map((q) => [q.key, q]));
for (const [key, e] of refs.tiles) {
const s = stateOf(e.b, cur);
if (e.el.dataset.st !== s.st) {
e.el.dataset.st = s.st;
e.badge.textContent = '';
if (s.st === 'queued') e.badge.appendChild(icon('clock'));
else if (s.st === 'ready') e.badge.appendChild(icon('up'));
else if (s.st === 'locked') e.badge.appendChild(icon('lock'));
e.el.setAttribute('aria-label', tileLabel(e.b, s));
}
const q = queueByKey.get(key);
e.bar.style.setProperty('--p', q ? String(Math.max(0, Math.min(1, (now - q.startedAt) / Math.max(1, q.dueAt - q.startedAt)))) : '0');
}
for (const [key, e] of refs.rows) {
const s = stateOf(e.b, cur);
const q = queueByKey.get(key);
let pill = '', pillCls = 'pill', sub = '';
if (s.st === 'queued') { pill = f.clock(q.dueAt - now); pillCls += ' amber mono'; sub = App.buildingDesc(e.b.type); }
else if (s.st === 'ready') { pill = App.t(e.b.level > 0 ? 'pop.upgradeReady' : 'sheet.build', { n: e.b.level + 1 }); pillCls += ' green'; sub = App.buildingDesc(e.b.type); }
else if (s.st === 'max') { pill = App.t('pop.max'); sub = App.buildingDesc(e.b.type); }
else if (s.st === 'locked') {
const m = (e.b.next.missing || [])[0];
pill = m ? App.buildingName(m.type) + ' ' + App.t('pop.level', { n: m.level }) : App.t('pop.locked'); pillCls += ' dim';
sub = App.buildingDesc(e.b.type);
} else sub = App.buildingDesc(e.b.type);
if (e.status.textContent !== pill) e.status.textContent = pill;
e.status.className = pillCls;
e.status.hidden = !pill;
if (e.sub.textContent !== sub) e.sub.textContent = sub;
e.el.dataset.st = s.st;
e.bar.style.setProperty('--p', q ? String(Math.max(0, Math.min(1, (now - q.startedAt) / Math.max(1, q.dueAt - q.startedAt)))) : '0');
}
// power
const p = refs.power, net = cur.rates.powerNet, buf = cur.amounts.battery, bcap = cur.caps.battery;
p.out.textContent = f.dec(cur.rates.powerOut);
p.draw.textContent = f.dec(cur.rates.powerDraw);
p.net.textContent = f.dec(net, true);
p.net.className = net < 0 ? 'bad' : 'good';
p.buf.textContent = f.num(buf) + ' / ' + f.num(bcap) + ' ' + App.t('power.unit');
p.bar.style.setProperty('--p', String(bcap > 0 ? Math.min(1, buf / bcap) : 0));
const speed = App.state.world.speed || 1;
let status, cls = '';
if (net < 0) {
if (buf <= 0) { status = App.t('power.empty'); cls = 'bad'; }
else { status = App.t('power.draining', { t: f.dur(buf / (-net * speed) * D.HOUR_MS) }); cls = 'warn'; }
} else if (net > 0 && buf < bcap - 0.01) status = App.t('power.charging', { t: f.dur((bcap - buf) / (net * speed) * D.HOUR_MS) });
else status = buf >= bcap - 0.01 && bcap > 0 ? App.t('power.full') : App.t('power.ok');
if (p.status.textContent !== status) p.status.textContent = status;
p.status.className = 'power-status ' + cls;
}
// ------------------------------------------------------------------ town changed
function onTown(t) {
// toast for levels that finished since the last fetch
if (prevQueue && prevQueue.townId === t.id) {
const nowIds = new Set(t.queue.map((q) => q.id));
for (const q of prevQueue.items) {
if (nowIds.has(q.id)) continue;
const b = t.buildings.find((x) => x.key === q.key);
if (b && b.level >= q.toLevel) toast(App.t('alerts.build_done', { name: App.buildingName(q.type), level: b.level }), 'ok');
refetchTries.delete(q.id);
App.checkAlerts();
}
}
prevQueue = { townId: t.id, items: t.queue.slice() };
if (visible) draw(); else dirty = true;
}
App.registerScreen({
id: 'pop', titleKey: 'screen.pop', navKey: 'nav.pop', icon: 'pop', hud: true,
render(container) {
box = container;
App.on('town', onTown);
App.on('session', () => { dirty = true; prevQueue = null; });
App.on('townchange', () => { dirty = true; if (visible) draw(); });
App.on('towns', () => { dirty = true; if (visible) draw(); });
},
onShow() {
visible = true;
draw();
if (offTick) offTick();
offTick = App.onTick(tick);
if (td() && Date.now() - App.state.townFetchedAt > 15000) App.refreshTown().catch(() => {});
},
onHide() { visible = false; if (offTick) offTick(); offTick = null; closeSheet(); },
});
}());