A network loaded from its checkpoint drifted from the one that never stopped:
after a checkpoint on day 1, 2 or 5 its R differed at once (bizDem at Ashburn
6426 against 26, then cityDem, citySrv, tNet), and from the next day S too
(cash, eyeball growth). Three causes, each shown by a probe:
- R after a day is the R of the day's last routing, made before the day's end
changed S (customers who left or signed, moods, bills, transit history) and
routed from the memory of the R before it. srvLoad routed the saved S again
from R's own memory: another R, which the next day reads (sfOf for eyeball
growth, the peering share). Every compute() in the realm now keeps, for the
R it makes, S as it routed it (one JSON per top-level key, 0.8 ms big) and
the memory it started from. rt carries that routing point (pt: the memory,
the keys that changed since, the keys S did not have then), and srvLoad
routes that S again from it: the same R, byte for byte. The old restore test
checkpointed after day 10, where a failure or event routed again at the end
of the day and nothing changed after it: it passed by luck.
- The sales desk's tried offers (UI.slTried, an offer that did not fit waits a
week) live outside S. A fresh realm forgot them and the desk tried other
offers. rt carries them (sl); a day mark keeps them and the in-place restore
after a throw puts them back (before, a parsed S dropped them).
- A save and a reload give some keys back in another key order (a customer's
defaults go last, the intern's week tally in its own order), and the week's
report lists the tally in that order. At a checkpoint rt carries the live
text of each such key (ord, srvGate's round trip, about 8 ms), taken on load
only where it holds what sanitize() made of the save. A fresh realm after a
timeout takes the mark's own text the same way (live).
The plain game drifts across a save and a reload too (jsdom: from the first
day after it; the page routes a reloaded S with an empty R and keeps no desk
memory): a game property, so the engine carries what is missing.
The envelope keeps its shape {s, uidN, rt, last, day}; rt keeps R's own route
memory, so an older checkpoint loads as before (close, not exact). Big network:
the checkpoint grows from about 42-49 KB gzip to 54-79 KB (rt 7-29 KB; the
whole R would be 375 KB), srvSave from 2-2.5 ms to 7-8 ms, a load by one
routing. A day with its mark costs the same (big 39.8 -> 37.8 ms, busy
90.0 -> 88.8 ms, within noise: the day mark joins per-key JSON now, which pays
for the routing point).
Tests: the restore test checkpoints after days 1, 2, 5 and 10 of the scenic big
network and of the same network busy (intern on every order, the desk signing
on its own, failures, events, an attack), those after days 2 and 10 right after
an action and a what-if (sent to the copies too), each compared byte for byte
at once and 10 days later (SIM_LONG: after every day to 30, 60 checkpoints). It
fails on the old engine, and without any one of the three parts. The retry test
plays busy networks (fails without the desk memory in srvRestore). The market
checkpoint compares bytes too; canon() is gone.
497 lines
41 KiB
JavaScript
497 lines
41 KiB
JavaScript
// One network of a server session, run by the game's own code in a vm realm (the server-sim design, section 4.1).
|
|
// The realm is a vm context made with DONT_CONTEXTIFY, so it has its own intrinsics (a prototype polluted in one realm
|
|
// stays there) and runs at full speed. Into it go, in order: the prelude below (DOM stand-ins that record what the
|
|
// game writes and reads back, no-op timers that count, the network's language), the network's dictionary
|
|
// (site/i18n/<lang>.js, not English), the game script, and the epilogue (the srv… functions: what the server asks of a
|
|
// network, and the rebinds that turn toasts, sounds, windows and the like into effects, "fx", for the page).
|
|
//
|
|
// The worker (mp-sim-worker.js) calls into a realm only through call()/raw(): the input goes in as one JSON string
|
|
// (globalThis.__in), the answer comes back as one string, and no object crosses between host and realm. An answer is
|
|
// a JSON header, optionally followed by more parts, each on its own line (JSON text never holds a raw newline):
|
|
// srvPull answers `{"v":3,"parts":["upd","snap"]}\n<upd JSON>\n<snap JSON>`, ready to write to a stream.
|
|
// A call that throws inside the realm answers {"srvErr": stack}; a call that runs over its time limit throws
|
|
// ERR_SCRIPT_EXECUTION_TIMEOUT here, and the realm must not be used for play again (a timeout skips finally blocks).
|
|
//
|
|
// gameSource({root, page}) the game script (the largest inline <script> of the assembled page)
|
|
// dictSource(lang, root) the source dictionary of a language, or null for English
|
|
// prelude(opts), EPILOGUE the realm's own code around the game, as plain strings
|
|
// compileCode({root, page}) {game, epilogue, simId} as vm.Scripts, once per process (a worker)
|
|
// new Realm({code, lang, dict, test, log, nid}) a realm, the game loaded; .call(name, input, ms), .raw(...)
|
|
// parts(text) [header, ...parts] of an answer
|
|
'use strict';
|
|
const fs = require('node:fs');
|
|
const path = require('node:path');
|
|
const vm = require('node:vm');
|
|
const { assemble, simId, ROOT } = require('./page');
|
|
const ACTS = require('./mp-sim-acts');
|
|
|
|
/* The page whose game a realm runs: the plain one (design 4.1), never a multiplayer build's page. That one also holds
|
|
the server-play client (src/game/98-server-play/), whose rebinds of after, toast and save are for a page that shows
|
|
a server's network; inside the server's own realm they would have to be switched off one by one. The build id
|
|
(SIM_ID) still names the multiplayer page, which holds this game and its client both. */
|
|
const REALM_PAGE = Object.freeze({ dev: false, mp: false });
|
|
|
|
function gameSource({ root = ROOT, page = REALM_PAGE } = {}) {
|
|
const html = assemble({ src: path.join(root, 'src'), dev: !!page.dev, mp: !!page.mp }).html;
|
|
let best = '';
|
|
html.replace(/<script>([\s\S]*?)<\/script>/g, (m, s) => { if (s.length > best.length) best = s; return m; });
|
|
if (!best.includes('function dayTick')) throw new Error('mp-sim-realm: no game script in the assembled page');
|
|
return best;
|
|
}
|
|
|
|
const LANG_RE = /^[a-z]{2}$/;
|
|
function dictSource(lang, root = ROOT) {
|
|
if (!lang || lang === 'en') return null;
|
|
if (!LANG_RE.test(lang)) throw new Error(`mp-sim-realm: bad language ${JSON.stringify(String(lang).slice(0, 20))}`);
|
|
const f = path.join(root, 'site', 'i18n', lang + '.js');
|
|
if (!fs.existsSync(f)) throw new Error(`mp-sim-realm: no dictionary for ${lang}`);
|
|
return fs.readFileSync(f, 'utf8');
|
|
}
|
|
|
|
/* The realm's stand-ins (start: probe/srv-engine/common.js prelude({mode:'record'}), which kept S byte-identical to
|
|
jsdom over 30 big-network days). opts.seed: a test's seeded Math.random under the game's own seeded wrapper (the
|
|
harness's generator, so a realm and a test page draw the same numbers); opts.now: a test's pinned Date.now, moved on
|
|
by opts.step at every day. Without them the realm has its own Math.random and the real clock. */
|
|
function prelude({ lang = 'en', seed = null, now = null, step = 2500, test = false } = {}) {
|
|
const L = JSON.stringify(LANG_RE.test(lang) ? lang : 'en');
|
|
return `'use strict';
|
|
globalThis.self=globalThis;self.window=self;self.__TUBES_WORKER__=1;self.__TUBES_TEST__=true;
|
|
{const hn=__hostNow;self.performance={now:()=>hn(),mark(){},measure(){},timeOrigin:0};}
|
|
{const hl=__hostLog,f=l=>(...a)=>{try{hl(l,a.map(x=>x&&x.stack?x.stack:String(x)).join(' '));}catch(e){}};self.console={log:f('log'),info:f('info'),warn:f('warn'),error:f('error'),debug:f('debug'),trace:f('debug')};}
|
|
// No timers in a realm: nothing may run outside the worker's handling of a message. Calls are counted (the timer audit).
|
|
self.__SRV_T={n:0,at:${test ? '[]' : 'null'}};
|
|
{const t=k=>function(){__SRV_T.n++;if(__SRV_T.at&&__SRV_T.at.length<50)__SRV_T.at.push(k+': '+String(new Error().stack).split('\\n').slice(2,7).join(' < '));return 0;};
|
|
for(const k of ['setTimeout','setInterval','requestAnimationFrame','queueMicrotask','setImmediate','requestIdleCallback'])self[k]=t(k);
|
|
for(const k of ['clearTimeout','clearInterval','cancelAnimationFrame','clearImmediate','cancelIdleCallback'])self[k]=()=>{};}
|
|
${seed == null ? '' : `{let r=${(+seed | 0) || 12345};Math.random=()=>{r=(r*16807)%2147483647;return r/2147483647;};}`}
|
|
${now == null ? '' : `{let t=${+now};Date.now=()=>t;self.__srvClock=v=>{if(typeof v==='number')t=v;return t;};self.__srvStep=${+step || 0};}`}
|
|
const _n=new Proxy(function(){},{get:(t,k)=>k===Symbol.toPrimitive?()=>0:k==='then'?undefined:_n,apply:()=>_n,construct:()=>_n,set:()=>true});
|
|
const _store=()=>{const m=new Map();return {getItem:k=>m.has(String(k))?m.get(String(k)):null,setItem(k,v){m.set(String(k),String(v));},removeItem(k){m.delete(String(k));},clear(){m.clear();},key:i=>[...m.keys()][i]??null,get length(){return m.size;}};};
|
|
const _ent={amp:'&',lt:'<',gt:'>',quot:'"',apos:"'",nbsp:'\\u00a0',middot:'\\u00b7',times:'\\u00d7',rarr:'\\u2192',larr:'\\u2190',hellip:'\\u2026',mdash:'\\u2014',ndash:'\\u2013',bull:'\\u2022',deg:'\\u00b0',euro:'\\u20ac',thinsp:'\\u2009'};
|
|
const _txt=h=>String(h).replace(/<[^>]*>/g,'').replace(/&(#x[0-9a-f]+|#\\d+|[a-z]+);/gi,(m,e)=>e[0]==='#'?String.fromCodePoint(e[1]==='x'||e[1]==='X'?parseInt(e.slice(2),16):+e.slice(1)):(e in _ent?_ent[e]:m));
|
|
// Elements keep innerHTML, hidden and value, and answer textContent and firstElementChild from what was written; they
|
|
// have no children (morphKids would loop for ever on the inert proxy's endless nextSibling).
|
|
const _el=(tag,init)=>{const t={tagName:String(tag||'div').toUpperCase(),_h:'',hidden:true,value:'',firstChild:null,lastChild:null,nextSibling:null,previousSibling:null,parentNode:null,children:[],childNodes:[],attributes:[],...init};
|
|
return new Proxy(t,{get(o,k){if(k==='innerHTML')return o._h;if(k==='textContent')return _txt(o._h);
|
|
if(k==='firstElementChild'){const m=/^\\s*<([a-zA-Z][a-zA-Z0-9]*)\\b[^>]*>([\\s\\S]*?)<\\/\\1>/.exec(o._h);return m?_el(m[1],{_h:m[2]}):null;}
|
|
if(k in o)return o[k];return _n;},
|
|
set(o,k,v){if(k==='innerHTML')o._h=String(v);else if(k==='textContent')o._h=String(v).replace(/[&<>]/g,c=>({'&':'&','<':'<','>':'>'})[c]);else o[k]=v;return true;}});};
|
|
const _byId=new Map();
|
|
const _doc=new Proxy({},{get(o,k){if(k==='createElement')return tag=>_el(tag);if(k==='getElementById')return id=>{if(!_byId.has(id))_byId.set(id,_el('div',{id}));return _byId.get(id);};return _n;},set:()=>true});
|
|
self.__srvEl=_byId;self.__srvCoarse=false;
|
|
for(const [k,v] of Object.entries({document:_doc,localStorage:_store(),sessionStorage:_store(),innerWidth:1024,innerHeight:768,devicePixelRatio:1,
|
|
matchMedia:q=>({matches:/pointer:\\s*coarse/.test(String(q))?!!self.__srvCoarse:false,addEventListener(){},removeEventListener(){},addListener(){},removeListener(){}}),
|
|
Image:_n,Audio:_n,AudioContext:undefined,webkitAudioContext:undefined,screen:_n,visualViewport:_n,history:_n,getComputedStyle:_n,ResizeObserver:_n,MutationObserver:_n,IntersectionObserver:_n,Path2D:_n,scrollTo(){},
|
|
SOT_LANG:${L},SOT_LANGS:{en:'English',it:'Italiano',pt:'Português',fr:'Français',es:'Español',de:'Deutsch'},I18N:{},
|
|
location:{href:'https://server.invalid/',protocol:'https:',hostname:'server.invalid',host:'server.invalid',origin:'https://server.invalid',search:'',hash:'',pathname:'/',reload(){},replace(){},assign(){}},
|
|
addEventListener(){},removeEventListener(){},dispatchEvent(){return true;},
|
|
// Nothing reaches out of a realm: no channels, sockets or requests (fetch never settles), no workers.
|
|
BroadcastChannel:undefined,WebSocket:undefined,EventSource:undefined,Worker:undefined,fetch:()=>new Promise(()=>{}),
|
|
navigator:{language:${L},languages:[${L}],userAgent:'tubes-server',onLine:true,maxTouchPoints:0,hardwareConcurrency:1,vibrate:()=>false}}))
|
|
Object.defineProperty(self,k,{value:v,writable:true,configurable:true,enumerable:true});
|
|
`;
|
|
}
|
|
|
|
/* The epilogue: the server's side of a network, in the game's global scope. It only uses the game's own functions and
|
|
the tables of mp-sim-acts.js, written in as data. Everything a page needs to know comes out as fx or in the answers. */
|
|
const TABLES = JSON.stringify({ SEND: ACTS.SEND, ASK: ACTS.ASK, CONFIRM: ACTS.CONFIRM, DRAFTS: ACTS.DRAFTS, PREFS: ACTS.PREFS });
|
|
const EPILOGUE = `'use strict';
|
|
const SIMT=${TABLES},SIM_SEND=new Set(SIMT.SEND),SIM_ASK=new Set(SIMT.ASK),SIM_KEEP=new Set(['badge','modal']);
|
|
const SIM_RNEVER=new Set(['ef','fl','efp','flc','efg','egDesc','l2route','bbF','peered','cityBlocked']);
|
|
const SIM_DRAFT=['pending','route','via','cnPrem','dfSrc','dfSys','seaDesign','seaterminal','seaengineering','decom','slop','pieIns','pieLas'];
|
|
// The realm's own memory: epoch and version of what it sent (5.10), the last keys sent, the fx and actions since the
|
|
// last pull, the marks, and what the running call saw (a window opened or closed, a refusal toast, an auto-pause).
|
|
const SIMR={epoch:'',v:0,seen:false,base:null,rSent:null,fx:[],acts:[],floats:0,alone:false,last:1,pause:false,modal:null,closed:false,bad:false,
|
|
mark:null,markK:null,markRt:null,strict:false};
|
|
const srvOwn=(o,k)=>Object.prototype.hasOwnProperty.call(o,k);
|
|
const srvOut=(h,...p)=>[JSON.stringify(h),...p].join('\\n');
|
|
function srvLog(t){console.warn(String(t).slice(0,600));}
|
|
|
|
/* fx: a ring of 200; when it overflows, the oldest go first, but badges and windows (win, lose) stay, at most 32. */
|
|
function srvFx(f){const q=SIMR.fx;q.push(f);
|
|
if(q.length>200){const i=q.findIndex(x=>!SIM_KEEP.has(x[0]));q.splice(i>=0?i:0,1);}
|
|
if(SIM_KEEP.has(f[0])){let n=0;for(const x of q)if(SIM_KEEP.has(x[0]))n++;if(n>32)q.splice(q.findIndex(x=>SIM_KEEP.has(x[0])),1);}}
|
|
// At most 60 in one update: floaters go first, then sounds and the like, then the oldest toasts; windows, badges,
|
|
// pauses and the chaos monkey's last word stay.
|
|
function srvCap(fx){if(fx.length<=60)return fx;let out=fx;
|
|
for(const k of ['floater','sfx','haptic','track','mk','told','toast']){let over=out.length-60;if(over<=0)break;
|
|
out=out.filter(f=>{if(over>0&&f[0]===k&&!(k==='mk'&&f[1]&&f[1].e==='end')){over--;return false;}return true;});}
|
|
return out.length>60?out.slice(-60):out;}
|
|
|
|
/* ---- capture: what the page shows, as fx (design 4.1's table) ---- */
|
|
toast=function(h,k='',a=[],o=null){if(S)logNote(h,k,a,o);if(k==='bad')SIMR.bad=true;srvFx(['toast',{h:String(h),k:String(k),a:Array.isArray(a)?a:[],o:o||null,tick:!!UI.tick}]);};
|
|
sfx=function(n){srvFx(['sfx',String(n)]);};
|
|
haptic=function(n){srvFx(['haptic',+n||12]);};
|
|
floater=function(x,y,t,c){if(SIMR.floats>=40)return;SIMR.floats++;srvFx(['floater',[+x||0,+y||0,String(t),String(c)]]);};
|
|
track=function(n,once){srvFx(['track',[String(n),!!once]]);};
|
|
// Alone, an auto-pause pauses the world (the host stops the clock after the day) and its toast's Resume votes for the
|
|
// speed it ran at; with others it does not pause, and the page offers a vote instead.
|
|
// Alone it stops this realm's clock too, as the page's does: a second auto-pause that day finds it paused (srvDay sets
|
|
// the speed again before the next day).
|
|
autoPause=function(){if(!S||!UI.speed)return false;SIMR.pause=true;srvFx(['pause',1]);if(!SIMR.alone)return false;UI.resumeSpeed=UI.lastSpeed=SIMR.last;UI.speed=0;return true;};
|
|
openModal=function(h,c=''){SIMR.modal={h:String(h),c:String(c||'')};const m=$('modal');m.className=String(c||'');m.hidden=false;$('modalCard').innerHTML=String(h);};
|
|
{const c0=closeModal;closeModal=function(){c0();SIMR.closed=true;};}
|
|
showWin=function(){srvFx(['modal','win']);};
|
|
showLose=function(){srvFx(['modal','lose']);};
|
|
showBaronWin=function(){srvFx(['modal','baron']);};
|
|
{const s0=mkStart,r0=mkRun,e0=mkEnd;
|
|
mkStart=function(c){s0(c);srvFx(['mk',{e:'start',c:String(c)}]);};
|
|
mkRun=function(l,dur,bad){r0(l,dur,bad);srvFx(['mk',{e:'run',link:l&&l.id!==undefined?String(l.id):null,felt:!!bad}]);};
|
|
mkEnd=function(ok,bye){e0(ok,bye);srvFx(['mk',{e:'end',ok:!!ok,bye:!!bye}]);};}
|
|
{const b0=checkBadges;checkBadges=function(){const a0=S&&S.ach?{...S.ach}:{},p0=S&&S.achP?{...S.achP}:{};b0();
|
|
if(S&&S.achP)for(const id of Object.keys(S.achP))if(a0[id]===undefined||p0[id]!==S.achP[id])srvFx(['badge',{id,v:String(S.achP[id])}]);};}
|
|
// Never shown here, and linkPanel would drop a selection it cannot find; the page keeps its own.
|
|
renderPanel=function(){};renderLeft=function(){};
|
|
// Checkpoints are the engine's (UI.slot is null anyway).
|
|
save=function(){};
|
|
// This realm is the server: a server network is never shown here.
|
|
srvOn=function(){return false;};
|
|
UI.clockLocked=true;UI.started=true;UI.pitched=true;UI.speed=1;
|
|
|
|
/* ---- S as top-level keys, R as the page gets it ---- */
|
|
function srvKeyJson(){const o={};for(const k of Object.keys(S)){const j=JSON.stringify(S[k]);if(j!==undefined)o[k]=j;}return o;}
|
|
function srvJoin(K){let t='{',f=true;for(const k in K){t+=(f?'':',')+JSON.stringify(k)+':'+K[k];f=false;}return t+'}';}
|
|
// Slim R (5.5): rwPack's view without the flow tables, routing's own inputs and what goes on demand; the top 4 networks
|
|
// per transit port, the top 8 over all of them, numbers to 6 significant digits. Packed once per R object.
|
|
const srvR6=(k,v)=>typeof v==='number'&&!Number.isInteger(v)&&Number.isFinite(v)?+v.toPrecision(6):v;
|
|
function srvSlimR(){const c=SIM_RTXT.get(R);if(c)return c;const o={};
|
|
for(const k in R){if(SIM_RNEVER.has(k))continue;o[k]=k==='ddos'?R.ddos.map(m=>({...m,attack:m.attack?m.attack.id:null,ports:null})):R[k];}
|
|
const tn={};for(const id in o.tNet)tn[id]=Object.fromEntries(Object.entries(o.tNet[id]).sort((a,b)=>b[1]-a[1]).slice(0,4));o.tNet=tn;
|
|
o.tTop8=transitTop(S.transit.map(t=>t.id),8);
|
|
const t=JSON.stringify(o,srvR6);SIM_RTXT.set(R,t);return t;}
|
|
const SIM_RTXT=new WeakMap();
|
|
|
|
/* ---- rt (4.1, 4.6): what a fresh realm needs besides the save to go on exactly as this one ---- */
|
|
// The route memory: what compute() reads of the R before it (R.load, R.l2route, R.efg cut to the scenic circuits' keys).
|
|
function srvRtOut(r){const efg={},E=r&&r.efg;
|
|
if(E)for(const id in E){const t=E[id]&&E[id].t;if(!t||!t.g)continue;const g=[],v=[];for(const [k,s] of t.g)if(String(k).startsWith('l2:')){g.push([k,v.length]);v.push(+t.v[s]);}if(g.length)efg[id]={g,v};}
|
|
return {load:(r&&r.load)||{},l2route:(r&&r.l2route)||{},efg};}
|
|
function srvRtIn(rt){const r=emptyR();if(!rt||typeof rt!=='object')return r;
|
|
if(rt.load&&typeof rt.load==='object')r.load=rt.load;if(rt.l2route&&typeof rt.l2route==='object')r.l2route=rt.l2route;
|
|
if(rt.efg&&typeof rt.efg==='object'){const o={};for(const id of Object.keys(rt.efg)){const t=rt.efg[id];if(t&&Array.isArray(t.g)&&Array.isArray(t.v))o[id]={g:new Map(t.g),v:t.v};}
|
|
Object.defineProperty(r,'efg',{value:rwEfgIn(o)});}
|
|
return r;}
|
|
/* The routing point. R after a day is the R of the day's last routing, which ran before the day's end changed S (bills,
|
|
moods, customers who left or signed) and started from the memory of the R before it. compute() of the saved S, even
|
|
from R's own memory, gives another R, and the next day reads it (eyeball growth, the peering share): a network
|
|
restored that way drifts from its first day on. So every compute() keeps, for the R it makes, S as it routed it (one
|
|
JSON per top-level key, 0.8 ms big) and the memory it started from. rt carries that point (pt: the memory, at: the
|
|
keys that changed since, gone: the keys S did not have then), and a fresh realm routes that S again from that memory:
|
|
the same R (srvReroute). Trials route and put R back: their points go with their R. */
|
|
const SIM_RIN=new WeakMap();
|
|
{const c0=compute;compute=function(){const k=S?srvKeyJson():null,rt=JSON.stringify(srvRtOut(R)),v=c0.apply(this,arguments);if(k)SIM_RIN.set(R,{k,rt});return v;};}
|
|
// The sales desk's memory (39-sales-auto.js): the offers it tried, which wait a week before it tries them again. It is
|
|
// not in S; rt carries the entries of offers still on the table (no other can count again).
|
|
function srvSlOut(){const t=UI.slTried;if(!t||t.s!==S||!t.m)return [];const ids=new Set(S.offers.map(o=>o.id));return [...t.m].filter(e=>ids.has(e[0]));}
|
|
function srvSlIn(sl){const m=new Map();if(Array.isArray(sl))for(const e of sl.slice(0,1000))if(Array.isArray(e)&&typeof e[0]==='string'&&Number.isInteger(e[1]))m.set(e[0],e[1]);UI.slTried=m.size?{s:S,m}:null;}
|
|
/* Key order: a reload gives some keys back with their keys in another order (a customer's defaults go last, the intern's
|
|
week tally comes back in its own order, and the week's report lists it in that order). At a checkpoint rt carries the
|
|
live text of each such key (ord, srvGate's round trip: ≈ 8 ms big, once per checkpoint), and a fresh realm takes it
|
|
only where it holds what sanitize() made of the save (srvSame): only the order comes from it. */
|
|
function srvOrdOut(txt,K){const u0=uidN,r0=S.rng;let B;
|
|
try{B=migrate(JSON.parse(txt));}catch(e){srvLog('checkpoint: the save does not load: '+String(e&&e.message||e));return '{}';}finally{uidN=u0;S.rng=r0;}
|
|
const o=[];for(const k in K)if(srvOwn(B,k)&&JSON.stringify(B[k])!==K[k])o.push(JSON.stringify(k)+':'+K[k]);return '{'+o.join(',')+'}';}
|
|
function srvOrdIn(o){if(!o||typeof o!=='object'||Array.isArray(o))return;for(const k of Object.keys(o))if(srvOwn(S,k)&&srvSame(o[k],S[k]))S[k]=o[k];}
|
|
// rt as JSON text: R's own route memory, its routing point against S as K holds it (when R was routed here), ord when
|
|
// given, and the desk's memory sl.
|
|
function srvRtText(r,K,ord,sl){const p=K&&SIM_RIN.get(r);let t=JSON.stringify(srvRtOut(r)).slice(0,-1);
|
|
if(p){const at=[],gone=[];for(const k in p.k)if(K[k]!==p.k[k])at.push(JSON.stringify(k)+':'+p.k[k]);for(const k in K)if(!srvOwn(p.k,k))gone.push(k);
|
|
t+=',"pt":'+p.rt.slice(0,-1)+',"at":{'+at.join(',')+'},"gone":'+JSON.stringify(gone)+'}';}
|
|
return t+(ord?',"ord":'+ord:'')+',"sl":'+JSON.stringify(sl||[])+'}';}
|
|
const srvKeysOf=s=>{const o=JSON.parse(s),K={};for(const k of Object.keys(o)){const j=JSON.stringify(o[k]);if(j!==undefined)K[k]=j;}return K;};
|
|
// The S of a routing point (pt), one JSON per key: the loaded S with the keys of at put back and those of gone left out.
|
|
function srvAtK(pt){if(!pt||typeof pt!=='object'||!pt.at||typeof pt.at!=='object'||Array.isArray(pt.at)||!Array.isArray(pt.gone))return null;
|
|
const K=srvKeyJson();for(const k of Object.keys(pt.at))K[k]=JSON.stringify(pt.at[k]);for(const k of pt.gone)if(typeof k==='string')delete K[k];return K;}
|
|
// R as the routing point gives it: that S routed from that memory, then the loaded S again (R's attacks found in it).
|
|
function srvReroute(pt){const K=srvAtK(pt);if(!K)return false;const S1=S,u0=uidN;
|
|
try{S=JSON.parse(srvJoin(K));R=srvRtIn(pt);compute();}
|
|
catch(e){srvLog('routing the checkpoint again failed: '+String(e&&e.stack||e));return false;}
|
|
finally{S=S1;uidN=u0;}
|
|
srvAttacks();return true;}
|
|
// R with its point, when it came whole (rpack): a checkpoint before its next routing still carries the point.
|
|
function srvPointIn(r,pt){const K=srvAtK(pt);if(K)SIM_RIN.set(r,{k:K,rt:JSON.stringify({load:pt.load||{},l2route:pt.l2route||{},efg:pt.efg||{}})});}
|
|
// R's attacks are its only references into S (rwPack): looked up again in a new S.
|
|
function srvAttacks(){if(!R||!Array.isArray(R.ddos))return;const as=ddosAll(S,false);for(const x of R.ddos)if(x.attack)x.attack=as.find(a=>a.id===x.attack.id)||null;}
|
|
// mark: rt of the marked R against the marked S (a day's mark has it at once); else of R against S now.
|
|
function srvRt(inp){const m=inp?JSON.parse(inp):{},k=SIMR.mark;
|
|
if(!m.mark)return srvRtText(R,srvKeyJson(),'',srvSlOut());
|
|
return SIMR.markRt||(k?srvRtText(k.R,SIMR.markK||srvKeysOf(k.s),'',k.sl):srvRtText(R,null,'',[]));}
|
|
/* R itself, whole, for the fresh realm that replaces this one after a timeout (routing it again from its point costs a
|
|
routing; the old realm still answers), the way the route worker sends it (rwPack/rwUnpack), as text: Maps, Sets, typed
|
|
arrays and non-finite numbers tagged. A checkpoint carries the point instead: 20 KB gzip, where R is 375 KB. */
|
|
const SIM_TA=new Set(['Float64Array','Float32Array','Int32Array','Uint32Array','Int16Array','Uint16Array','Int8Array','Uint8Array','Uint8ClampedArray']);
|
|
const srvEnc=(k,v)=>typeof v==='number'&&!Number.isFinite(v)?{__n:String(v)}:v instanceof Map?{__m:[...v]}:v instanceof Set?{__s:[...v]}:ArrayBuffer.isView(v)&&SIM_TA.has(v.constructor.name)?{__t:v.constructor.name,a:Array.from(v)}:v;
|
|
const srvDec=(k,v)=>!v||typeof v!=='object'||Array.isArray(v)?v:'__n' in v?Number(v.__n):'__m' in v?new Map(v.__m):'__s' in v?new Set(v.__s):'__t' in v&&SIM_TA.has(v.__t)?new self[v.__t](v.a):v;
|
|
function srvRPack(inp){const m=inp?JSON.parse(inp):{},r=m.mark&&SIMR.mark?SIMR.mark.R:R;if(!r||!r.efp||!r.flc)return '';const {o,p}=rwPack(r);return JSON.stringify({o,p},srvEnc);}
|
|
|
|
function srvSetPrefs(p){if(!p||typeof p!=='object')return;for(const k of SIMT.PREFS)if(typeof p[k]==='boolean')PREFS[k]=p[k];}
|
|
function srvFresh(epoch){SIMR.epoch=String(epoch||'');SIMR.v=0;SIMR.seen=false;SIMR.fx=[];SIMR.acts=[];SIMR.floats=0;SIMR.rSent=new WeakRef(R);SIMR.base=srvKeyJson();SIMR.mark=null;SIMR.markK=null;SIMR.markRt=null;
|
|
UI.sel=null;UI.confirm=null;UI.pending=null;UI.started=true;UI.pitched=true;UI.clockLocked=true;$('modal').hidden=true;}
|
|
|
|
/* srvLoad: a network from its save (a checkpoint, or the mark of a realm that timed out) and its rt: S in its live key
|
|
order, R routed again from its routing point, the desk's memory; then the days to come are the ones the old realm
|
|
had. A realm that replaces one that timed out gets the old realm's R itself when it could still pack it (rpack); live:
|
|
the save is the old realm's own S as text (a mark), key order and all. An rt without a point (an older checkpoint)
|
|
seeds R with its memory before compute(), the way the route worker does: close, not always the same. */
|
|
function srvLoad(inp){const m=JSON.parse(inp),rt=m.rt&&typeof m.rt==='object'?m.rt:{};SIMR.strict=!!m.strict;
|
|
S=migrate(JSON.parse(m.save));
|
|
if(typeof S.rng!=='number')S.rng=(m.rng|0)||1;
|
|
if(Number.isInteger(m.uidN)&&m.uidN>0)uidN=m.uidN;
|
|
srvSetPrefs(m.prefs);
|
|
// A test's pinned clock goes on where the realm this one replaces had it.
|
|
if(self.__srvClock&&typeof m.clock==='number')__srvClock(m.clock);
|
|
srvOrdIn(m.live?JSON.parse(m.save):rt.ord);
|
|
if(typeof m.rpack==='string'&&m.rpack){const x=JSON.parse(m.rpack,srvDec);R=rwUnpack(x.o,x.p);UI.hotMap=hotByCity();srvPointIn(R,rt.pt);}
|
|
else if(!srvReroute(rt.pt)){R=srvRtIn(rt);compute();}
|
|
srvSlIn(rt.sl);
|
|
srvFresh(m.epoch);
|
|
// Whatever a loaded network says before its first snapshot (days nobody watched) is older than that snapshot: the
|
|
// first pull handles it like any (5.11). Only a new network's welcome waits for its first page (srvBegin).
|
|
SIMR.seen=true;
|
|
return JSON.stringify({day:S.day,lost:!!S.lost});}
|
|
const srvClockNow=()=>self.__srvClock?{clock:__srvClock()}:{};
|
|
// srvBegin: a new network of a server session (T1's beginState, then the server's own marks and the welcome).
|
|
function srvBegin(inp){const m=JSON.parse(inp),b=m.begin||{};SIMR.strict=!!m.strict;
|
|
if(typeof b.home!=='string'||!homeOk(b.home))throw new Error('srvBegin: '+String(b.home).slice(0,20)+' cannot be a home city');
|
|
if(!b.mp||typeof b.mp!=='object')throw new Error('srvBegin: no session');
|
|
srvSetPrefs(m.prefs);UI.pitched=true;
|
|
beginState(String(b.name||'').slice(0,24)||randomNetworkName(),b.home,{mode:'normal',preset:b.preset,mp:b.mp,asn:Number(b.asn)});
|
|
if(!S.mp)throw new Error('srvBegin: the session did not take');
|
|
S.mp.sim=1;S.tut=b.tut?0:null;compute();srvFresh(m.epoch);
|
|
// The welcome: in S.log, and an fx that waits for the first update after the first snapshot (srvPullParts).
|
|
beginHello();
|
|
return JSON.stringify({day:S.day,lost:!!S.lost});}
|
|
function srvPrefs(inp){const m=JSON.parse(inp);srvSetPrefs(m.prefs);return '{}';}
|
|
|
|
/* srvMark: the restore point of the next day (day) or action (keys: one JSON per top-level key, whose join is the same
|
|
string, kept for the action's own comparison). The worker keeps the string, uidN and a day's rt too, to build a fresh
|
|
realm if this one times out. */
|
|
function srvMark(inp){const m=inp?JSON.parse(inp):{};let s,K=null;
|
|
if(m.keys||m.day){K=srvKeyJson();s=srvJoin(K);}else s=JSON.stringify(S);
|
|
SIMR.markK=m.keys?K:null;const sl=srvSlOut();
|
|
SIMR.mark={s,uidN,rng:S.rng,R,sl,...srvClockNow(),fx:SIMR.fx.slice(),floats:SIMR.floats,ui:{sel:UI.sel,tab:UI.tab,left:UI.left,confirm:UI.confirm,pending:UI.pending}};
|
|
// As text: nothing the day does reaches it.
|
|
const rtJ=m.day?srvRtText(R,K,'',sl):'';SIMR.markRt=rtJ||null;const h=JSON.stringify({uidN,day:S.day,...srvClockNow()});
|
|
return (rtJ?h.slice(0,-1)+',"rt":'+rtJ+'}':h)+'\\n'+s;}
|
|
/* srvRestore: back to the mark, in place (after a throw: the finally blocks ran). S is parsed back only when it
|
|
changed, so the S object stays on every normal path; R is the marked object, its attacks looked up again in a parsed
|
|
S; the sales desk's memory is the marked one (a failed day may have added to it). (The design rebuilt R from route
|
|
memory after a failed day; that R is close, not the same: tests/mp-sim-determinism.) */
|
|
function srvRestore(inp){const k=SIMR.mark;if(!k)return '{"none":1}';
|
|
let parsed=false;if(JSON.stringify(S)!==k.s){S=JSON.parse(k.s);parsed=true;}
|
|
uidN=k.uidN;S.rng=k.rng;if(self.__srvClock&&typeof k.clock==='number')__srvClock(k.clock);
|
|
// R: the marked object. A day or an action routes into a new R (compute() never writes to the one it starts from),
|
|
// so the marked one is still the R the network had: route memory and compute() would only give one close to it.
|
|
R=k.R;if(parsed)srvAttacks();
|
|
UI.hotMap=hotByCity();UI.slTried=k.sl.length?{s:S,m:new Map(k.sl)}:null;
|
|
Object.assign(UI,k.ui);SIMR.fx=k.fx.slice();SIMR.floats=k.floats;SIMR.modal=null;SIMR.closed=false;$('modal').hidden=true;
|
|
return JSON.stringify({parsed});}
|
|
|
|
/* srvDay: one day of this network, as the page runs it (dayTick, then the day's end render), then the tutorial. mute:
|
|
a catch-up day, whose fx are dropped (badges and windows stay). */
|
|
function srvDay(inp){const m=inp?JSON.parse(inp):{};
|
|
if(!S||S.lost)return JSON.stringify({day:S?S.day:0,lost:true});
|
|
SIMR.alone=!!m.alone;SIMR.last=[0.5,1,2,4,8].includes(m.last)?m.last:1;SIMR.pause=false;
|
|
UI.speed=[0.5,1,2,4,8].includes(m.speed)?m.speed:1;UI.clockLocked=true;UI.started=true;
|
|
if(self.__srvClock&&self.__srvStep)__srvClock(__srvClock()+__srvStep);
|
|
const n0=SIMR.fx.length;
|
|
dayTick();UI.ticking=true;try{renderHUD();}finally{UI.ticking=false;}
|
|
tutAdvance();
|
|
if(m.mute)SIMR.fx=SIMR.fx.slice(0,n0).concat(SIMR.fx.slice(n0).filter(f=>SIM_KEEP.has(f[0])));
|
|
// Tests (SIM_STRICT): live S after a day is what a reload makes of it, every key (T1's canonical state).
|
|
if(SIMR.strict){const bad=srvGate(null).bad;if(bad.length)throw new Error('sanitize would repair day '+S.day+': '+bad.join(', '));}
|
|
// Done: the marked R (and its flow tables) need not stay alive until the next mark.
|
|
SIMR.mark=null;
|
|
return JSON.stringify({day:S.day,lost:!!S.lost,...(SIMR.pause?{pause:true}:{})});}
|
|
|
|
/* The sanitize gate (5.8 step 6): the keys an action changed must come through the save path as they are. Never adopts
|
|
the repaired copy (a new S without compute() would leave R's attacks pointing into the old one). keys null: all. */
|
|
const srvSortK=v=>Array.isArray(v)?v.map(srvSortK):v&&typeof v==='object'?Object.keys(v).sort().reduce((o,k)=>(v[k]!==undefined&&(o[k]=srvSortK(v[k])),o),Object.create(null)):v;
|
|
const srvSame=(a,b)=>{const x=JSON.stringify(a),y=JSON.stringify(b);return x===y||JSON.stringify(srvSortK(a))===JSON.stringify(srvSortK(b));};
|
|
function srvGate(keys){const u0=uidN,r0=S.rng;
|
|
try{const txt=JSON.stringify(packSave(S)),a=JSON.parse(txt),b=JSON.parse(JSON.stringify(packSave(migrate(JSON.parse(txt)))));
|
|
const ks=keys||[...new Set([...Object.keys(a),...Object.keys(b)])];return {bad:ks.filter(k=>!srvSame(a[k],b[k])),len:txt.length};}
|
|
finally{uidN=u0;S.rng=r0;}}
|
|
|
|
/* ---- actions (5.8) ---- */
|
|
const srvSel=v=>v&&typeof v==='object'&&typeof v.id==='string'&&(v.type==='city'?isCity(v.id):v.type==='link'?S.links.some(l=>l.id===v.id):false)?{type:v.type,id:v.id}:null;
|
|
function srvView(c){c=c&&typeof c==='object'?c:{};
|
|
innerWidth=Number.isFinite(c.w)?c.w:1024;innerHeight=Number.isFinite(c.h)?c.h:768;self.__srvCoarse=!!c.coarse;}
|
|
function srvArm(act,args){const t=SIMT.CONFIRM[act];return t.replace(/\\{(\\w+)\\}/g,(m,k)=>String(args&&args[k]!==undefined?args[k]:''));}
|
|
// The drafts an act reads, from the request, each checked against the game's catalogs; anything else is wiped first, so
|
|
// nothing of an earlier request leaks into this one. A bad one: the reason; the act does not run.
|
|
function srvDrafts(act,ui,args){for(const k of SIM_DRAFT){if(k==='pending')UI.pending=null;else delete UI[k];}
|
|
const allowed=SIMT.DRAFTS[act]||[];
|
|
for(const k of Object.keys(ui||{})){if(!allowed.includes(k))return 'draft '+k+' is not '+act+'\\'s';const v=ui[k];
|
|
if(k==='pending'){if(!v||typeof v!=='object'||!isCity(v.a)||!isCity(v.b)||v.a===v.b)return 'pending names no two places';UI.pending={a:v.a,b:v.b};}
|
|
else if(k==='route'){if(typeof v!=='string'||!/^(|same|diverse|t:[A-Za-z0-9_.:|~-]{1,40})$/.test(v))return 'bad route';UI.route=v;}
|
|
else if(k==='via'){if(!(v===''||v==='land'||(typeof v==='string'&&CABLES.some(c=>c.id===v))))return 'bad via';UI.via=v;}
|
|
else if(k==='dfSrc'){if(!['lease','build','cable'].includes(v))return 'bad dfSrc';UI.dfSrc=v;}
|
|
else if(k==='dfSys'){if(typeof v!=='string'||!srvOwn(DF_SYS,v))return 'bad dfSys';UI.dfSys=v;}
|
|
else if(k==='seaDesign'){if(typeof v!=='string'||!srvOwn(SEA_DESIGNS,v))return 'bad seaDesign';UI.seaDesign=v;}
|
|
else if(k==='decom'){if(!Array.isArray(v))return 'bad decom';UI.decom=new Set(v.filter(isCity).slice(0,200));}
|
|
else if(k==='slop'){if(typeof v!=='boolean')return 'bad slop';if(v&&typeof args.script==='string')UI.slop=args.script.slice(0,4000);}
|
|
else{if(typeof v!=='boolean')return 'bad '+k;UI[k]=v;}}
|
|
return null;}
|
|
function srvAct(inp){const m=JSON.parse(inp),act=String(m.act),ent={rid:String(m.rid),dev:String(m.dev),ui:{}};
|
|
if(!S||S.lost)return srvOut({outcome:'stopped',v:SIMR.v});
|
|
const args=m.args&&typeof m.args==='object'&&!Array.isArray(m.args)?m.args:{};
|
|
let outcome,why;const K0=SIMR.markK;
|
|
const done=(o,w)=>{outcome=o;why=w;};
|
|
if(!SIM_SEND.has(act)||!srvOwn(ACT,act)||typeof ACT[act]!=='function')done('rejected','not an act the server runs');
|
|
else{const w=srvDrafts(act,m.ui,args);
|
|
if(w)done('rejected',w);
|
|
else{const c=m.ctx&&typeof m.ctx==='object'?m.ctx:{};
|
|
UI.sel=srvSel(c.sel);if(typeof c.tab==='string')UI.tab=c.tab;if(typeof c.left==='string')UI.left=c.left;srvView(c);$('modal').hidden=!c.modal;
|
|
let a2=args;UI.confirm=null;
|
|
if(m.confirmed===true&&srvOwn(SIMT.CONFIRM,act)){if(SIMT.CONFIRM[act]==='arg')a2={...args,ok:1};else UI.confirm=srvArm(act,args);}
|
|
const sent={sel:UI.sel,tab:UI.tab,left:UI.left,confirm:UI.confirm};
|
|
SIMR.modal=null;SIMR.closed=false;SIMR.bad=false;
|
|
let err=null;try{ACT[act](a2);tutAdvance();}catch(e){err=e;}
|
|
if(err){srvRestore('{}');srvLog('act '+act+' threw: '+String(err&&err.stack||err));done('error','the game threw: '+String(err&&err.message||err).slice(0,200));}
|
|
else{const K=srvKeyJson(),ch=[];for(const k in K)if(!K0||K0[k]!==K[k])ch.push(k);if(K0)for(const k in K0)if(!(k in K))ch.push(k);
|
|
if(!ch.length)done(SIMR.bad?'rejected':'no_effect');
|
|
else if(SIMR.bad&&ch.every(k=>k==='log'))done('rejected');
|
|
else{const g=srvGate(ch);let len=0,len0=0;for(const k in K)len+=K[k].length;if(K0)for(const k in K0)len0+=K0[k].length;
|
|
if(g.bad.length){srvRestore('{}');srvLog('sanitize would repair '+act+': '+g.bad.join(', '));done('error','sanitize would repair '+act+': '+g.bad.join(', '));}
|
|
else if(g.len>4194304||len-len0>262144){srvRestore('{}');srvLog('size guard: '+act);done('error','the network would grow too big');}
|
|
else done('applied');}
|
|
if(outcome!=='error'){for(const k of ['sel','tab','left','confirm'])if(JSON.stringify(UI[k]??null)!==JSON.stringify(sent[k]??null))ent.ui[k]=UI[k]??null;
|
|
if(SIMR.closed)ent.ui.closed=1;if(SIMR.modal)ent.ui.modal=SIMR.modal;}}}}
|
|
SIMR.mark=null;SIMR.markK=null;SIMR.acts.push(ent);
|
|
const p=srvPullParts({});
|
|
return srvOut({outcome,...(why?{why}:{}),v:SIMR.v},p.upd);}
|
|
|
|
/* ---- asks (5.9): what-ifs that open a window and put everything back ---- */
|
|
function srvAsk(inp){const m=JSON.parse(inp),k=SIMR.mark,act=String(m.act),out={};
|
|
if(!SIM_ASK.has(act)||!srvOwn(ACT,act))return JSON.stringify({err:'not a what-if the server answers'});
|
|
const args=m.args&&typeof m.args==='object'&&!Array.isArray(m.args)?m.args:{},td=UI.teDraft,sl=UI.slop,fx0=SIMR.fx.slice(),fl=SIMR.floats;
|
|
srvView(m.ctx);$('modal').hidden=!(m.ctx&&m.ctx.modal);SIMR.modal=null;
|
|
try{ACT[act](args);}catch(e){out.err='the game threw: '+String(e&&e.message||e).slice(0,200);srvLog('ask '+act+' threw: '+String(e&&e.stack||e));}
|
|
if(SIMR.modal)out.modal=SIMR.modal;
|
|
if(act==='teCheck'||act==='teSlop'){out.ui={teDraft:typeof UI.teDraft==='string'?UI.teDraft:null};if(act==='teSlop')out.ui.slop=typeof UI.slop==='string'?UI.slop:null;}
|
|
R=k.R;uidN=k.uidN;S.rng=k.rng;
|
|
if(JSON.stringify(S)!==k.s){srvLog('ask '+act+' changed the game: put back');srvRestore('{}');}
|
|
else Object.assign(UI,k.ui);
|
|
SIMR.mark=null;UI.teDraft=td;UI.slop=sl;SIMR.fx=fx0;SIMR.floats=fl;SIMR.modal=null;$('modal').hidden=true;
|
|
return JSON.stringify(out);}
|
|
|
|
/* ---- pulls (5.3-5.6, 5.10): the only place the version moves ---- */
|
|
function srvSubs(views){const o={};if(!Array.isArray(views))return o;
|
|
for(const w of views.slice(0,16)){if(!w||typeof w!=='object')continue;
|
|
if(typeof w.link==='string'){const l=S.links.find(x=>x.id===w.link),ef={},egd={};
|
|
if(l){const k=edgeKey(l),rec=R.ef&&R.ef[k];if(rec){ef[k]=rec;for(const e in rec.eg||{})if(R.egDesc&&R.egDesc[e])egd[e]=R.egDesc[e];}}
|
|
o['link:'+w.link]={ef,egd};}
|
|
if(typeof w.peer==='string'&&isCity(w.peer))o['peer:'+w.peer]={pf:{[w.peer]:S.pops[w.peer]?pniFlows(w.peer):{}}};}
|
|
return o;}
|
|
function srvPullParts(m,K){K=K||srvKeyJson();const now=Date.now();
|
|
// The first snapshot of an epoch, before any update: nobody holds anything of this realm yet, so there is no update to
|
|
// make; what happened meanwhile (a new network's welcome) waits for the first one, which that page will get.
|
|
if(m.snap&&!SIMR.seen){SIMR.seen=true;SIMR.base=K;SIMR.rSent=new WeakRef(R);
|
|
return {upd:'',snap:'{"t":"snap","epoch":'+JSON.stringify(SIMR.epoch)+',"v":'+SIMR.v+',"now":'+now+',"S":'+srvJoin(K)+',"r":'+srvSlimR()+',"keep":[]}',subs:m.views?srvSubs(m.views):null};}
|
|
const B=SIMR.base||{},s=[],del=[];
|
|
for(const k in K)if(B[k]!==K[k])s.push(k);for(const k in B)if(!(k in K))del.push(k);
|
|
const rNew=!SIMR.rSent||SIMR.rSent.deref()!==R,fx=SIMR.fx,acts=SIMR.acts;let upd='';
|
|
if(s.length||del.length||rNew||fx.length||acts.length){const from=SIMR.v,v=++SIMR.v;
|
|
let t='{"t":"upd","from":'+from+',"v":'+v+',"now":'+now+',"day":'+S.day+',"s":{'+s.map(k=>JSON.stringify(k)+':'+K[k]).join(',')+'}';
|
|
if(del.length)t+=',"del":'+JSON.stringify(del);
|
|
if(rNew)t+=',"r":'+srvSlimR();
|
|
const cf=srvCap(fx);if(cf.length)t+=',"fx":'+JSON.stringify(cf);
|
|
if(acts.length)t+=',"acts":'+JSON.stringify(acts);
|
|
upd=t+'}';SIMR.base=K;SIMR.rSent=new WeakRef(R);SIMR.fx=[];SIMR.acts=[];SIMR.floats=0;SIMR.seen=true;}
|
|
let snap='';
|
|
// A snapshot at the same version: what the host adds (clock, roster, since) it adds to this text itself.
|
|
if(m.snap){const keep=fx.filter(f=>SIM_KEEP.has(f[0])).slice(-32);
|
|
snap='{"t":"snap","epoch":'+JSON.stringify(SIMR.epoch)+',"v":'+SIMR.v+',"now":'+now+',"S":'+srvJoin(K)+',"r":'+srvSlimR()+',"keep":'+JSON.stringify(keep)+'}';
|
|
SIMR.base=K;SIMR.rSent=new WeakRef(R);}
|
|
return {upd,snap,subs:m.views?srvSubs(m.views):null};}
|
|
function srvPull(inp){const m=inp?JSON.parse(inp):{},p=srvPullParts(m),parts=[],h={v:SIMR.v,parts};
|
|
if(p.upd)parts.push('upd');if(p.snap)parts.push('snap');if(p.subs)h.subs=p.subs;
|
|
return srvOut(h,...(p.upd?[p.upd]:[]),...(p.snap?[p.snap]:[]));}
|
|
function srvSub(inp){const m=inp?JSON.parse(inp):{};return JSON.stringify({v:SIMR.v,subs:srvSubs(m.views)});}
|
|
// The one-shots a page says when a network opens (the courtesy route, Australia's prices): they change S, so the
|
|
// server says them, as fx of the next update.
|
|
function srvGreet(inp){bootNotes();return srvPull(inp);}
|
|
// A checkpoint: the save and its rt, ord included.
|
|
function srvSave(){const txt=JSON.stringify(packSave(S)),K=srvKeyJson(),h=JSON.stringify({uidN,day:S.day,lost:!!S.lost,...srvClockNow()});
|
|
return h.slice(0,-1)+',"rt":'+srvRtText(R,K,srvOrdOut(txt,K),srvSlOut())+'}\\n'+txt;}
|
|
function srvCard(){return JSON.stringify({card:mpCard()});}
|
|
`;
|
|
|
|
// The realm API: one precompiled trampoline per name. Input in __in, a string out; a throw comes back as {srvErr}.
|
|
const API = ['srvLoad', 'srvBegin', 'srvPrefs', 'srvMark', 'srvRestore', 'srvRt', 'srvRPack', 'srvDay', 'srvAct', 'srvAsk', 'srvPull', 'srvSub', 'srvGreet', 'srvSave', 'srvCard'];
|
|
let TRAMP = null;
|
|
const tramps = () => TRAMP || (TRAMP = Object.fromEntries(API.map((n) => [n, new vm.Script(
|
|
`(()=>{try{return ${n}(globalThis.__in);}catch(e){return JSON.stringify({srvErr:String(e&&e.stack||e).slice(0,4000)});}})()`, { filename: `srv-${n}.js` })])));
|
|
// Tests only (createEngine({test})): run a piece of code in a realm, answer its value as JSON.
|
|
const EVAL = new vm.Script('(()=>{const f=new Function(globalThis.__in);const v=f();return v===undefined?"null":JSON.stringify(v);})()', { filename: 'srv-test-eval.js' });
|
|
|
|
/* The game, the epilogue and the build id, compiled once per process. */
|
|
function compileCode({ root = ROOT, page = REALM_PAGE } = {}) {
|
|
if (!vm.constants || vm.constants.DONT_CONTEXTIFY === undefined) {
|
|
throw new Error(`server-run play needs Node 22.8 or newer (vm.constants.DONT_CONTEXTIFY); this is ${process.version}`);
|
|
}
|
|
const src = gameSource({ root, page });
|
|
return {
|
|
game: new vm.Script(src, { filename: 'game.js' }),
|
|
epilogue: new vm.Script(EPILOGUE, { filename: 'srv-epilogue.js' }),
|
|
simId: simId(assemble({ src: path.join(root, 'src'), mp: true }).html),
|
|
root,
|
|
};
|
|
}
|
|
|
|
const DICTS = new Map();
|
|
function dictScript(lang, root) {
|
|
const k = root + '|' + lang;
|
|
if (!DICTS.has(k)) { const s = dictSource(lang, root); DICTS.set(k, s ? new vm.Script(s, { filename: `i18n-${lang}.js` }) : null); }
|
|
return DICTS.get(k);
|
|
}
|
|
|
|
class Realm {
|
|
/* code: compileCode()'s; lang: the network's language; test: {seed, now, step} for tests; log(level, text). */
|
|
constructor({ code, lang = 'en', test = null, log = () => {}, loadMs = 30000 }) {
|
|
const t0 = performance.now();
|
|
const ctx = vm.createContext(vm.constants.DONT_CONTEXTIFY);
|
|
ctx.__hostNow = () => performance.now();
|
|
let n = 0, w0 = 0;
|
|
// The realm's console, rate-limited: 20 lines, then one a second.
|
|
ctx.__hostLog = (lvl, txt) => { const t = Date.now(); if (n > 20 && t - w0 < 1000) return; if (t - w0 >= 1000) { w0 = t; n = Math.min(n, 20); } n++; log(lvl, String(txt).slice(0, 2000)); };
|
|
this.lang = LANG_RE.test(lang) && lang !== 'en' && dictScript(lang, code.root) ? lang : 'en';
|
|
new vm.Script(prelude({ lang: this.lang, test: !!test, ...(test || {}) }), { filename: 'srv-prelude.js' }).runInContext(ctx, { timeout: loadMs });
|
|
const d = this.lang === 'en' ? null : dictScript(this.lang, code.root);
|
|
if (d) d.runInContext(ctx, { timeout: loadMs });
|
|
code.game.runInContext(ctx, { timeout: loadMs });
|
|
code.epilogue.runInContext(ctx, { timeout: loadMs });
|
|
// The no-op timers the page's own start called (two canvas resizes) are not a simulation's.
|
|
new vm.Script('__SRV_T.n=0;if(__SRV_T.at)__SRV_T.at.length=0;').runInContext(ctx);
|
|
this.ctx = ctx;
|
|
this.ms = performance.now() - t0;
|
|
}
|
|
// The answer as the realm gave it (a string). Throws ERR_SCRIPT_EXECUTION_TIMEOUT past ms.
|
|
raw(name, input, ms = 1000) {
|
|
const s = tramps()[name];
|
|
if (!s) throw new Error(`mp-sim-realm: no realm call ${name}`);
|
|
this.ctx.__in = input === undefined ? '' : JSON.stringify(input);
|
|
try { const r = s.runInContext(this.ctx, { timeout: ms }); return typeof r === 'string' ? r : ''; } finally { this.ctx.__in = ''; }
|
|
}
|
|
// The header parsed, plus the parts that follow it.
|
|
call(name, input, ms) { return parts(this.raw(name, input, ms)); }
|
|
// Tests only.
|
|
eval(src, ms = 5000) {
|
|
this.ctx.__in = String(src);
|
|
try { const r = EVAL.runInContext(this.ctx, { timeout: ms }); return JSON.parse(r); } finally { this.ctx.__in = ''; }
|
|
}
|
|
}
|
|
|
|
// [header (parsed), ...parts (strings)] of a realm's answer.
|
|
function parts(text) {
|
|
const t = String(text);
|
|
const i = t.indexOf('\n');
|
|
if (i < 0) return [JSON.parse(t || '{}')];
|
|
const rest = t.slice(i + 1).split('\n');
|
|
return [JSON.parse(t.slice(0, i)), ...rest];
|
|
}
|
|
|
|
const isTimeout = (e) => !!e && e.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT';
|
|
|
|
module.exports = { REALM_PAGE, gameSource, dictSource, prelude, EPILOGUE, API, compileCode, Realm, parts, isTimeout };
|