@maka/maka-cli 5.181.0 → 5.183.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/combat-turn.js

@@ -1,6 +1,29 @@
 import { rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP, rollPool, formatRoll } from './dice.js';
 import { ActionBudget } from './action-budget.js';
 import { runNpcActionPhase } from './npc-combat-brain.js';
+export function arenaKey(a) {
+    return a.kind === 'room' ? `room:${a.room.name}` : a.kind === 'host' ? `host:${a.host.name}` : 'grid:open';
+}
+/** The arena this actor would fight in right now. */
+export function arenaOf(actor) {
+    if (actor.plane === 'matrix') {
+        const host = actor.hostInside;
+        return host ? { kind: 'host', host } : { kind: 'grid' };
+    }
+    return { kind: 'room', room: actor.currentLocation };
+}
+/** Standing in the arena: the body in the room, or the persona on
+ *  that side of the host wall. */
+export function inArena(arena, actor) {
+    if (arena.kind === 'room')
+        return actor.plane !== 'matrix' && actor.currentLocation === arena.room;
+    if (actor.plane !== 'matrix')
+        return false;
+    return arena.kind === 'host' ? actor.hostInside === arena.host : actor.hostInside === undefined;
+}
+export function arenaName(arena) {
+    return arena.kind === 'room' ? arena.room.name : arena.kind === 'host' ? `the ${arena.host.name} host` : 'the open grid';
+}
 /**
  * THE COMBAT TURN (SR5 p.158-161, RAG-checked 2026-09-06).
  *
@@ -96,10 +119,23 @@ export class CombatEncounter {
      *  autopilot was retired 2026-09-07: a phase you commit with "end
      *  turn" is yours to play). */
     onHumanPhase;
-    constructor(scene, logger, room) {
+    /** A fresh Combat Turn is about to be rolled (p.159 step 5) -- the
+     *  seam a host uses to launch one IC "at the beginning of each Combat
+     *  Turn" (p.247), before the roll so the new program rolls with
+     *  everyone. */
+    onNewTurn;
+    /** The fight goes on even with nobody paired against anybody: a host
+     *  whose ice is all crashed still gets its next turn to relaunch
+     *  (p.355-356). Consulted by stillHostile(). */
+    keepAlive;
+    /** Where this fight is. `room` stays for the physical arena and for
+     *  world events; a host arena's room is the room under the host. */
+    arena;
+    constructor(scene, logger, room, arena) {
         this.scene = scene;
         this.logger = logger;
         this.room = room;
+        this.arena = arena ?? { kind: 'room', room };
     }
     // ------------------------------------------------------------ setup ----
     /**
@@ -153,7 +189,7 @@ export class CombatEncounter {
             metaLines.push(`  ${p.actor.name}: ${formatInitiative(p.roll)}${p.score !== p.roll.score ? ` -> ${p.score}` : ''}`);
         }
         worldLines.push(`Combat Turn ${this.turn} -- ${this.orderLine()}.`);
-        this.scene.addWorldEvent(`A fight broke out in ${this.room.name} -- ${opts.aggressor.name} opened${opts.target ? ` on ${opts.target.name}` : ''}. In it: ${this.participants.map(p => p.actor.name).join(', ')}.`);
+        this.scene.addWorldEvent(`A fight broke out in ${arenaName(this.arena)} -- ${opts.aggressor.name} opened${opts.target ? ` on ${opts.target.name}` : ''}. In it: ${this.participants.map(p => p.actor.name).join(', ')}.`);
         await this.announce(worldLines, metaLines);
         await this.run();
     }
@@ -233,9 +269,14 @@ export class CombatEncounter {
     fullDefenseActive(actor) {
         return this.participantOf(actor)?.fullDefenseTurn === this.turn;
     }
-    /** Present in the room, on their feet, still a participant. */
+    /** Present in the arena, on their feet, still a participant. */
     present(p) {
-        return p.actor.currentLocation === this.room && !p.actor.isIncapacitated();
+        return inArena(this.arena, p.actor) && !p.actor.isIncapacitated() && !p.actor.deathClaimed;
+    }
+    /** A program the host runs (utilities/ic-actors.ts) -- its phase is
+     *  played by the ice brain and narrated by its own lines. */
+    isConstruct(actor) {
+        return actor.icKind !== undefined;
     }
     isNpc(actor) {
         return !this.scene.isHumanControlled(actor);
@@ -261,9 +302,9 @@ export class CombatEncounter {
     }
     /** An attack renews (or creates) the hostility between two actors. */
     noteAttack(attacker, defender) {
-        if (!this.has(defender) && defender.currentLocation === this.room)
+        if (!this.has(defender) && inArena(this.arena, defender))
             this.join(defender);
-        if (!this.has(attacker) && attacker.currentLocation === this.room)
+        if (!this.has(attacker) && inArena(this.arena, attacker))
             this.join(attacker);
         this.notePair(attacker, defender);
     }
@@ -273,6 +314,8 @@ export class CombatEncounter {
      * by an attack -- hands up ends a fight unless somebody keeps shooting.
      */
     stillHostile() {
+        if (this.keepAlive?.())
+            return true;
         for (const pair of this.pairs.values()) {
             const a = this.participants.find(p => p.actor.name === pair.a);
             const b = this.participants.find(p => p.actor.name === pair.b);
@@ -400,10 +443,15 @@ export class CombatEncounter {
      * phase that opens and closes in one tick is one beat per watcher.
      */
     notePhaseChanged() {
-        for (const a of this.room.getActors()) {
-            if (this.scene.isHumanControlled(a))
-                a.noteConditionChanged();
-        }
+        for (const a of this.watchers())
+            a.noteConditionChanged();
+    }
+    /** The humans who can see this fight: bodies in the room, or the
+     *  human personas on this side of the host wall. */
+    watchers() {
+        if (this.arena.kind === 'room')
+            return this.room.getActors().filter(a => this.scene.isHumanControlled(a));
+        return this.scene.getPlayers().filter(p => inArena(this.arena, p));
     }
     async beginPhase(p) {
         this.phaseActor = p.actor;
@@ -424,12 +472,18 @@ export class CombatEncounter {
             this.budget.spend('free', 'Run (still running)');
         const human = this.scene.isHumanControlled(p.actor);
         if (human) {
-            const budgetLine = `Your Action Phase -- Combat Turn ${this.turn}, pass ${this.pass}, Initiative ${p.score}. ${this.budget.describe()}; ${this.movementLine(p.actor)}. "end turn" when you're done.`;
+            // A persona has no metres to spend: the grid sees no distance.
+            const ground = this.arena.kind === 'room' ? `; ${this.movementLine(p.actor)}` : '';
+            const budgetLine = `Your Action Phase -- Combat Turn ${this.turn}, pass ${this.pass}, Initiative ${p.score}. ${this.budget.describe()}${ground}. "end turn" when you're done.`;
             this.logger.log(`\n{cyan-fg}${budgetLine}{/cyan-fg}`, { actor: p.actor.name });
             this.scene.updateStatus();
             this.onHumanPhase?.(p.actor, this);
             return;
         }
+        // Ice narrates its own action (utilities/ic-brain.ts); a second
+        // "acts" line per program per pass was half the wall of text.
+        if (this.isConstruct(p.actor))
+            return;
         await this.announce([`${p.actor.name} acts (Initiative ${p.score}).`], []);
     }
     movementLine(actor) {
@@ -543,6 +597,11 @@ export class CombatEncounter {
         }
         this.turn += 1;
         this.pass = 1;
+        // The host launches at the START of the turn (p.247), before the
+        // roll, so a fresh program rolls initiative with everyone else.
+        await this.onNewTurn?.(this);
+        if (this.ended)
+            return;
         const metaLines = [`Combat Turn ${this.turn} -- new Initiative (p.159):`];
         for (const p of this.participants) {
             p.roll = rollInitiativeScore(p.actor.getInitiativeAttribute(), p.actor.getInitiativeDice());
@@ -590,7 +649,7 @@ export class CombatEncounter {
                 : `${actor.name} has only ${p.score} Initiative left -- ${label} costs ${cost} (SR5 p.168).`;
         }
         p.score -= cost;
-        this.logger.meta(`  ${actor.name}: ${label} (-${cost} Initiative -> ${p.score})`, undefined, { room: this.room.name });
+        this.logger.meta(`  ${actor.name}: ${label} (-${cost} Initiative -> ${p.score})`, undefined, this.arena.kind === 'room' ? { room: this.room.name } : { actor: actor.name });
         return undefined;
     }
     /** Full Defense (p.191): -10, Willpower to every defense this turn. */
@@ -620,29 +679,37 @@ export class CombatEncounter {
             p.actor.firedThisPhase = false;
         }
         this.scene.endEncounter(this);
+        const where = arenaName(this.arena);
         const line = reason === 'burnout'
-            ? `The fight in ${this.room.name} burns out -- nobody can land the finishing blow.`
+            ? `The fight in ${where} burns out -- nobody can land the finishing blow.`
             : reason === 'left'
-                ? `The fight in ${this.room.name} is over -- nobody left to fight.`
-                : `The fight in ${this.room.name} is over.`;
+                ? `The fight in ${where} is over -- nobody left to fight.`
+                : `The fight in ${where} is over.`;
         await this.announce([line], []);
         this.scene.updateStatus();
         // Spirits whose services ran out depart once the dust settles.
         this.scene.ownerGame?.settleSpiritServices?.();
     }
     // ------------------------------------------------------------ output ----
-    /** A human is present in the room to see it. */
+    /** A human is present in the arena to see it. */
     witnessed() {
-        return this.scene.getPlayers().some(p => p.currentLocation === this.room);
+        return this.watchers().length > 0;
     }
     async announce(lines, meta) {
         if ((lines.length === 0 && meta.length === 0) || !this.witnessed())
             return;
-        const scope = { room: this.room.name };
-        for (const m of meta)
-            this.logger.meta(m, undefined, scope);
-        if (lines.length > 0)
-            this.logger.log(`\n${lines.join('\n')}`, scope);
+        // A room scope resolves by BODY room (headless.ts), which is not
+        // where a persona stands -- so a host or grid fight addresses each
+        // watching persona by name instead.
+        const scopes = this.arena.kind === 'room'
+            ? [{ room: this.room.name }]
+            : this.watchers().map(p => ({ actor: p.name }));
+        for (const scope of scopes) {
+            for (const m of meta)
+                this.logger.meta(m, undefined, scope);
+            if (lines.length > 0)
+                this.logger.log(`\n${lines.join('\n')}`, scope);
+        }
         this.scene.updateStatus();
         const beat = process.env.MAKA_NO_BEATS === '1' ? 0 : CombatEncounter.BEAT_MS;
         if (beat > 0)
@@ -674,7 +741,8 @@ export class CombatEncounter {
         if (!p)
             return undefined;
         if (this.phaseActor === player && this.budget) {
-            return `{cyan-fg}⏱ YOUR PHASE{/cyan-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()} · ${player.movementLeftMeters} m · "end turn"`;
+            const ground = this.arena.kind === 'room' ? ` · ${player.movementLeftMeters} m` : '';
+            return `{cyan-fg}⏱ YOUR PHASE{/cyan-fg} T${this.turn}/P${this.pass} Init ${p.score} · ${this.budget.describe()}${ground} · "end turn"`;
         }
         const who = this.phaseActor ? `${this.phaseActor.name} acting` : 'resolving';
         return `⏱ COMBAT T${this.turn}/P${this.pass} Init ${p.score} · ${who}${p.fullDefenseTurn === this.turn ? ' · FULL DEFENSE' : ''}`;

package/bundle/typescript/src/commands/game/sideQuest/utilities/grid-view.js

@@ -16,6 +16,25 @@ import { isWatched, camerasLive, canSnoopFeeds } from './surveillance.js';
  * ▣ PAN, ▲ dangerous device, ◇ data. (There is no air-gapped-host glyph
  * any more -- see hhSWzLSXECFtfoAGa and canReachHost.)
  */
+/**
+ * A DEVICE ICON, AND WHAT WORKS IT (commands/disable.ts, 2026-09-13).
+ * Control Device (p.238) needs 2 marks on the device -- "disable" -- and
+ * a Data Spike (p.239) needs none -- "brick". A bricked lock stays
+ * locked (p.228), so its line says so rather than offering a way in.
+ */
+export function deviceIconLine(device, actor) {
+    const dr = `{bold}[DR ${device.rating}]{/bold}`;
+    if (device.isOpen())
+        return `▤ ${device.name} ${dr} -- its icon standing open, nothing left to hold.`;
+    if (device.isBricked) {
+        return `▤ ${device.name} ${dr} -- BRICKED, dead electronics${device.kind === 'lock' ? '; the lock stays locked (p.228)' : ''}.`;
+    }
+    const marks = device.marksBy.get(actor.name) ?? 0;
+    const way = marks >= 2
+        ? `"disable ${device.name}" (Control Device, ${marks} marks held)`
+        : `"hack ${device.name}" for marks (${marks}/2 to command it), or "brick ${device.name}"`;
+    return `▤ ${device.name} ${dr} -- a device icon shaped like the thing itself, shut. (${way})`;
+}
 export function gridIcons(scene, actor, room) {
     // INSIDE A HOST IS A DIFFERENT PLACE (SR5 p.246, and Deditri's
     // eJANPpm7qCaCAJBJw). "The virtual space inside a host is separate
@@ -202,9 +221,7 @@ export function gridIcons(scene, actor, room) {
     for (const device of room.devices) {
         if (!device.broadcastsAro())
             continue;
-        icons.push(device.isOpen()
-            ? `▤ ${device.name} {bold}[DR ${device.rating}]{/bold} -- its icon standing open, nothing left to hold.`
-            : `▤ ${device.name} {bold}[DR ${device.rating}]{/bold} -- a device icon shaped like the thing itself, shut. ("hack ${device.name}")`);
+        icons.push(deviceIconLine(device, actor));
     }
     // The cameras, as a THING (surveillance.ts): live for security, looped,
     // or yours to ride.
@@ -306,7 +323,16 @@ function hostInteriorIcons(scene, actor, room) {
     const data = room.offlineServer
         ? []
         : room.inventory.getAllItems().filter(i => i.plane === 'matrix');
-    for (const item of data) {
+    // THE ARCHIVE IS NOT A GLANCE (p.241, player ruling 2026-09-13): a
+    // persona sees the host's files after a Matrix Search turns them up
+    // (commands/search.ts, Host.searchedBy), or when the host is cracked
+    // and they spill open. Until then a look says only that there is an
+    // archive to search.
+    const found = room.hostCracked || (room.host?.searchedBy.has(actor.name) ?? false);
+    if (data.length > 0 && !found) {
+        icons.push(`◇ The host's archive -- files in here somewhere, and a glance does not read an archive. ("search" runs a Matrix Search, p.241)`);
+    }
+    for (const item of found ? data : []) {
         icons.push(room.hostCracked
             ? `◇ ${item.name} [data] -- unsealed, sitting open in the host's archive. ("take" it)`
             : `◇ ${item.name} [data] -- SEALED in the host's archive. ("hack" the host to break the seal)`);

package/bundle/typescript/src/commands/game/sideQuest/utilities/host-combat.js

@@ -0,0 +1,107 @@
+import { hostIsHunting, hostLaunchStep } from './ic.js';
+import { personasInside } from './matrix-roster.js';
+/**
+ * THE HOST OWNS ITS FIGHT (2026-09-13, the Matrix joins the Combat Turn).
+ *
+ * Before this the host's ice acted once per PLAYER COMMAND (game.ts
+ * withICTurn -> ic.ts runICTurn): type "look" inside an alerted host and
+ * every running program took a swing, four programs and twelve lines a
+ * keystroke, with no initiative and no turn to end -- an engine mapping
+ * that its own comment called "not a rule". Cybercombat, meanwhile, ran
+ * on the two-actor exchange: every `attack Patrol IC` rolled a fresh
+ * initiative and printed "FREEZES".
+ *
+ * Canon has one structure for both (SR5 p.247, p.229-230, RAG-checked
+ * 2026-09-13): Combat Turns and Initiative Passes shared with the meat
+ * world; a persona's initiative is Data Processing + Intuition with
+ * 3D6/4D6; each IC program has its own persona, condition monitor and
+ * Initiative Score, treated as hot-sim (4D6); the host launches ONE IC
+ * per Combat Turn at the beginning of the turn, up to its rating
+ * running; IC attacks are Complex Actions. So the host's fight is a
+ * CombatEncounter in a host ARENA (combat-turn.ts): the host launches
+ * on the encounter's newTurn hook, each program is a participant whose
+ * Action Phase the ice brain plays (ic-brain.ts), and the persona spends
+ * its own budget and types "end turn" like anywhere else.
+ *
+ * `ic.ts` stays scene-free and dice-only; this file is the seam that
+ * holds the Scene and the encounter.
+ */
+const empty = () => ({ lines: [], meta: [], world: [] });
+/** Every program the host has running as an actor, seated in the fight. */
+function seatRunningIce(enc, host) {
+    for (const ice of host.iceActors.values()) {
+        if (!enc.has(ice) && !ice.isIncapacitated())
+            enc.join(ice);
+    }
+}
+/** Report one host step to the persona's watchers. */
+async function tell(enc, scene, turn) {
+    for (const w of turn.world)
+        scene.addWorldEvent(w);
+    await enc.announce(turn.lines, turn.meta);
+}
+/**
+ * THE START OF THE HOST'S COMBAT TURN (p.247): crashed programs leave,
+ * one program launches, and the newcomer rolls initiative with everyone
+ * else -- the encounter calls this from newTurn() before the roll.
+ */
+export async function hostTurnStart(scene, host, enc) {
+    const out = empty();
+    hostLaunchStep(host.over, scene, out);
+    seatRunningIce(enc, host);
+    await tell(enc, scene, out);
+}
+/** The fight goes on while the host is alert and someone human is still
+ *  inside it -- even with every program crashed, the host gets its next
+ *  turn to relaunch (p.355-356). */
+export function hostKeepsFighting(scene, host) {
+    return host.alert && !host.sanctioned
+        && personasInside(scene, host).some(p => scene.isHumanControlled(p) && !p.isIncapacitated());
+}
+/**
+ * OPEN THE HOST'S FIGHT on an intruder it has made. The aggressor is a
+ * running program -- Patrol, which "is already walking the host", if
+ * nothing else is -- so the initiative block reads like a fight and not
+ * like a system message.
+ */
+export async function openHostEncounter(scene, host, intruder) {
+    const out = empty();
+    let aggressor = [...host.iceActors.values()].find(ice => !ice.isIncapacitated());
+    if (!aggressor) {
+        aggressor = hostLaunchStep(host.over, scene, out);
+    }
+    if (!aggressor)
+        return undefined;
+    for (const w of out.world)
+        scene.addWorldEvent(w);
+    const enc = await scene.startEncounter({ kind: 'host', host }, {
+        aggressor, target: intruder, ambush: false,
+        onNewTurn: e => hostTurnStart(scene, host, e),
+        keepAlive: () => hostKeepsFighting(scene, host),
+    });
+    seatRunningIce(enc, host);
+    if (out.lines.length > 0)
+        await enc.announce(out.lines, out.meta);
+    return enc;
+}
+/**
+ * The beat after every command a persona types inside a host (game.ts
+ * withHostTurn): an alerted host that is not yet fighting this persona
+ * opens on it. Returns true when a fight was opened this beat.
+ */
+export async function hostContactBeat(scene, player) {
+    const host = player.hostInside;
+    if (!host || player.plane !== 'matrix')
+        return false;
+    if (!hostIsHunting(host.over, player))
+        return false;
+    const live = scene.encounterInHost(host);
+    if (live) {
+        if (!live.has(player))
+            live.join(player);
+        return false;
+    }
+    const enc = await openHostEncounter(scene, host, player);
+    return enc !== undefined;
+}
+//# sourceMappingURL=host-combat.js.map

package/bundle/typescript/src/commands/game/sideQuest/utilities/ic-brain.js

@@ -0,0 +1,84 @@
+import { IC_TYPES, icActs } from './ic.js';
+import { leaveMatrix } from './planes.js';
+import { Logger } from './logger.js';
+/**
+ * A PROGRAM'S ACTION PHASE (SR5 p.247): one Complex Action, by rule.
+ *
+ * The meat brain (npc-combat-brain.ts) plays verbs -- draw, close, fire.
+ * Ice has no verbs and no mind (models/npc.ts isConstruct): its whole
+ * repertoire is the one test its type makes, and utilities/ic.ts already
+ * rolls that with the right dice. So the phase is: pick the persona the
+ * host is after, run the program's act once, spend the Complex, and
+ * route what happened to the same places game.ts used to -- the lines to
+ * the watchers, the world events to the table, a bricked or scrambled
+ * persona to the forced dump, a trace to the heat ledger.
+ *
+ * Nothing here narrates a second "X acts" line: the program's own act
+ * line is the narration (combat-turn.ts beginPhase skips it for ice).
+ */
+export async function runIcActionPhase(enc, ice) {
+    const logger = Logger.getInstance();
+    const host = ice.icHost;
+    const type = IC_TYPES.find(t => t.name === ice.icKind);
+    if (!host || !type || ice.isIncapacitated())
+        return;
+    const budget = enc.budgetOf(ice);
+    if (!budget)
+        return;
+    const target = pickTarget(enc, ice);
+    if (!target) {
+        logger.write(`Ice: ${ice.name} has nobody in the host to hunt -- phase forfeited.`);
+        budget.spend('complex', `${type.name} (idle)`);
+        return;
+    }
+    ice.combatOpponent = target;
+    ice.lastExchangeAt = Date.now();
+    const out = { lines: [], meta: [], world: [] };
+    icActs(host.over, target, type, out, ice);
+    budget.spend('complex', type.name);
+    // The forced dumps ic.ts reports rather than performs -- it takes no
+    // Scene. Reasons verbatim from the old game.ts withICTurn.
+    if (out.bricked) {
+        out.lines.push(...leaveMatrix(enc.scene, target, {
+            forced: true,
+            reason: `The host's ice burns your deck out from under you.`,
+        }));
+    }
+    else if (out.scrambled) {
+        out.lines.push(...leaveMatrix(enc.scene, target, {
+            forced: true,
+            reason: `Scramble IC rips the connection out at the root --`,
+        }));
+    }
+    if (out.traced) {
+        // TRACK IC (p.249): the location goes to the authorities -- routed
+        // into the heat the game already keeps for being made in the meat.
+        enc.scene.ownerGame?.addHeat?.(4, `Track IC reported ${target.name}'s location`);
+    }
+    for (const w of out.world)
+        enc.scene.addWorldEvent(w);
+    await enc.announce(out.lines, out.meta);
+    enc.syncWounds();
+}
+/**
+ * Who the program goes for: the persona the host holds the most marks
+ * on (Probe's work, and what Killer's DV and the mark-gated programs
+ * read), then whoever it last engaged, then the first enemy standing.
+ */
+function pickTarget(enc, ice) {
+    const enemies = enc.enemiesOf(ice).filter(e => e.plane === 'matrix');
+    if (enemies.length === 0)
+        return undefined;
+    const marksOn = ice.icHost?.marksOn;
+    let best = enemies[0];
+    let bestMarks = -1;
+    for (const e of enemies) {
+        const m = marksOn?.get(e.name) ?? 0;
+        if (m > bestMarks || (m === bestMarks && e === ice.combatOpponent)) {
+            best = e;
+            bestMarks = m;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=ic-brain.js.map