Phase 4: close loot/refund leaks, landing-site garrisons, speed-scaled shipping, update/offsite tooling, broad e2e
Built: - Economy: raid loot capped to the room the raiders have at home (rest stays with the victim, "lootLeft" in the report); trade escrow reserves its room so refunds always fit; trade accept refuses with no_room_for_goods when the goods would not fit. Loot destroyed per 30-day run 31-61k -> ~1k, refunds clipped ~27k -> 0 (docs/BALANCE.md, 3 seeds). - End game: members of the holding alliance garrison landing sites (migration 005_site_garrison.sql), garrison counts in site defence, 72 h capture shield, withdraw route, POP view lists garrisoned units. Shipping capacity scales with world speed (3x world: winner 76-98 -> ~30-36 days after sites open). Bot runs show real contests (84-194 attacks on held sites at 1x). - Ops: deploy/update.sh (backup, stop, ff-merge, npm ci --ignore-scripts, health check, rollback), deploy/upstream-offsite (rsync only), admin end-world snapshots results, EPIPE fix, docs/workflows/ filled in. - e2e 62 -> 163 checks: units, raids/reports, alliance+messages, trade, end game, nb, PWA, reconnect, slow polling fallback (opt-in). Two app bugs found: message push ignored, "New" button stayed English. Tested: npm test 274/274, openapi check, npm run e2e 163/163 (137 s), bot runs 50x30d seeds 1-3 and 140-day/60-day speed-3 end-game runs INVARIANTS OK, adversarial review pass (findings fixed or documented). NOT tested: update.sh on a real box (systemd, real npm, runuser; stubs only, shellcheck not installed), garrison card/loot text on a phone, Node 22.13, humans. Known leaks left open and documented (BALANCE S6): loot/shipments can still overflow when stock arrives in flight, bounced backbone shipments lose overflow (reported to the sender). Garrison numbers (heldDefenceMult 2, shield 72 h) are first guesses from 2 seeds. Not claimed: balanced. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Q2MJaQ5LXAHzGnTDgceT14
This commit is contained in:
parent
9104480463
commit
3c23c51902
92 changed files with 4887 additions and 300 deletions
|
|
@ -1,9 +1,14 @@
|
|||
'use strict';
|
||||
/*
|
||||
* Arrival of a scan or an attack at a backbone landing site (hooked from combat.arriveSite, runs inside the `arrive` event).
|
||||
* A site is defended by a static value only: rules.backboneDefence(seed, x, y, world age, node level). Beating it as a member
|
||||
* of an alliance makes that alliance the holder (level, stockpile and a running build stay with the site). The site never
|
||||
* loses anything, so there is no loot and no raid; survivors drive home. Re-validates at arrival like every movement.
|
||||
* Arrival of a scan, an attack or a reinforcement at a backbone landing site (scan/attack hooked from combat.arriveSite, reinforce from
|
||||
* arrivals.arriveReinforce; all run inside the `arrive` event, at its due time, so waves resolve strictly in arrival order).
|
||||
*
|
||||
* Defence of a site = static value (rules.backboneDefence: heavy while nobody holds it, a modest `heldDefenceMult` once an alliance does,
|
||||
* both growing with the node level) + the garrison: units that members of the holding alliance stationed there (server/military/garrison.js,
|
||||
* DECISIONS E6), counted with their owner's defence research while their owner POP is online. A lost attack kills the same share of the
|
||||
* garrison as it would in a POP (ratio^1.5 of its units), so the next wave faces less; a won attack wipes it and the attacker's alliance
|
||||
* holds the site (level, stockpile and a running build stay with the site). The static part loses nothing; survivors drive home.
|
||||
* Re-validates at arrival like every movement.
|
||||
*/
|
||||
const R = require('../../public/js/rules.js');
|
||||
const D = require('../../public/js/data.js');
|
||||
|
|
@ -11,10 +16,21 @@ const U = require('./units');
|
|||
const M = require('./movements');
|
||||
const E = require('../endgame');
|
||||
const { createReport } = require('./reports');
|
||||
const G = require('./garrison');
|
||||
const P = require('./power');
|
||||
const { loadTown, loadWorld, settle } = require('../state');
|
||||
const { bounce, townBrief, opBrief } = require('./arrivals');
|
||||
|
||||
const SCAN_STRENGTH = D.ENDGAME.scanStrength; // a landing site counts as this many defending scanners
|
||||
|
||||
// Battle points (the same bookkeeping as POP combat; combat.js keeps its own copy of this helper private).
|
||||
function addPoints(db, operatorId, column, v) {
|
||||
if (!operatorId || !(v > 0)) return;
|
||||
db.run('INSERT INTO operator_stats (operator_id, attack_points, defense_points) VALUES (?, 0, 0) ON CONFLICT (operator_id) DO NOTHING', operatorId);
|
||||
const col = column === 'attack' ? 'attack_points' : 'defense_points';
|
||||
db.run('UPDATE operator_stats SET ' + col + ' = ' + col + ' + ? WHERE operator_id = ?', v, operatorId);
|
||||
}
|
||||
|
||||
function sendHome(ctx, mv, survivors) {
|
||||
if (U.isEmpty(survivors)) return null;
|
||||
const dest = U.homeTownFor(ctx.db, mv.ownerId, mv.fromTownId);
|
||||
|
|
@ -22,7 +38,27 @@ function sendHome(ctx, mv, survivors) {
|
|||
return M.launchReturn(ctx, { worldId: mv.worldId, ownerId: mv.ownerId, fromTownId: null, at: mv.to, to: dest, units: survivors, cargo: {}, parentId: mv.id, extra: {} });
|
||||
}
|
||||
|
||||
module.exports = function arriveLanding(ctx, mv, now, world, tile) {
|
||||
// A member of the holding alliance's units reach the site: they join its garrison. Anybody else, or a site that changed hands on the road, bounces them.
|
||||
function reinforce(ctx, mv, ev) {
|
||||
const { db } = ctx;
|
||||
const now = ev.dueAt;
|
||||
const world = loadWorld(db, mv.worldId);
|
||||
const tile = R.tileAt(world.seed, world.map_radius, mv.to.x, mv.to.y, E.ageDays(world, now));
|
||||
if (tile.type !== 'backbone') return bounce(ctx, mv, now, 'invalid_target');
|
||||
const site = E.ensureSites(db, world, now, ctx).find((r) => r.idx === tile.site);
|
||||
const op = U.getOperator(db, mv.ownerId);
|
||||
if (!op.alliance_id || !site.holder_alliance_id || site.holder_alliance_id !== op.alliance_id) return bounce(ctx, mv, now, 'not_holder');
|
||||
const ownerTown = U.homeTownFor(db, mv.ownerId, mv.fromTownId);
|
||||
if (!ownerTown) return; // the sender lost every POP meanwhile: nothing to belong to
|
||||
const town = loadTown(db, ownerTown.id);
|
||||
settle(db, town, now); // the owner's draw is the same as before the trip, but only from this moment
|
||||
G.add(db, site.id, ownerTown.id, mv.units);
|
||||
P.reschedule(ctx, town.id, now);
|
||||
const uid = U.userOfOperator(db, op.id);
|
||||
if (uid) ctx.notify(uid, mv.worldId, 'garrison_arrived', { siteId: site.id, index: site.idx, ownerTownId: ownerTown.id, units: mv.units });
|
||||
}
|
||||
|
||||
function arriveLanding(ctx, mv, now, world, tile) {
|
||||
const { db } = ctx;
|
||||
if (mv.type !== 'scan' && mv.type !== 'attack') return bounce(ctx, mv, now, 'invalid_target');
|
||||
const rows = E.ensureSites(db, world, now, ctx);
|
||||
|
|
@ -31,13 +67,24 @@ module.exports = function arriveLanding(ctx, mv, now, world, tile) {
|
|||
const origin = mv.fromTownId ? db.get('SELECT * FROM towns WHERE id = ?', mv.fromTownId) : null;
|
||||
const uid = U.userOfOperator(db, attackerOp.id);
|
||||
const where = { x: site.x, y: site.y, index: site.idx, siteId: site.id, level: site.level, holder: E.allianceInfo(db, site.holder_alliance_id) };
|
||||
const staticDef = R.backboneDefence(world.seed, site.x, site.y, E.ageDays(world, now), site.level);
|
||||
const held = !!site.holder_alliance_id;
|
||||
const staticDef = R.backboneDefence(world.seed, site.x, site.y, E.ageDays(world, now), site.level, held);
|
||||
const def = G.defenders(db, site.id, now); // the garrison (read only: nothing changes until the battle is resolved)
|
||||
const active = def.groups.filter((g) => g.online);
|
||||
where.held = held;
|
||||
|
||||
if (mv.type === 'scan') {
|
||||
const sa = R.scanStrength(mv.units.port_scanner || 0, mv.extra.research);
|
||||
const res = R.resolveScan(sa, SCAN_STRENGTH);
|
||||
let sd = SCAN_STRENGTH;
|
||||
for (const g of active) sd += R.scanStrength(g.units.port_scanner || 0, g.research);
|
||||
const res = R.resolveScan(sa, sd);
|
||||
const loss = R.applyLoss(mv.units, res.lossFraction);
|
||||
const intel = res.success ? { defence: staticDef, level: site.level, holder: where.holder, build: site.build_to ? { toLevel: site.build_to, dueAt: site.build_due_at } : null } : null;
|
||||
const garrisonUnits = {};
|
||||
for (const g of def.groups) U.sumInto(garrisonUnits, g.units);
|
||||
const intel = res.success ? {
|
||||
defence: staticDef + def.power, static: staticDef, level: site.level, holder: where.holder, build: site.build_to ? { toLevel: site.build_to, dueAt: site.build_due_at } : null,
|
||||
garrison: { units: garrisonUnits, power: def.power, offline: def.groups.filter((g) => !g.online).map((g) => g.ownerTownId) },
|
||||
} : null;
|
||||
createReport(ctx, {
|
||||
worldId: mv.worldId, type: 'scan', now, summary: { success: res.success, site: Object.assign({ type: 'backbone' }, where) },
|
||||
data: { success: res.success, detail: res.detail, site: Object.assign({ type: 'backbone' }, where), scanners: { sent: mv.units, lost: loss.lost, survivors: loss.survivors }, intel },
|
||||
|
|
@ -50,18 +97,50 @@ module.exports = function arriveLanding(ctx, mv, now, world, tile) {
|
|||
// attack: alliance members only, and not against the own alliance or a pact partner (the world may have changed since it left)
|
||||
if (!attackerOp.alliance_id) return bounce(ctx, mv, now, 'no_alliance');
|
||||
try { E.denyIfFriendly(db, attackerOp, site); } catch (e) { return bounce(ctx, mv, now, e.details.reason || 'invalid_target'); }
|
||||
const shield = E.shieldUntil(site, world);
|
||||
if (shield > now) return bounce(ctx, mv, now, 'site_shielded', { until: shield }); // it changed hands while the attack was on the road
|
||||
|
||||
const b = R.resolveBattle({ kind: 'attack', attackers: { units: mv.units, research: mv.extra.research || {} }, defenders: [], firewall: 0, staticDefence: staticDef });
|
||||
const b = R.resolveBattle({
|
||||
kind: 'attack', attackers: { units: mv.units, research: mv.extra.research || {} },
|
||||
defenders: active.map((g) => ({ id: g.id, units: g.units, research: g.research })), firewall: 0, staticDefence: staticDef,
|
||||
});
|
||||
const survivors = Object.assign({}, b.attacker.survivors);
|
||||
const oldHolder = site.holder_alliance_id;
|
||||
|
||||
// ---- the garrison: losses (a won attack wipes every group, offline ones included), written after settling each owner POP (its draw changes)
|
||||
const wipe = b.attackerWins || b.defenderLossFraction >= 1; // (the offline groups are not in the battle, but a lost site takes them with it)
|
||||
const garrisonReport = [];
|
||||
let defenderLost = {};
|
||||
for (const g of def.groups) {
|
||||
const res = b.defenders.find((d) => d.id === g.id);
|
||||
let left, lost;
|
||||
if (wipe) { left = {}; lost = g.units; } else if (res) { left = res.survivors; lost = res.lost; } else { left = g.units; lost = {}; }
|
||||
if (!U.isEmpty(lost)) {
|
||||
const town = loadTown(db, g.ownerTownId);
|
||||
if (town) settle(db, town, now);
|
||||
for (const k of Object.keys(g.units)) G.setUnit(db, site.id, g.ownerTownId, k, left[k] || 0);
|
||||
if (town) P.reschedule(ctx, town.id, now);
|
||||
}
|
||||
U.sumInto(defenderLost, lost);
|
||||
garrisonReport.push({ ownerTownId: g.ownerTownId, ownerOpId: g.ownerOpId, sent: g.units, lost, survivors: left, share: res ? res.share : 0, offline: !res });
|
||||
}
|
||||
const attLost = b.attacker.lost;
|
||||
addPoints(db, attackerOp.id, 'attack', R.battlePoints(defenderLost));
|
||||
const defPts = R.battlePoints(attLost);
|
||||
for (const g of garrisonReport) addPoints(db, g.ownerOpId, 'defense', defPts * g.share);
|
||||
|
||||
if (b.attackerWins) E.transferSite(ctx, site, attackerOp, now);
|
||||
const ret = sendHome(ctx, mv, survivors);
|
||||
const data = {
|
||||
outcome: b.attackerWins ? 'attacker_won' : 'defender_won', arrivedAt: now, site: Object.assign({ type: 'backbone' }, where), origin: townBrief(origin),
|
||||
attacker: { operator: opBrief({ id: attackerOp.id, name: attackerOp.name, as_number: attackerOp.as_number }), alliance: E.allianceInfo(db, attackerOp.alliance_id), units: { sent: mv.units, lost: b.attacker.lost, survivors } },
|
||||
power: { attack: b.A, defence: b.D }, taken: b.attackerWins, returnMovementId: ret ? ret.id : null,
|
||||
defender: { staticDefence: staticDef, garrison: garrisonReport.map((g) => ({ ownerTownId: g.ownerTownId, operator: g.ownerOpId ? opBrief(U.getOperator(db, g.ownerOpId)) : null, sent: g.sent, lost: g.lost, survivors: g.survivors, offline: g.offline })) },
|
||||
power: { attack: b.A, defence: b.D, static: staticDef, garrison: b.defenceRaw }, taken: b.attackerWins, returnMovementId: ret ? ret.id : null,
|
||||
};
|
||||
const recipients = [{ userId: uid, role: 'attacker' }];
|
||||
if (oldHolder) for (const m of db.all('SELECT o.user_id AS uid FROM alliance_members am JOIN operators o ON o.id = am.operator_id WHERE am.alliance_id = ?', oldHolder)) recipients.push({ userId: m.uid, role: 'defender' });
|
||||
createReport(ctx, { worldId: mv.worldId, type: 'landing', now, summary: { outcome: data.outcome, site: data.site, attacker: data.attacker.operator, taken: b.attackerWins }, data, recipients });
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = arriveLanding;
|
||||
module.exports.reinforce = reinforce;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue