Built: - Client: trade screen, world/end-game screen (landing sites, shipping, node build, final ranking), report sharing + alliance reports tab, alert describers for all notification types, error-code strings (en+nb) for every server CODE. - tools/bot.js (+ tools/bot/): 50 headless bots against the real server in-process with a fake clock; resource/unit conservation ledger, exit 1 on broken invariants. docs/BALANCE.md has method and every run behind a number. - Balance changes (evidence in docs/BALANCE.md): secondQueueCoreLevel 10 -> 3, TRANSPORT.capacityPerLink 500 -> 1000 (end game was shipping-limited in bot runs). - Server fixes: POST /reports/:id/share 500 without a pending reportCleanup; bounced link shipments were silent about cargo overflow. Tested: npm test 207/207 (new: bot determinism + invariants, client alerts/world/i18n over CODES, two regression tests that failed before their fix); openapi check up to date. Real-browser scratch runs (not in repo): WebSocket push shows an incoming-attack banner ~214 ms after launch, polling fallback ~52 s, 15 scripted flows, 71 screenshots. NOT tested: Playwright suite (e2e/ still empty), real devices/Safari, nginx proxy websockets, throttled networks, HTTP-level bot load. NOT claimed: balance. Bots are not humans; open balance items (loot waste, escrow refund clipping, no garrisons at landing sites, end game not scaling with world speed) are listed in docs/BALANCE.md. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
175 lines
8.6 KiB
JavaScript
175 lines
8.6 KiB
JavaScript
'use strict';
|
|
/*
|
|
* WebSocket push client (docs/PROTOCOL.md). Push is only a HINT: the game is fully playable with the socket down, so
|
|
* every failure here is silent (no toasts, no thrown errors) and a slow REST poll runs as the fallback.
|
|
*
|
|
* connect to ws(s)://<same origin>/ws; first message {"type":"auth","token":"..."}; server answers {"type":"ready","serverTime"}
|
|
* server pushes {"type":"town","townId"} {"type":"incoming","townId","arriveAt"} {"type":"notification","id","kind"}
|
|
* {"type":"report","id"} {"type":"message","id"}
|
|
* client pings {"type":"ping"} every ~25 s and expects {"type":"pong"} within a few seconds, else it reconnects
|
|
* reconnect: exponential backoff from 1 s to 60 s with jitter, reset by a successful "ready"
|
|
*
|
|
* createSocketClient() is pure plumbing with everything injected (WebSocket constructor, timers, token), so
|
|
* test/client-ws.test.js can drive it. The browser wiring (bind) feeds pushes into api.emit('push', msg) and refetches
|
|
* the affected screens. The token is never logged and never put in the URL.
|
|
*/
|
|
(function (root, factory) {
|
|
if (typeof module === 'object' && module.exports) module.exports = factory(require('./milcore.js'));
|
|
else root.UpstreamWs = factory(root.UpstreamMil);
|
|
}(typeof self !== 'undefined' ? self : this, function (Mil) {
|
|
function createSocketClient(o) {
|
|
const WS = o.WebSocket;
|
|
const setT = o.setTimeout || setTimeout, clearT = o.clearTimeout || clearTimeout;
|
|
const pingMs = o.pingMs || 25000, pongMs = o.pongTimeoutMs || 8000;
|
|
const rnd = o.random || Math.random;
|
|
let sock = null, state = 'idle', attempt = 0, wanted = false, hadReady = false;
|
|
let retryTimer = null, pingTimer = null, pongTimer = null;
|
|
|
|
function setState(s) { if (s !== state) { state = s; if (o.onState) o.onState(s); } }
|
|
function clearTimers() { clearT(retryTimer); clearT(pingTimer); clearT(pongTimer); retryTimer = pingTimer = pongTimer = null; }
|
|
|
|
function schedule(minWait) {
|
|
if (!wanted || retryTimer) return;
|
|
const wait = Math.max(minWait || 0, Mil.backoffMs(attempt, rnd()));
|
|
attempt++;
|
|
retryTimer = setT(() => { retryTimer = null; connect(); }, wait);
|
|
}
|
|
|
|
function startPing() {
|
|
clearT(pingTimer);
|
|
pingTimer = setT(() => {
|
|
if (!sock || state !== 'open') return;
|
|
try { sock.send('{"type":"ping"}'); } catch (e) { drop(); return; }
|
|
clearT(pongTimer);
|
|
pongTimer = setT(() => drop(), pongMs); // no pong: the connection is dead although nobody told us
|
|
startPing();
|
|
}, pingMs);
|
|
}
|
|
|
|
function drop(minWait) {
|
|
const s = sock;
|
|
sock = null;
|
|
clearT(pingTimer); clearT(pongTimer); pingTimer = pongTimer = null;
|
|
if (s) { try { s.onopen = s.onmessage = s.onclose = s.onerror = null; s.close(); } catch (e) { /* already gone */ } }
|
|
setState(wanted ? 'closed' : 'idle');
|
|
schedule(minWait);
|
|
}
|
|
|
|
// Close codes of docs/PROTOCOL.md: 4401 (token refused), 4400 and 1009 (a client bug) must not be retried in a loop;
|
|
// 4429 (rate limited) waits at least 30 s; everything else is a plain reconnect.
|
|
function onClosed(ev) {
|
|
const code = ev && ev.code;
|
|
if (code === 4401 || code === 4400 || code === 1009) {
|
|
wanted = false; clearTimers(); sock = null; setState('idle');
|
|
if (o.onFatal) o.onFatal(code);
|
|
return;
|
|
}
|
|
drop(code === 4429 ? 30000 : 0);
|
|
}
|
|
|
|
function connect() {
|
|
if (!wanted || sock) return;
|
|
const token = o.token();
|
|
if (!token || !WS) return;
|
|
let s;
|
|
try { s = new WS(o.url()); } catch (e) { setState('closed'); schedule(); return; }
|
|
sock = s;
|
|
setState('connecting');
|
|
s.onopen = () => { try { s.send(JSON.stringify({ type: 'auth', token })); } catch (e) { drop(); } };
|
|
s.onmessage = (ev) => {
|
|
let msg = null;
|
|
try { msg = JSON.parse(ev.data); } catch (e) { return; }
|
|
if (!msg || typeof msg.type !== 'string') return;
|
|
if (msg.type === 'ready') { attempt = 0; const again = hadReady; hadReady = true; setState('open'); startPing(); if (o.onReady) o.onReady(msg, again); return; }
|
|
if (msg.type === 'pong') { clearT(pongTimer); pongTimer = null; return; }
|
|
if (o.onMessage) o.onMessage(msg);
|
|
};
|
|
s.onclose = (ev) => { if (sock === s) onClosed(ev); };
|
|
s.onerror = () => { /* the close event follows; stay quiet */ };
|
|
}
|
|
|
|
return {
|
|
start() { if (wanted) return; wanted = true; attempt = 0; hadReady = false; connect(); },
|
|
stop() { wanted = false; clearTimers(); const s = sock; sock = null; if (s) { try { s.onopen = s.onmessage = s.onclose = s.onerror = null; s.close(); } catch (e) { /* ignore */ } } setState('idle'); },
|
|
// Try now (back online, tab visible again): skips the backoff wait.
|
|
kick() { if (!wanted || sock) return; clearT(retryTimer); retryTimer = null; attempt = 0; connect(); },
|
|
get state() { return state; },
|
|
get open() { return state === 'open'; },
|
|
get attempts() { return attempt; },
|
|
};
|
|
}
|
|
|
|
// ------------------------------------------------------------------ browser wiring
|
|
function bind(App, UI, windowRef) {
|
|
const api = App.api;
|
|
const wsUrl = () => (windowRef.location.protocol === 'https:' ? 'wss://' : 'ws://') + windowRef.location.host + '/ws';
|
|
const client = createSocketClient({
|
|
WebSocket: windowRef.WebSocket,
|
|
url: wsUrl,
|
|
token: () => api.getToken(),
|
|
onMessage: (msg) => api.emit('push', msg),
|
|
// after every ready that follows a gap, refetch what is on screen (PROTOCOL.md): hints sent while we were away are lost
|
|
onReady: (msg, again) => { poll(true); if (again && App.state.user) { App.refreshTown().catch(() => {}); App.refreshTowns().catch(() => {}); } },
|
|
onFatal: () => { /* token refused or a client bug: stay quiet, the REST layer reports a dead token itself */ },
|
|
});
|
|
App.ws = client;
|
|
|
|
const timers = {};
|
|
function debounce(key, fn, ms) { clearTimeout(timers[key]); timers[key] = setTimeout(fn, ms); }
|
|
|
|
// ---- what a push means for the screens (everything is a refetch over REST)
|
|
api.on('push', (msg) => {
|
|
if (!App.state.user) return;
|
|
switch (msg.type) {
|
|
case 'town':
|
|
if (msg.townId === App.state.townId) debounce('town', () => App.refreshTown().catch(() => {}), 250);
|
|
break;
|
|
case 'incoming':
|
|
debounce('moves', () => App.refreshMovements().catch(() => {}), 150);
|
|
UI.toast(App.t('push.incoming'), 'error');
|
|
break;
|
|
case 'report':
|
|
App.refreshReportsUnread().catch(() => {});
|
|
debounce('towns', () => App.refreshTowns().catch(() => {}), 500); // a settle / takeover report changes the POP list
|
|
debounce('moves', () => App.refreshMovements().catch(() => {}), 300); // the movement that made the report is over: the incoming banner must go
|
|
App.emit('report', msg);
|
|
break;
|
|
case 'notification':
|
|
App.checkAlerts();
|
|
if (msg.kind === 'town_gained' || msg.kind === 'town_lost') App.refreshTowns().catch(() => {});
|
|
if (/^(train_done|research_done|movement_returned|reinforcements_sent_home|units_offline|units_decommissioned|transport_arrived|town_gained|town_lost)$/.test(msg.kind || '')) {
|
|
debounce('town', () => App.refreshTown().catch(() => {}), 400);
|
|
debounce('moves', () => App.refreshMovements().catch(() => {}), 400);
|
|
}
|
|
break;
|
|
default: break; // 'message' etc. belong to other screens (api.on('push') there)
|
|
}
|
|
});
|
|
|
|
// ---- REST fallback: slow when the socket is open (it only backs the hints up), faster when it is down
|
|
let lastPoll = 0;
|
|
function poll(force) {
|
|
if (!App.state.user || windowRef.document.hidden) return;
|
|
const gap = client.open ? 180000 : 45000;
|
|
if (!force && Date.now() - lastPoll < gap) return;
|
|
lastPoll = Date.now();
|
|
App.refreshMovements().catch(() => {});
|
|
App.refreshReportsUnread().catch(() => {});
|
|
App.refreshTowns().catch(() => {});
|
|
App.checkAlerts();
|
|
}
|
|
setInterval(() => poll(false), 15000);
|
|
|
|
// ---- lifecycle
|
|
App.on('session', (st) => {
|
|
if (st && st.user) { client.start(); poll(true); } else client.stop();
|
|
});
|
|
api.on('unauthorized', () => client.stop());
|
|
api.on('online', () => client.kick());
|
|
windowRef.document.addEventListener('visibilitychange', () => { if (!windowRef.document.hidden && App.state.user) { client.kick(); poll(false); } });
|
|
}
|
|
|
|
if (typeof window !== 'undefined' && window.App && window.UI) bind(window.App, window.UI, window);
|
|
|
|
return { createSocketClient, bind };
|
|
}));
|