'use strict'; /* * Arrival of scan / raid / attack / takeover. Everything here runs inside the `arrive` event's transaction at the * event's own due time, after every earlier event, so combat order is exactly event order. Deterministic: the only * dice (the loyalty roll) are seeded from (world seed, movement id). * * Steps: re-check the target (it may have changed since departure) -> settle the target to the due time -> gather * defenders (home crews + reinforcements, only while online) -> rules.resolveBattle -> apply losses, loot, siege, * takeover -> survivors drive home with the loot -> reports + battle points. */ const R = require('../../public/js/rules.js'); const D = require('../../public/js/data.js'); const { loadTown, settle, loadWorld } = require('../state'); const U = require('./units'); const M = require('./movements'); const P = require('./power'); const { createReport } = require('./reports'); const { bounce, townBrief, opBrief } = require('./arrivals'); const DAY = 24 * D.HOUR_MS; // All groups standing in the target: home crews then each reinforcing POP's units, with the research that applies. function defenderGroups(db, target) { const groups = []; const home = U.homeUnits(db, target.id); if (!U.isEmpty(home)) groups.push({ id: 'home', ownerTownId: target.id, ownerOpId: target.ownerId, units: home, research: U.researchLevels(db, target.id) }); for (const g of U.hostedGroups(db, target.id)) { const ot = db.get('SELECT owner_id FROM towns WHERE id = ?', g.ownerTownId); groups.push({ id: 'from:' + g.ownerTownId, ownerTownId: g.ownerTownId, ownerOpId: ot ? ot.owner_id : null, units: g.units, research: U.researchLevels(db, g.ownerTownId) }); } return groups; } // Write a defending group's units back after the battle. function writeGroup(db, hostTownId, group, units) { const keys = new Set(Object.keys(group.units).concat(Object.keys(units))); for (const k of keys) { if (group.id === 'home') U.setHomeUnit(db, hostTownId, k, units[k] || 0); else U.setStationed(db, hostTownId, group.ownerTownId, k, units[k] || 0); } } 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); db.run('UPDATE operator_stats SET ' + (column === 'attack' ? 'attack_points' : 'defense_points') + ' = ' + (column === 'attack' ? 'attack_points' : 'defense_points') + ' + ? WHERE operator_id = ?', v, operatorId); } const sumValues = (list) => list.reduce((acc, u) => U.sumInto(acc, u), {}); // Survivors drive home (with loot). No survivors, no movement. function sendHome(ctx, mv, survivors, cargo) { const { db } = ctx; if (U.isEmpty(survivors)) return null; const dest = U.homeTownFor(db, mv.ownerId, mv.fromTownId); if (!dest) return null; return M.launchReturn(ctx, { worldId: mv.worldId, ownerId: mv.ownerId, fromTownId: mv.toTownId, at: mv.to, to: dest, units: survivors, cargo: cargo || {}, parentId: mv.id, extra: {} }); } function arrive(ctx, mv, ev) { const { db } = ctx; const now = ev.dueAt; const world = loadWorld(db, mv.worldId); if (!mv.toTownId) return arriveSite(ctx, mv, now, world); const targetRow = db.get('SELECT * FROM towns WHERE id = ?', mv.toTownId); if (!targetRow) return bounce(ctx, mv, now, 'target_gone'); const attackerOp = U.getOperator(db, mv.ownerId); const defOp = U.getOperator(db, targetRow.owner_id); if (defOp.id === attackerOp.id) return bounce(ctx, mv, now, 'own_town'); if (mv.type !== 'scan') { if (R.isProtected(defOp.protection_until, now)) return bounce(ctx, mv, now, 'protected', { until: defOp.protection_until }); if (U.pactBlocks(db, attackerOp.id, defOp.id)) return bounce(ctx, mv, now, 'pact'); } const target = loadTown(db, targetRow.id); settle(db, target, now); const online = P.online(target, now); const groups = defenderGroups(db, target); const active = online ? groups : []; const origin = mv.fromTownId ? db.get('SELECT * FROM towns WHERE id = ?', mv.fromTownId) : null; if (mv.type === 'scan') return resolveScanOnTown(ctx, mv, now, { target, targetRow, defOp, attackerOp, origin, groups, active, online }); const kind = mv.type === 'raid' ? 'raid' : 'attack'; const fwLevel = target.buildings.firewall ? target.buildings.firewall.level : 0; const b = R.resolveBattle({ kind, attackers: { units: mv.units, research: mv.extra.research || {} }, defenders: active.map((g) => ({ id: g.id, units: g.units, research: g.research })), firewall: fwLevel, }); const win = b.attackerWins; // ---- defenders: losses (a full attack lost by the defender wipes everything in the POP, offline units included) const wipe = b.defenderLossFraction >= 1; const groupReports = []; let defenderLost = {}; for (const g of groups) { const res = b.defenders.find((d) => d.id === g.id); let survivors, lost; if (wipe) { survivors = {}; lost = g.units; } else if (res) { survivors = res.survivors; lost = res.lost; } else { survivors = g.units; lost = {}; } // offline and not wiped: untouched writeGroup(db, target.id, g, survivors); U.sumInto(defenderLost, lost); groupReports.push({ id: g.id, ownerTownId: g.ownerTownId, ownerOpId: g.ownerOpId, sent: g.units, lost, survivors, share: res ? res.share : 0, offline: !res }); } const survivorsAtt = Object.assign({}, b.attacker.survivors); // ---- loot let loot = { fiber: 0, hardware: 0, capital: 0 }; let hidden = 0; if (win) { hidden = kind === 'raid' ? R.cacheFraction(target.buildings.rack_hall ? target.buildings.rack_hall.level : 0) : 0; const avail = {}; for (const r of D.RESOURCES) avail[r] = target.res[r] * (1 - hidden); loot = R.lootSplit(R.carryOf(survivorsAtt), avail); for (const r of D.RESOURCES) target.res[r] -= loot[r]; db.run('UPDATE towns SET fiber = ?, hardware = ?, capital = ? WHERE id = ?', target.res.fiber, target.res.hardware, target.res.capital, target.id); } // ---- siege: exploit kits tear levels off the chosen building let siege = null; if (win && mv.type !== 'raid' && mv.extra.target) { const levels = R.siegeLevels(survivorsAtt.exploit_kit || 0); const cur = levels > 0 ? target.buildings[mv.extra.target] : null; if (cur && cur.level > 0) { const to = Math.max(0, cur.level - levels); db.run('UPDATE buildings SET level = ? WHERE town_id = ? AND key = ?', to, target.id, mv.extra.target); siege = { key: mv.extra.target, type: cur.type, from: cur.level, to }; } } // ---- takeover let takeover = null; let captured = false; if (mv.type === 'takeover' && win && (survivorsAtt[D.EXPANSION.conquestUnit] || 0) > 0) { const defTowns = db.get('SELECT COUNT(*) AS n FROM towns WHERE owner_id = ?', defOp.id).n; const block = R.takeoverBlock(!!targetRow.is_capital, defTowns); const gate = R.footprintGate(U.operatorTowns(db, attackerOp.id).length, U.operatorFootprint(db, attackerOp.id, now)); takeover = { attempted: true, blocked: block === 'last_pop' ? 'last_pop' : (gate.ok ? null : 'footprint'), capital: block === 'capital', loyaltyBefore: target.loyalty, loyaltyAfter: target.loyalty, drop: 0, captured: false }; if (takeover.blocked === null) { const rand = R.rng(R.hash(world.seed, mv.id, 0x7a11))(); const drop = R.loyaltyDrop(rand); const after = Math.max(0, target.loyalty - drop); const left = survivorsAtt[D.EXPANSION.conquestUnit] - 1; // the M&A team that did the talking is used up if (left > 0) survivorsAtt[D.EXPANSION.conquestUnit] = left; else delete survivorsAtt[D.EXPANSION.conquestUnit]; db.run('UPDATE towns SET loyalty = ?, loyalty_at = ? WHERE id = ?', after, now, target.id); Object.assign(takeover, { drop, loyaltyAfter: after }); if (after <= 0 && block === null) { transferTown(ctx, target, attackerOp, defOp, now); captured = true; takeover.captured = true; } } } // ---- battle points const attLost = b.attacker.lost; addPoints(db, attackerOp.id, 'attack', R.battlePoints(defenderLost)); const defPts = R.battlePoints(attLost); for (const g of groupReports) addPoints(db, g.ownerOpId, 'defense', defPts * g.share); P.reschedule(ctx, target.id, now); const ret = sendHome(ctx, mv, survivorsAtt, loot); // ---- reports const data = { type: mv.type, outcome: win ? 'attacker_won' : 'defender_won', arrivedAt: now, attacker: { operator: opBrief(attackerOp), town: townBrief(origin), units: { sent: mv.units, lost: attLost, survivors: survivorsAtt } }, defender: { operator: opBrief(defOp), town: townBrief(target), online, groups: groupReports.map((g) => ({ ownerTownId: g.ownerTownId, sent: g.sent, lost: g.lost, survivors: g.survivors, offline: g.offline })) }, power: { attack: b.A, defence: b.D, defenceRaw: b.defenceRaw, firewallLevel: fwLevel, effectiveFirewall: b.effectiveFirewall }, loot, cacheHidden: hidden, siege, takeover, capturedTown: captured, returnMovementId: ret ? ret.id : null, }; const summary = { type: mv.type, outcome: data.outcome, attacker: opBrief(attackerOp), defender: opBrief(defOp), target: townBrief(target), loot, captured }; const recipients = [{ userId: U.userOfOperator(db, attackerOp.id), role: 'attacker' }, { userId: U.userOfOperator(db, defOp.id), role: 'defender' }]; for (const g of groupReports) if (g.id !== 'home' && g.ownerOpId) recipients.push({ userId: U.userOfOperator(db, g.ownerOpId), role: 'reinforcer' }); createReport(ctx, { worldId: mv.worldId, type: mv.type, now, summary, data, recipients }); } // ---- scans function resolveScanOnTown(ctx, mv, now, s) { const { db } = ctx; const { target, defOp, attackerOp, origin, groups, active, online } = s; const sa = R.scanStrength(mv.units.port_scanner || 0, mv.extra.research); let sd = 0; 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); let intel = null; if (res.success) { intel = { detail: res.detail, online, units: { home: U.homeUnits(db, target.id), stationed: groups.filter((g) => g.id !== 'home').map((g) => ({ ownerTownId: g.ownerTownId, units: g.units })) }, resources: { fiber: target.res.fiber, hardware: target.res.hardware, capital: target.res.capital }, }; if (res.detail === 'full') { intel.buildings = Object.keys(target.buildings).map((k) => ({ key: k, type: target.buildings[k].type, level: target.buildings[k].level })); intel.loyalty = target.loyalty; intel.outgoing = db.all("SELECT id, type, to_x, to_y, arrive_at FROM movements WHERE from_town_id = ? AND status = 'out' AND type != 'return' ORDER BY arrive_at, id", target.id) .map((m) => ({ type: m.type, to: { x: m.to_x, y: m.to_y }, arriveAt: m.arrive_at })); } } const aData = { success: res.success, detail: res.detail, scanners: { sent: mv.units, lost: loss.lost, survivors: loss.survivors }, strength: { attacker: sa, defender: sd }, target: townBrief(target), operator: opBrief(defOp), intel }; createReport(ctx, { worldId: mv.worldId, type: 'scan', now, summary: { success: res.success, target: townBrief(target), operator: opBrief(defOp) }, data: aData, recipients: [{ userId: U.userOfOperator(db, attackerOp.id), role: 'attacker' }], }); const dData = { identityRevealed: res.identityRevealed, target: townBrief(target), by: res.identityRevealed ? { operator: opBrief(attackerOp), town: townBrief(origin) } : null }; createReport(ctx, { worldId: mv.worldId, type: 'scan_detected', now, summary: { identityRevealed: res.identityRevealed, target: townBrief(target), by: dData.by && dData.by.operator }, data: dData, recipients: [{ userId: U.userOfOperator(db, defOp.id), role: 'defender' }], }); sendHome(ctx, mv, loss.survivors, {}); } // ---- incumbent sites (NPC): static defence, no losses for the site, never attack function arriveSite(ctx, mv, now, world) { const { db } = ctx; const { x, y } = mv.to; const tile = R.tileAt(world.seed, world.map_radius, x, y, R.worldAgeDays(world.start_at, now, world.speed)); if (tile.type === 'backbone') return require('./landing')(ctx, mv, now, world, tile); // end game: backbone landing site if (tile.type !== 'incumbent' || (mv.type !== 'scan' && mv.type !== 'attack')) return bounce(ctx, mv, now, 'invalid_target'); const attackerOp = U.getOperator(db, mv.ownerId); const ageDays = Math.max(0, (now - world.start_at) / DAY * world.speed); const staticDef = R.incumbentDefence(world.seed, x, y, ageDays); const origin = mv.fromTownId ? db.get('SELECT * FROM towns WHERE id = ?', mv.fromTownId) : null; const site = { x, y, type: 'incumbent' }; const uid = U.userOfOperator(db, attackerOp.id); if (mv.type === 'scan') { const sa = R.scanStrength(mv.units.port_scanner || 0, mv.extra.research); const res = R.resolveScan(sa, D.INCUMBENT.scanStrength); const loss = R.applyLoss(mv.units, res.lossFraction); const taken = !!db.get('SELECT 1 AS x FROM incumbent_takes WHERE world_id = ? AND x = ? AND y = ? AND operator_id = ?', world.id, x, y, attackerOp.id); const intel = res.success ? { defence: staticDef, bonusAvailable: !taken, hardwareBonus: D.INCUMBENT.hardwareBonus } : null; createReport(ctx, { worldId: mv.worldId, type: 'scan', now, summary: { success: res.success, site }, data: { success: res.success, detail: res.detail, site, scanners: { sent: mv.units, lost: loss.lost, survivors: loss.survivors }, intel }, recipients: [{ userId: uid, role: 'attacker' }], }); sendHome(ctx, mv, loss.survivors, {}); return; } const b = R.resolveBattle({ kind: 'attack', attackers: { units: mv.units, research: mv.extra.research || {} }, defenders: [], firewall: 0, staticDefence: staticDef }); const survivors = Object.assign({}, b.attacker.survivors); let bonus = null; const cargo = {}; if (b.attackerWins) { const first = db.run('INSERT OR IGNORE INTO incumbent_takes (world_id, x, y, operator_id, taken_at) VALUES (?, ?, ?, ?, ?)', world.id, x, y, attackerOp.id, now); if (first.changes) { cargo.hardware = D.INCUMBENT.hardwareBonus; bonus = { hardware: D.INCUMBENT.hardwareBonus, researchSpeedBonus: R.researchSpeedBonus(U.incumbentTakes(db, attackerOp.id)) }; } } const ret = sendHome(ctx, mv, survivors, cargo); createReport(ctx, { worldId: mv.worldId, type: 'incumbent', now, summary: { outcome: b.attackerWins ? 'attacker_won' : 'defender_won', site, bonus }, data: { outcome: b.attackerWins ? 'attacker_won' : 'defender_won', arrivedAt: now, site, origin: townBrief(origin), attacker: { operator: opBrief(attackerOp), units: { sent: mv.units, lost: b.attacker.lost, survivors } }, power: { attack: b.A, defence: b.D }, bonus, returnMovementId: ret ? ret.id : null, }, recipients: [{ userId: uid, role: 'attacker' }], }); } // A takeover completed: the POP changes owner. Pending work of the old owner stops, reinforcements of the old owner // standing elsewhere are re-homed, the new owner starts at conqueredLoyalty. function transferTown(ctx, town, newOp, oldOp, now) { const { db } = ctx; db.run('UPDATE towns SET owner_id = ?, is_capital = 0, loyalty = ?, loyalty_at = ? WHERE id = ?', newOp.id, D.EXPANSION.conqueredLoyalty, now, town.id); db.run("UPDATE events SET status = 'cancelled', done_at = ? WHERE town_id = ? AND type IN ('trainDone', 'researchDone') AND status = 'pending'", now, town.id); db.run("UPDATE events SET payload = json_set(payload, '$.userId', ?) WHERE town_id = ? AND type = 'buildDone' AND status = 'pending'", U.userOfOperator(db, newOp.id), town.id); // units of the old owner that were hosted here (should be dead already) or that belonged to this POP and stand elsewhere const home = U.homeTownFor(db, oldOp.id); for (const g of U.awayGroups(db, town.id)) { db.run('DELETE FROM stationed WHERE host_town_id = ? AND owner_town_id = ?', g.hostTownId, town.id); if (!home) continue; if (home.id === g.hostTownId) U.addHome(db, home.id, g.units); else U.addStationed(db, g.hostTownId, home.id, g.units); } db.run('DELETE FROM town_power WHERE town_id = ?', town.id); require('../trade').onTownTransferred(ctx, town.id, now); // open Internet exchange offers of the old owner end, the escrow stays in the POP const oldUser = U.userOfOperator(db, oldOp.id), newUser = U.userOfOperator(db, newOp.id); if (oldUser) ctx.notify(oldUser, town.worldId, 'town_lost', { townId: town.id, name: town.name, by: opBrief(newOp) }); if (newUser) ctx.notify(newUser, town.worldId, 'town_gained', { townId: town.id, name: town.name }); } module.exports = { arrive, defenderGroups, transferTown };