'use strict'; /* * 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'); 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); if (!dest) return null; return M.launchReturn(ctx, { worldId: mv.worldId, ownerId: mv.ownerId, fromTownId: null, at: mv.to, to: dest, units: survivors, cargo: {}, parentId: mv.id, extra: {} }); } // 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); const site = rows.find((r) => r.idx === tile.site); const attackerOp = U.getOperator(db, mv.ownerId); 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 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); 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 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 }, recipients: [{ userId: uid, role: 'attacker' }], }); sendHome(ctx, mv, loss.survivors); return; } // 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: 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 } }, 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;