The review of track T2 found these; each has a test in tests/mp-sim-*.
- Built-ins: an arg, array entry or draft that is '__proto__', 'constructor'
or 'prototype' is refused by the envelope check and again by the realm
(free text may still say them). After every realm call the trampoline
checks the realm's built-ins against what they were at load; a realm
whose built-ins changed answers {srvErr, polluted} and is replaced from
the worker's mark like one that timed out. S as one JSON per key is a
null-prototype object, so the epilogue's for…in never reads a prototype.
- A realm that cannot be built again is never used again: rebuild() tries
once more without the packed R, and when that fails too the network is
dropped (NO_REALM), and the engine tells the host (opts.onLost).
- A mark that fails or runs out of time changes nothing: it clears the old
mark first, the realm is built again from its own save, never from an
older mark, and the reply names the mark. A day rebuilds only from its
own attempt's mark.
- A day whose alone or nets is not a list is refused whole (ERR); a throw
in a load or day step answers that call, never ends the worker.
- An exit counts against the session the worker was running (the worker
says so before each job and step), else as before. Workers of their own
are capped (opts.maxOwn, 4): past that a session is given up.
- A worker that exits before it is ready is started again after a pause
that doubles; after 5 in a row every call answers SIM_DOWN.
- The game text is read and compiled once, in createEngine: a src/ that
does not compile throws there, and every worker, also one started after
an exit, runs the game engine.simId names.
- A damaged route memory never breaks a save that loads (routed from
nothing, logged), and only a server network loads (S.mp.sim, Normal).
- Routing memory (UI.rk, UI.rkR) is kept by the in-place restore and
carried in rt (rk), so a reloaded or rolled-back network skips the same
routings as the one that kept going.
- A fresh realm takes over the fx of the one it replaces (the mark's after
a failed call, all of them after a read): badges, windows and toasts
waiting for a page are not lost to a timeout.
- Windows: the stand-in elements answer querySelector from what was
written (a [data-x] marker) and have a working classList, never the
inert proxy that said every window is open. A request's ctx may name the
open window, ctx.win = {k, ui} (mp-sim-acts.js WINDOWS: bstd, routing,
charter, ops, pie), with the view state only the page holds (the
intern's POP, the pie window's tab and POP), checked in the realm. This
is an addition to the contract of design 5.8 that the page (T4) sends.
The stand-in is hidden again after an act.
- xpBuild's via is a TEXT arg (256): a six-span express fits.
- actDone, askDone and pulled carry ms, the worker time of the call;
engine.mem() and engine.has(code, nid) are public; prefs() passes a
realm's err through; after close() every call rejects CLOSED.
- The fake engine fails as the engine does (NO_REALM, ERR, a load without
a save, a day of an unknown session or naming an unloaded network,
GAVE_UP, SIM_DOWN, CLOSED, onLost), its greet says its one-shots once and
never 'told'; a test runs the same edge calls on both.
- SIM_DRAFT is built from DRAFT_TYPES.
562 lines
49 KiB
JavaScript
562 lines
49 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 after which the realm's built-ins are not what
|
|
// they were at load (a prototype written through) answers {"srvErr", "polluted":1}, and the realm must not be used for
|
|
// play again; a call that runs over its time limit throws ERR_SCRIPT_EXECUTION_TIMEOUT here, and the realm must not be
|
|
// used for play again either (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, src, simId}) {game, epilogue, simId} as vm.Scripts, once per process (a worker); src and
|
|
// simId: the game text and build id the engine read once (every worker runs the same)
|
|
// 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==='querySelector'||k==='querySelectorAll')return s=>_q(o._h,s,k==='querySelectorAll');if(k==='classList')return _cls(o);
|
|
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;}});};
|
|
// Which window is open, as the game asks it (pieRe, bstdShown, routingRefresh, the sea survey: a class, or a [data-x] /
|
|
// [data-x="v"] marker inside the card), is answered from what was written, never with the inert proxy, which would say
|
|
// every window is open. Other selectors match nothing; matches carry their data-* attributes. (closest() stays inert:
|
|
// a stand-in has no ancestors, and the page's own start asks one for its chip.)
|
|
const _cls=o=>{const g=()=>String(o.className||'').split(/\\s+/).filter(Boolean),p=a=>{o.className=a.join(' ');};
|
|
return new Proxy({contains:c=>g().includes(String(c)),add:(...c)=>p([...new Set([...g(),...c.map(String)])]),remove:(...c)=>{const x=c.map(String);p(g().filter(y=>!x.includes(y)));},
|
|
toggle:(c,f)=>{c=String(c);const on=f===undefined?!g().includes(c):!!f;p(on?[...new Set([...g(),c])]:g().filter(y=>y!==c));return on;}},{get:(t,k)=>k in t?t[k]:_n});};
|
|
const _cc=x=>x.replace(/-([a-z])/g,(q,c)=>c.toUpperCase());
|
|
const _ds=a=>{const d=Object.create(null);a.replace(/\\sdata-([a-z0-9-]+)(?:\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+)))?/gi,(m,k,x,y,z)=>{d[_cc(k.toLowerCase())]=_txt(x??y??z??'');return m;});return d;};
|
|
const _q=(h,sel,all)=>{const m=/^\\[data-([a-z0-9-]+)(?:=(?:"([^"]*)"|'([^']*)'|([^\\]"']*)))?\\]$/i.exec(String(sel).trim()),out=[];
|
|
if(m){const k=_cc(m[1].toLowerCase()),v=m[2]??m[3]??m[4],re=/<([a-zA-Z][a-zA-Z0-9]*)(\\s[^>]*)?>/g;let t;
|
|
while((t=re.exec(h))){const d=_ds(t[2]||'');if(Object.hasOwn(d,k)&&(v===undefined||d[k]===v)){out.push(_el(t[1],{dataset:d}));if(!all)break;}}}
|
|
return all?out:out[0]||null;};
|
|
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, DRAFT_TYPES: ACTS.DRAFT_TYPES, PREFS: ACTS.PREFS, TEXT: ACTS.TEXT, WINDOWS: ACTS.WINDOWS });
|
|
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=Object.keys(SIMT.DRAFT_TYPES);
|
|
// 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));}
|
|
/* The realm's built-ins as the game left them at load. A click that writes through a prototype (a city named
|
|
__proto__ or constructor) changes them, and every for…in, the game's and this file's, would carry that from then on.
|
|
The trampoline checks after every call; a realm whose built-ins changed is replaced like one that timed out. */
|
|
const srvFp=(()=>{const n=Object.getOwnPropertyNames,L=[Object,Object.prototype,Array,Array.prototype,Function.prototype,String.prototype,Number.prototype,Boolean.prototype,Map.prototype,Set.prototype];
|
|
return ()=>{for(const k in {})return 'Object.prototype.'+k;for(const k in [])return 'Array.prototype.'+k;return L.map(o=>n(o).length).join(',');};})();
|
|
const SIM_FP0=srvFp();
|
|
function srvDirty(){const f=srvFp();return f===SIM_FP0?'':/^(Object|Array)\\./.test(f)?f:'a built-in has a new property';}
|
|
// Strings no arg names: written through as a key, they reach a prototype. Free text (TEXT) may say them.
|
|
const SIM_BADV=new Set(['__proto__','constructor','prototype']);
|
|
const srvBadV=v=>typeof v==='string'?SIM_BADV.has(v):Array.isArray(v)?v.some(srvBadV):!!v&&typeof v==='object'&&Object.keys(v).some(k=>SIM_BADV.has(k)||srvBadV(v[k]));
|
|
const srvBadArgs=(act,a)=>{const t=srvOwn(SIMT.TEXT,act)?SIMT.TEXT[act]:{};return Object.keys(a).some(k=>SIM_BADV.has(k)||(!srvOwn(t,k)&&srvBadV(a[k])));};
|
|
|
|
/* 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=Object.create(null);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,rk){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:'')+(rk?',"rk":true':'')+',"sl":'+JSON.stringify(sl||[])+'}';}
|
|
// rk: R is the routing of S as it is (routeIfChanged's memory, UI.rk and UI.rkR, against K: routeKey() is the join of
|
|
// K without RK_SKIP). A fresh realm given it skips the routing of a click that changes nothing routing reads, as this
|
|
// one would; without it that click routes again, and compute() is not always a fixed point.
|
|
const srvRkOk=(r,K,rk,rkR)=>{if(!K||rkR!==r||typeof rk!=='string')return false;let t='{',f=true;for(const k in K){if(RK_SKIP.has(k))continue;t+=(f?'':',')+JSON.stringify(k)+':'+K[k];f=false;}return t+'}'===rk;};
|
|
const srvKeysOf=s=>{const o=JSON.parse(s),K=Object.create(null);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){const K=srvKeyJson();return srvRtText(R,K,'',srvSlOut(),srvRkOk(R,K,UI.rk,UI.rkR));}
|
|
if(SIMR.markRt)return SIMR.markRt;
|
|
if(!k)return srvRtText(R,null,'',[]);
|
|
const K=SIMR.markK||srvKeysOf(k.s);return srvRtText(k.R,K,'',k.sl,srvRkOk(k.R,K,k.ui.rk,k.ui.rkR));}
|
|
/* 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];}
|
|
/* The window the page has open (ctx.modal; ctx.win names it, mp-sim-acts.js WINDOWS): the stand-in #modal is that
|
|
window as the game asks it (its class, its marker), with the view state it draws from (checked here). No win: no
|
|
window, or one nothing asks about. The view state of an earlier request never stays. */
|
|
const SIM_WINUI=[...new Set(Object.values(SIMT.WINDOWS).flatMap(w=>w.ui||[]))];
|
|
const SIM_WINOK={opsCity:v=>srvOwn(S.pops,v),pieCity:v=>srvOwn(S.pops,v),pieTab:v=>PIE_TABS.includes(v)};
|
|
function srvWin(c){const w=c&&c.win&&typeof c.win==='object'?c.win:null,W=w&&typeof w.k==='string'&&srvOwn(SIMT.WINDOWS,w.k)?SIMT.WINDOWS[w.k]:null,m=$('modal');
|
|
for(const k of SIM_WINUI)delete UI[k];
|
|
m.hidden=!((c&&c.modal===true)||W);m.className=W?W.c:'';$('modalCard').innerHTML=W&&W.sel?'<div '+W.sel.slice(1,-1)+'></div>':'';
|
|
if(W&&W.ui&&w.ui&&typeof w.ui==='object')for(const k of W.ui){const v=w.ui[k];if(typeof v==='string'&&srvOwn(SIM_WINOK,k)&&SIM_WINOK[k](v))UI[k]=v;}}
|
|
function srvWinOff(){const m=$('modal');m.hidden=true;m.className='';$('modalCard').innerHTML='';}
|
|
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;srvWinOff();}
|
|
|
|
/* 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. A damaged rt
|
|
never breaks a save that loads: R is routed from nothing then (close, logged). fx: the fx a fresh realm takes over
|
|
from the one it replaces (srvFxOut). Only a server network loads: a Normal game with the session's marks (S.mp.sim;
|
|
a local save is stamped on its way in, 5.2), else the load fails with the reason. */
|
|
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));
|
|
{const no=S.mode!=='normal'||S.scn?'server networks are Normal games':!S.mp||S.mp.sim!==1?'not a server network (S.mp.sim)':'';if(no)throw new Error('srvLoad: '+no);}
|
|
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)){try{R=srvRtIn(rt);compute();}catch(e){srvLog('the route memory does not load ('+String(e&&e.message||e).slice(0,200)+'): routed from nothing');R=emptyR();compute();}}
|
|
if(rt.rk===true){UI.rk=routeKey();UI.rkR=R;}
|
|
srvSlIn(rt.sl);
|
|
srvFresh(m.epoch);
|
|
if(m.fx&&typeof m.fx==='object'&&Array.isArray(m.fx.fx)){SIMR.fx=m.fx.fx.filter(f=>Array.isArray(f)&&typeof f[0]==='string').slice(-200);SIMR.floats=Math.min(40,Math.max(0,m.fx.floats|0));}
|
|
// 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,rk:UI.rk,rkR:UI.rkR}};
|
|
// As text: nothing the day does reaches it.
|
|
const rtJ=m.day?srvRtText(R,K,'',sl,srvRkOk(R,K,UI.rk,UI.rkR)):'';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;srvWinOff();
|
|
return JSON.stringify({parsed});}
|
|
// The fx a fresh realm takes over from this one: the mark's after a failed call (its own fx are dropped, 4.3), else
|
|
// (a read that ran out of time) all of them. Badges and windows wait for a page for days; a timeout does not lose them.
|
|
function srvFxOut(inp){const m=inp?JSON.parse(inp):{},k=SIMR.mark;return JSON.stringify(m.mark&&k?{fx:k.fx,floats:k.floats}:{fx:SIMR.fx,floats:SIMR.floats});}
|
|
|
|
/* 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 if(srvBadArgs(act,args)||srvBadV(m.ui))done('rejected','an arg names a built-in');
|
|
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);srvWin(c);
|
|
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;}}}}
|
|
srvWinOff();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,hot=UI.hotMap;
|
|
if(srvBadArgs(act,args))return JSON.stringify({err:'an arg names a built-in'});
|
|
srvView(m.ctx);srvWin(m.ctx);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;UI.hotMap=hot;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;srvWinOff();
|
|
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||Object.create(null),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(),srvRkOk(R,K,UI.rk,UI.rkR))+'}\\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}, and
|
|
// changed built-ins as {srvErr, polluted}. The unchecked ones only read what a fresh realm needs from one that is done
|
|
// (its save, rt, R and fx): the worker's recovery after a timeout or a pollution.
|
|
const API = ['srvLoad', 'srvBegin', 'srvPrefs', 'srvMark', 'srvRestore', 'srvRt', 'srvRPack', 'srvFxOut', 'srvDay', 'srvAct', 'srvAsk', 'srvPull', 'srvSub', 'srvGreet', 'srvSave', 'srvCard'];
|
|
const PEEK = ['srvRt', 'srvRPack', 'srvFxOut', 'srvSave'];
|
|
let TRAMP = null, TRAMP0 = null;
|
|
const tramp = (n, check) => new vm.Script(`(()=>{let r;try{r=${n}(globalThis.__in);}catch(e){r=JSON.stringify({srvErr:String(e&&e.stack||e).slice(0,4000)});}`
|
|
+ (check ? `const d=srvDirty();return d?JSON.stringify({srvErr:'the built-ins of the realm changed: '+d,polluted:1}):r;})()` : 'return r;})()'), { filename: `srv-${n}.js` });
|
|
const tramps = (check = true) => (check ? TRAMP || (TRAMP = Object.fromEntries(API.map((n) => [n, tramp(n, true)])))
|
|
: TRAMP0 || (TRAMP0 = Object.fromEntries(PEEK.map((n) => [n, tramp(n, false)]))));
|
|
// 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. The engine passes the game text and its build
|
|
id (read once, in the main thread), so a worker started later runs the game the engine names, whatever src/ holds by
|
|
then; without them they are read from root. */
|
|
function compileCode({ root = ROOT, page = REALM_PAGE, src = null, simId: id = null } = {}) {
|
|
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 game = typeof src === 'string' && src ? src : gameSource({ root, page });
|
|
return {
|
|
game: new vm.Script(game, { filename: 'game.js' }),
|
|
epilogue: new vm.Script(EPILOGUE, { filename: 'srv-epilogue.js' }),
|
|
simId: id || 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)); };
|
|
// A language this server has no dictionary for plays in English (the page falls back the same way), not broken.
|
|
let d = null;
|
|
if (LANG_RE.test(lang) && lang !== 'en') { try { d = dictScript(lang, code.root); } catch (e) { log('warn', `no dictionary for ${lang}: English`); } }
|
|
this.lang = d ? lang : 'en';
|
|
new vm.Script(prelude({ lang: this.lang, test: !!test, ...(test || {}) }), { filename: 'srv-prelude.js' }).runInContext(ctx, { timeout: loadMs });
|
|
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. check false: one of PEEK,
|
|
// whatever the built-ins are now (recovery only).
|
|
raw(name, input, ms = 1000, check = true) {
|
|
const s = tramps(check)[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 };
|