Pie in the Sky: a full constellation pays back in about seven years

Rule O7's payback half is now played through the game loop
(tests/pie-balance.test.js): the big-network save runs a full lasered
Shortcrust by a sensible policy until its books balance, in 5 to 10 years
(6.3 on seed 7; 7.4 and 6.9 on seeds 11 and 3). The static formula is gone.

Retune: pies $0.5M (+$0.25M lasers), from $1M (+$0.5M); landing rights
$12,000 per eyeball up to $100M a year, from $28,000 up to $200M; orbit
rates x1.25 (pizza 25k, flywifi 36k, boat 27.5k, marsorb 44k); PIE_SELL
0.25 -> 0.4; PIE_OFFER_RATE 1/6 -> 1/3.
This commit is contained in:
Frederic Jung 2026-11-04 10:20:56 +01:00
parent 46ba4e04d2
commit 1de0723c35
No known key found for this signature in database
9 changed files with 103 additions and 45 deletions

View file

@ -639,38 +639,8 @@ test('O7: a fresh Tier 1 cannot afford a full Shortcrust in its first year', ()
assert.deepEqual(g.errors, []);
});
// Years a full crust takes to pay for itself: the build (company, factory, pad, rockets, lasered pies, the dishes it needs
// and landing rights) over a year's orbit income less running costs, licences and replacing the pies as they age out.
const PAYBACK = `((cr,rev,dishes,lic)=>{const C=CRUSTS[cr],ndish=dishes??Math.ceil(C.g*PIE_SELL/(PIE_ANT_MAX*PIE_ANT_G));
const build=pieFullCost(cr)+C.full*PIE_LAS+ndish*piePrice(PIE_DISH+PIE_ANT*PIE_ANT_MAX)+lic;
const renew=(C.full*(PIE_PIE+PIE_LAS)+Math.ceil(C.full/ROCKETS.heavy.pies)*ROCKETS.heavy.cost)/(C.life/360);
return build/(12*rev-12*(PIE_CO_MO+PIE_FAC_MO+PIE_PAD_MO+ndish*PIE_DISH_MO)-lic-renew);})`;
test('O7: a full constellation never pays back in under 5 years, and a strong network’s pays back in 5 to 10', () => {
const g = load();
// (A negative answer: it never pays back.) The best case for every crust: every Gbps the sky can sell is sold, the capped kinds at their cap, the rest at the
// dearest rate, all served. A dish needs a city of its own (one per POP), so the dishes it takes pay the cheapest
// landing rights any set of that many covered cities in the world could have.
const best = JSON.parse(g.ev(`JSON.stringify(Object.keys(CRUSTS).map(cr=>{const T=Object.values(BIZ_T).filter(t=>t.orbit);let left=1,r=0;
for(const t of T.filter(t=>t.share)){r+=t.share*t.rate;left-=t.share;}r+=left*Math.max(...T.filter(t=>!t.share).map(t=>t.rate));
const nd=Math.ceil(CRUSTS[cr].g*PIE_SELL/(PIE_ANT_MAX*PIE_ANT_G)),n={};for(const c of CITIES)if(pieCovers(cr,c.id))n[c.cc]=(n[c.cc]||0)+1;
let k=0,lic=0;for(const cc of Object.keys(n).sort((a,b)=>pieLicPrice(a)/n[a]-pieLicPrice(b)/n[b])){if(k>=nd)break;k+=n[cc];lic+=pieLicPrice(cc);}
return [cr,${PAYBACK}(cr,CRUSTS[cr].g*PIE_SELL*r,nd,lic)];}))`));
for (const [cr, y] of best) assert.ok(y < 0 || y >= 5, `O7: a full ${cr} pays back in ${y.toFixed(1)} years at best; make orbit dearer or its customers cheaper`);
// The seeded reference: the big-network save, a full lasered Shortcrust, 32 full dishes in the cheapest countries to
// license, and every orbit customer the market offers signed (the real offers, routed by compute()).
const save = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
g.ev(`S=migrate(JSON.parse(${JSON.stringify(save)}));S.pieV=1;S.nextFail=1e9;S.nextEvent=1e9;__reseed(7);compute()`);
const ref = JSON.parse(g.ev(`(()=>{pieInit();const P=S.pie;P.co={name:PIE_NAMES[0]};P.fac=true;P.pads=[{city:'mia',next:0,boosters:[]}];
const pops=Object.keys(S.pops).filter(c=>pieCovers('short',c)),n={};for(const c of pops)n[CITY[c].cc]=(n[CITY[c].cc]||0)+1;
const top=pops.sort((a,b)=>pieLicPrice(CITY[a].cc)/n[CITY[a].cc]-pieLicPrice(CITY[b].cc)/n[CITY[b].cc]||CITY[b].P-CITY[a].P).slice(0,32);
for(const c of top){P.dishes.push({id:'d'+c,city:c,ant:PIE_ANT_MAX,down:0});P.lic[CITY[c].cc]={state:'ok',until:1e6};}
P.crusts.short.cohorts=[{n:CRUSTS.short.full,day:S.day,las:true}];compute();
for(let i=0;i<4000&&pieSold()<pieMarket()-20;i++){S.offers=S.offers.filter(o=>!BIZ_T[o.type].orbit);const t=pieOfferTypes();if(!t.length)break;pieSpawn(pick(t));const o=S.offers.find(o=>BIZ_T[o.type].orbit);if(o)ACT.accept({id:o.id});}
compute();const lic=Object.keys(P.lic).reduce((a,cc)=>a+pieLicPrice(cc),0);return JSON.stringify({rev:R.pie.rev,y:${PAYBACK}('short',R.pie.rev,top.length,lic)});})()`));
assert.ok(ref.y >= 5 && ref.y <= 10, `O7: the reference Shortcrust pays back in ${ref.y.toFixed(1)} years on ${Math.round(ref.rev / 1e6)}M/mo from orbit; aim for 6 to 10`);
assert.deepEqual(g.errors, []);
});
// O7's other half (a full lasered Shortcrust pays back in 5 to 10 years, never sooner) is played through the game loop
// in tests/pie-balance.test.js, so it counts launches, aging, incidents, churn and every running cost.
test('no page errors while checking the rules', () => {
assert.deepEqual(errors, []);

85
tests/pie-balance.test.js Normal file
View file

@ -0,0 +1,85 @@
// Rule O7, played: the big-network save becomes a rocket company and runs a full lasered Shortcrust through the real
// day tick (pieDay, launches, aging, incidents, spats, offers, moods, orbit income), by a sensible player's policy.
// Seeded. Orbit is judged on its own books (S.pie.book): the fixture's ground network loses money on its own.
// It plays until the books balance (at most 10 years). PIE_BALANCE_YEARS=10 node --test tests/pie-balance.test.js plays
// that many years whatever happens and prints them year by year, PIE_BALANCE_DIAG=1 also monthly with the spending by kind
// and PIE_BALANCE_SEED another seed (for tuning).
const test = require('node:test');
const assert = require('node:assert/strict');
const fs = require('node:fs');
const path = require('node:path');
const { load } = require('./harness');
const YEARS = +(process.env.PIE_BALANCE_YEARS || 0);
// The policy, once a day before the tick:
// - a company, a factory, the reuse R&D and two pads, the coastal POPs nearest the equator;
// - lasered Shortcrust on the reusable rocket while the crust is short of full (never past it: replacements only), at most
// two launches per pad in the queue;
// - safe mode while a solar storm is on;
// - the ground grows with the customers: an antenna on the busiest dish when one is over 90% or the healthy dishes (fiber
// there at least 97% up) hold less than 1.3x what is sold, a new dish when every healthy dish has 16, at a well-served
// POP under the crust (fiber at least 98% up), cheapest landing rights first, the first eight spread out;
// - landing rights renewed before they lapse, every orbit offer signed.
// compute() runs every 30 days and whenever what the sky carries changes (coverage in 10% steps, hubs, lasers,
// safe mode, an orbit incident or spat starting or ending); orbit income is booked from the last one, as in the game.
function sim(days, stop = false, seed = 7) {
const g = load({ seed });
const save = fs.readFileSync(path.join(__dirname, 'fixtures', 'big-network.json'), 'utf8');
g.ev(`S=migrate(JSON.parse(${JSON.stringify(save)}));S.pieV=1;UI.started=true;UI.pitched=true;UI.speed=0;S.nextFail=1e9;S.nextEvent=1e9;
isTier1=()=>true;after=()=>{};pieModal=()=>{};compute();pieInit();UI.pieLas=true;ACT.pieFound();ACT.pieFactory();ACT.pieRd({k:'reuse'});
for(const c of Object.keys(S.pops).filter(c=>pieCoast(c)&&piePadOk(c,'short')).sort((a,b)=>Math.abs(CITY[a].lat)-Math.abs(CITY[b].lat)).slice(0,2))ACT.piePad({city:c});
window.__site=()=>{const ds=S.pie.dishes,lic=c=>pieLicOk(CITY[c].cc)?0:pieLicPrice(CITY[c].cc);
const c=Object.keys(S.pops).filter(c=>pieCovers('short',c)&&!ds.some(x=>x.city===c)&&sfOf(R,c)>=0.98).sort((a,b)=>lic(a)-lic(b)||CITY[b].P-CITY[a].P);
return (ds.length<8&&c.find(x=>ds.every(d=>pieKm(d.city,x)>=1500)))||c[0];};
window.__step=()=>{const P=S.pie,C=CRUSTS.short,rk=P.rd.reuse?'again':'falcon';S.nextFail=1e9;S.nextEvent=1e9;let dirty=false;
while(P.q.length<2*P.pads.length&&pieLive('short')+P.crusts.short.queued+ROCKETS[rk].pies<=C.full){if(!pieQuote(rk,'short',{las:true}).ok)break;ACT.pieLaunch({rk,cr:'short'});}
const storm=S.inc.some(i=>i.type==='piestorm'&&i.until>S.day);if(storm!==P.safe){ACT.pieSafe();dirty=true;}
if(pieUp('short')){const ok=x=>pieLicOk(CITY[x.city].cc)&&sfOf(R,x.city)>=0.97,u=x=>((R.pie&&R.pie.used[x.city])||0)/(x.ant*PIE_ANT_G);
const cap=pieDishes().filter(ok).reduce((a,d)=>a+d.g,0),need=Math.min(pieMarket(),pieSold()*1.3+400);
if(cap<need||P.dishes.some(x=>ok(x)&&u(x)>0.9&&x.ant<PIE_ANT_MAX)){const d=P.dishes.filter(x=>ok(x)&&x.ant<PIE_ANT_MAX).sort((a,b)=>u(b)-u(a))[0];
if(d)ACT.pieAnt({id:d.id});else{const c=__site();if(c){if(!pieLicOk(CITY[c].cc))ACT.pieLic({cc:CITY[c].cc});ACT.pieDish({city:c});}}}}
for(const d of P.dishes){const l=P.lic[CITY[d.city].cc];if(l&&l.state==='ok'&&l.until-S.day<5)ACT.pieLic({cc:CITY[d.city].cc});}
for(const o of S.offers.filter(o=>BIZ_T[o.type].orbit))ACT.accept({id:o.id});
const key=[pieHubs().join(),Math.round(pieCarry('short')*10),Math.round(pieCov('short')*10),pieLased('short'),P.safe,S.inc.filter(i=>PIE_INC.includes(i.type)&&i.until>S.day).map(i=>i.id).join(),Object.keys(P.spat).join()].join('|');if(key!==window.__key)dirty=true;window.__key=key;
const real=compute;compute=()=>{if(dirty||S.day%30===0){window.__nC=(window.__nC||0)+1;real();}};try{dayTick();}finally{compute=real;}};
window.__year=()=>({y:Math.round(S.day/360),spent:S.pie.book.spent,earned:S.pie.book.earned,mo:(R.pie&&R.pie.rev)||0,cov:pieCov('short'),cust:S.biz.filter(b=>BIZ_T[b.type].orbit).length,dishes:S.pie.dishes.length,nC:window.__nC|0});
closeModal()`);
if (process.env.PIE_BALANCE_DIAG) g.ev(`window.__B={};for(const k of ['pieLaunch','pieDish','pieAnt','pieLic','pieRd','pieFound','pieFactory','piePad','fixInc','pieSpatPick']){const f=ACT[k];if(!f)continue;ACT[k]=a=>{const s0=S.pie.book.spent;const r=f(a);__B[k]=(__B[k]||0)+(S.pie.book.spent-s0)/1e6;return r;};}
{const f=pieDay;pieDay=d=>{const s0=S.pie.book.spent;f(d);__B.day=(__B.day||0)+(S.pie.book.spent-s0)/1e6;};}`);
const rows = [];
try {
const d0 = g.ev('S.day');
for (let d = 1; d <= days; d++) {
g.ev('__step()');
if (d % 360 === 0) { rows.push(JSON.parse(g.ev('JSON.stringify(__year())'))); if (stop && rows[rows.length - 1].earned >= rows[rows.length - 1].spent) break; }
if (process.env.PIE_BALANCE_DIAG && d % 30 === 0) console.log(d, g.ev(`JSON.stringify({c:S.biz.filter(b=>BIZ_T[b.type].orbit).length,un:S.biz.filter(b=>BIZ_T[b.type].orbit&&!((R.pie.sf[b.id]||0)>=0.95)).length,mo:Math.round(R.pie.rev/1e6),hubs:pieHubs(),las:pieLased('short'),cov:+pieCov('short').toFixed(2),inc:S.inc.filter(i=>i.type.startsWith('pie')).map(i=>i.type),spat:Object.keys(S.pie.spat),safe:S.pie.safe,B:Object.fromEntries(Object.entries(__B).map(([k,v])=>[k,Math.round(v)]))})`));
}
rows.d0 = d0;
} finally { g.ev('closeModal()'); }
return { rows, errors: g.errors, ev: g.ev };
}
// The year the books balance, within the year it happens. The run stops there (at most 10 years); one that never
// balances is carried on by its last year's net, for the message.
function payback(rows) {
for (let i = 0; i < rows.length; i++) {
const r = rows[i], p = rows[i - 1] || { y: 0, spent: 0, earned: 0 };
if (r.earned >= r.spent) return p.y + (p.spent - p.earned) / ((r.earned - p.earned) - (r.spent - p.spent));
}
const a = rows[rows.length - 2], b = rows[rows.length - 1], net = (b.earned - a.earned) - (b.spent - a.spent);
return net > 0 ? b.y + (b.spent - b.earned) / net : Infinity;
}
test('O7: a full lasered Shortcrust, run sensibly through the game loop, pays back in 5 to 10 years', { timeout: 600000 }, () => {
const years = YEARS || 10;
const { rows, errors } = sim(360 * years, !YEARS, +(process.env.PIE_BALANCE_SEED || 7));
if (YEARS) for (const r of rows) console.log(`year ${r.y}: spent ${(r.spent / 1e9).toFixed(2)}B, earned ${(r.earned / 1e9).toFixed(2)}B, orbit ${(r.mo / 1e6).toFixed(0)}M/mo, ${Math.round(r.cov * 100)}% covered, ${r.cust} customers, ${r.dishes} dishes, ${r.nC} computes`);
const last = rows[rows.length - 1], y = payback(rows);
if (YEARS) console.log(`payback: year ${y.toFixed(1)}`);
assert.ok(last.cov > 0.9, `O7: the crust is full after ${years} years (${Math.round(last.cov * 100)}%)`);
assert.ok(last.cust > 30, `O7: customers stay (${last.cust})`);
assert.ok(y >= 5, `O7: a full Shortcrust pays back in ${y.toFixed(1)} years; make orbit dearer or its customers fewer`);
assert.ok(y <= 10, `O7: a full Shortcrust pays back in ${y.toFixed(1)} years (spent ${(last.spent / 1e9).toFixed(1)}B, earned ${(last.earned / 1e9).toFixed(1)}B by year ${last.y}); make orbit cheaper or its customers more`);
assert.deepEqual(errors, []);
});

View file

@ -81,7 +81,7 @@ test('actions cost what they should', () => {
assert.equal(step(`ACT.pieAnt({id:'${id}'})`), ev('piePrice(PIE_ANT)'));
assert.equal(step("ACT.pieLic({cc:'DE'})"), ev("pieLicPrice('DE')"));
assert.ok(ev("pieLicPrice('US')") > ev("pieLicPrice('LU')"), 'big markets cost more');
assert.ok(ev("pieLicPrice('US')") <= 200e6 && ev("pieLicPrice('MH')") >= 10e6);
assert.ok(ev("pieLicPrice('US')<=PIE_LIC_MAX") && ev("pieLicPrice('MH')") >= 10e6);
assert.equal(ev("pieLicOk('DE')&&pieDishes().length"), 1, 'a licensed dish is live');
// a launch: rocket with the equatorial discount, 20 pies, the party later
ev('S.pie.stock=100');