@maka/maka-cli 5.181.0 → 5.183.0

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

@@ -297,37 +297,37 @@ export function runHostTurn(room, actor, scene) {
     return ambientPatrol(room, actor);
 }
 /**
- * ONE COMBAT TURN of the host's ice.
+ * THE START OF A HOST'S COMBAT TURN (p.247): "a host can launch one IC
+ * program per Combat Turn, at the beginning of each Combat Turn", up to
+ * its rating running, never two of a kind. Crashed programs leave the
+ * list first and come back the very next turn (p.355-356, "delayed,
+ * never destroyed") -- the relaunch takes the turn's one launch.
  *
- * THE TURN MAPPING IS AN ENGINE MAPPING, NOT A RULE, and is labelled so
- * deliberately. Canon paces IC in Combat Turns -- one program launched
- * per turn, at the beginning of it. sideQuest has no Matrix initiative
- * structure to hang that on, so ONE PLAYER ACTION TAKEN INSIDE AN
- * ALERTED HOST counts as one Combat Turn. That is the closest structural
- * analogue available; it is not something the book says, and it is not
- * dressed up as a citation.
+ * Launches only; nothing acts here. In play the encounter's newTurn
+ * hook calls this (utilities/host-combat.ts) and each program then acts
+ * in its own Action Phase (utilities/ic-brain.ts). Returns the actor a
+ * launch produced, so the caller can seat it in the fight.
  */
-export function runICTurn(room, actor, scene) {
-    if (!hostIsHunting(room, actor))
-        return empty();
-    const out = empty();
+export function hostLaunchStep(room, scene, out) {
     const host = room.host;
-    // CRASHED IC LEAVES, AND COMES BACK (p.355-356): a program whose monitor
-    // filled since the last turn is off the list now, and the host
-    // relaunches it the very next turn -- "delayed, never destroyed".
+    let launched;
     if (host) {
-        // Last turn's crashes come back FIRST (p.355-356: "reactivated the very
-        // next turn"); what crashes this turn waits for the next call.
+        // Crashes first, then the relaunch: a program whose monitor filled
+        // during the last turn is off the list at the start of this one and
+        // comes straight back -- "reactivated the very next turn" -- taking
+        // the turn's one launch.
+        for (const kind of crashedIC(host)) {
+            crashIC(scene, host, kind);
+            out.lines.push(`  {red-fg}${kind} shears apart -- crashed. The host is already recompiling it.{/red-fg}`);
+        }
         if (host.relaunchQueue.length > 0 && room.runningIC.length < room.hostRating) {
             const kind = host.relaunchQueue.shift();
             room.runningIC.push(kind);
             if (scene)
-                spawnIC(scene, host, kind);
+                launched = spawnIC(scene, host, kind);
             out.lines.push(`  {red-fg}The host relaunches ${kind}.{/red-fg}`);
-        }
-        for (const kind of crashedIC(host)) {
-            crashIC(scene, host, kind);
-            out.lines.push(`  {red-fg}${kind} shears apart -- crashed. The host is already recompiling it.{/red-fg}`);
+            // ONE launch per turn (p.247): the relaunch was it.
+            return launched;
         }
     }
     if (room.runningIC.length < room.hostRating) {
@@ -335,26 +335,49 @@ export function runICTurn(room, actor, scene) {
         if (next) {
             room.runningIC.push(next.name);
             if (host && scene)
-                spawnIC(scene, host, next.name);
+                launched = spawnIC(scene, host, next.name) ?? launched;
             out.lines.push(next.kind === 'patrol'
                 ? `  {red-fg}${next.name} is already walking the host -- it never had to be launched.{/red-fg}`
                 : `  {red-fg}The host launches ${next.name}.{/red-fg}`);
         }
     }
-    // Every running program acts. An IC attack is a Complex Action
-    // (p.247), which is one program's whole turn.
+    return launched;
+}
+/**
+ * ONE PROGRAM'S ACTION -- an IC attack is a Complex Action (p.247), which
+ * is one program's whole Action Phase. `ice` is the program's own actor
+ * when the scene has one: it is what a failed attack damages.
+ */
+export function icActs(room, actor, type, out, ice) {
+    if (type.kind === 'patrol')
+        patrolActs(room, actor, out);
+    else if (type.kind === 'probe')
+        probeActs(room, actor, type, out, ice);
+    else if (type.kind === 'damage')
+        damageActs(room, actor, type, out, ice);
+    else
+        reducerOrConditionalActs(room, actor, type, out, ice);
+}
+/**
+ * ONE WHOLE COMBAT TURN of the host's ice, as a single call: the launch
+ * step, then every running program acts once. This is the shape the
+ * tests drive and the shape the engine used to run after EVERY player
+ * command ("one action inside an alerted host = one Combat Turn" -- an
+ * engine mapping that was never a rule, and that had four programs
+ * hitting a persona for typing "look"). In play the Combat Turn owns the
+ * pacing now (utilities/host-combat.ts): the launch at newTurn, each
+ * program in its own phase.
+ */
+export function runICTurn(room, actor, scene) {
+    if (!hostIsHunting(room, actor))
+        return empty();
+    const out = empty();
+    hostLaunchStep(room, scene, out);
     for (const name of room.runningIC) {
         const type = IC_TYPES.find(t => t.name === name);
         if (!type)
             continue;
-        if (type.kind === 'patrol')
-            patrolActs(room, actor, out);
-        else if (type.kind === 'probe')
-            probeActs(room, actor, out);
-        else if (type.kind === 'damage')
-            damageActs(room, actor, type, out);
-        else
-            reducerOrConditionalActs(room, actor, type, out);
+        icActs(room, actor, type, out, room.host?.iceActors.get(name));
     }
     return out;
 }
@@ -363,13 +386,29 @@ export function runICTurn(room, actor, scene) {
  * v. Intuition + Firewall (p.248). Returns the net hits; 0 or less is a
  * miss. Shared so the four reducers, Track and Scramble cannot drift
  * from Killer's version of the same roll.
+ *
+ * A FAILED ATTACK ACTION HURTS THE ATTACKER (p.247 "as with all Attack
+ * actions, a failed attack causes damage to the IC"; the amount is the
+ * general rule, Data Trails p.181: one box of Matrix damage per net hit
+ * the defender got, unresisted). Patrol makes no Attack action and is
+ * never here (hurtByFailure false). Applied to the program's own actor,
+ * which is its condition monitor (ic-actors.ts); a program crashed this
+ * way leaves at the next launch step like any other.
  */
-function icAttack(room, actor, type, out) {
+function icAttack(room, actor, type, out, ice) {
     const { pool, limit } = icAttackPool(room);
     const attack = rollPool(pool, limit);
     const defence = rollPool(icDefencePool(actor));
     const net = attack.hits - defence.hits;
     out.meta.push(`${type.name} -- Host Rating x2 [Attack ${limit}]: ${formatRoll(attack)} v. Intuition + Firewall: ${formatRoll(defence)} (net ${net})`);
+    if (net < 0 && type.hurtByFailure && ice && !ice.isDown()) {
+        const rebound = -net;
+        ice.takeDamage(rebound);
+        out.meta.push(`${type.name} -- failed Attack action: ${rebound} box${rebound === 1 ? '' : 'es'} back on the program, unresisted (p.247)`);
+        out.lines.push(ice.isDown()
+            ? `  {red-fg}${ice.name}'s own attack code rejects and tears it apart -- ${rebound} box${rebound === 1 ? '' : 'es'}, and its monitor fills.{/red-fg}`
+            : `  ${ice.name} eats its own rejected code -- ${rebound} box${rebound === 1 ? '' : 'es'} (${ice.conditionSummary()}).`);
+    }
     return net;
 }
 /**
@@ -389,8 +428,8 @@ function icAttack(room, actor, type, out) {
  * against the next IC, and Jammer really does lower the ceiling on your
  * own Brute Force.
  */
-function reducerOrConditionalActs(room, actor, type, out) {
-    const net = icAttack(room, actor, type, out);
+function reducerOrConditionalActs(room, actor, type, out, ice) {
+    const net = icAttack(room, actor, type, out, ice);
     if (net <= 0) {
         out.lines.push(`  ${type.name} probes at your icon and finds no purchase.`);
         return;
@@ -467,17 +506,13 @@ function applyMatrixDamage(actor, dealt, type, out) {
  * Probe IC spends its turns building. That coupling is canon's own, and
  * it is why Probe is worth a slot on a host that also fields a Killer.
  *
- * A FAILED IC ATTACK SHOULD DAMAGE THE IC (p.247) AND DOES NOT YET,
- * stated here rather than left for the next reader to discover. Modelling
- * it needs a condition monitor per program AND a way for the player to
- * attack ice, and neither exists: there is no cybercombat path against
- * IC in this engine at all. Half of it -- ice that hurts itself while
- * the player still cannot swing back -- would be worse than neither
- * half. It lands with the verb.
+ * A FAILED IC ATTACK DAMAGES THE IC (p.247) -- see icAttack, where it
+ * lands for every attacking program at once. The player's side of it,
+ * cybercombat against ice, is `attack <program>` inside the host.
  */
-function damageActs(room, actor, type, out) {
+function damageActs(room, actor, type, out, ice) {
     const { limit } = icAttackPool(room);
-    const net = icAttack(room, actor, type, out);
+    const net = icAttack(room, actor, type, out, ice);
     if (net <= 0) {
         out.lines.push(`  ${type.name} lunges at your icon and closes on nothing.`);
         return;
@@ -608,12 +643,10 @@ function patrolActs(room, actor, out) {
  * read in Phase 4. The engine previously modelled the host's side as the
  * single boolean `hostAlert`, which cannot answer "how many".
  */
-function probeActs(room, actor, out) {
-    const { pool, limit } = icAttackPool(room);
-    const attack = rollPool(pool, limit);
-    const defence = rollPool(icDefencePool(actor));
-    const net = attack.hits - defence.hits;
-    out.meta.push(`Probe IC -- Host Rating x2 [Attack ${limit}]: ${formatRoll(attack)} v. Intuition + Firewall: ${formatRoll(defence)} (net ${net})`);
+function probeActs(room, actor, type, out, ice) {
+    // The same opposed roll as every attacking program (icAttack), so a
+    // failed probe rebounds on the program like any failed Attack action.
+    const net = icAttack(room, actor, type, out, ice);
     const held = room.hostMarksOn.get(actor.name) ?? 0;
     if (net <= 0) {
         out.lines.push(`  Probe IC tests your edges and finds nothing to hold onto.`);

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

@@ -1,6 +1,7 @@
 import { Category } from '../types/shared/item-enum.js';
 import { inMeleeReach, isInCover, coverAvailableFor, actorDistanceMeters } from './spots.js';
 import { Logger } from './logger.js';
+import { runIcActionPhase } from './ic-brain.js';
 /**
  * AN NPC'S ACTION PHASE, PLAYED BY RULE (SR5 p.163-167).
  *
@@ -25,6 +26,10 @@ import { Logger } from './logger.js';
  * Nothing here rolls a die of its own: the verbs do.
  */
 export async function runNpcActionPhase(enc, npc) {
+    // A HOST'S PROGRAM HAS ITS OWN BRAIN (utilities/ic-brain.ts): no
+    // weapon to draw, no ground to close -- one test, by type.
+    if (npc.icKind !== undefined)
+        return runIcActionPhase(enc, npc);
     const logger = Logger.getInstance();
     if (npc.isIncapacitated() || npc.surrendered)
         return;

package/bundle/typescript/src/commands/game/sideQuest/utilities/perception.js

@@ -39,36 +39,65 @@ import { mentalLimit } from './limits.js';
  *  an active search mechanically different from a passive glance. */
 export const ACTIVELY_LOOKING = 3;
 /**
- * ON THE GRID IT IS A DIFFERENT TEST WITH A DIFFERENT BRACKET. Matrix
- * Search is Computer + Logic [Data Processing], so the Mental limit does
- * NOT apply out there -- capping a decker's sweep by their Willpower
- * would be a fresh deviation dressed as a fix. The engine takes the
- * best of Perception and Computer so pre-Computer deckers lose nothing
- * (a standing allowance, older than this function).
+ * THE MEAT PERCEPTION TEST. The Matrix used to ride through here as a
+ * "different test with a different bracket" -- Logic + the better of
+ * Perception and Computer [Data Processing] -- which was neither Matrix
+ * Perception nor Matrix Search. It is matrixSearchTest now, below; the
+ * grid never comes through this door.
+ */
+export function perceptionTest(actor, opts = {}) {
+    const skill = actor.skillRating('perception');
+    // Unskilled defaults at -1 (p.130), exactly as both callers already did.
+    const pool = Math.max(1, actor.intuition
+        + (skill > 0 ? skill : -1)
+        + (opts.active ? ACTIVELY_LOOKING : 0)
+        + actor.bonus('perception')
+        + actor.woundModifier
+        - actor.sustainingPenalty);
+    return { pool, limit: mentalLimit(actor) };
+}
+/**
+ * MATRIX SEARCH (SR5 p.241, RAG-checked 2026-09-13): a Special action,
+ * "Computer + Intuition [Data Processing]" -- INTUITION, not Logic; the
+ * old grid branch above rolled Logic and called it canon. The threshold
+ * and the base time come from what is being looked for (the Matrix
+ * Search Table: public 1 / 1 minute, limited 3 / 30 minutes; inside a
+ * host the base time is one minute whatever the information), net hits
+ * over the threshold divide the time, and a failure still spends all
+ * of it. A Browse program "cuts the base time in half" (Splintered
+ * State p.54) -- time, not dice. Running silent costs its -2 like every
+ * Matrix action (p.235-236).
  *
  * Data Processing reads 0 for an actor with no deck at all; that is a
  * caller's missing gate rather than a real limit, so it degrades to
  * unlimited here instead of handing rollPool a zero it would reject.
  */
-export function perceptionTest(actor, opts = {}) {
-    const onGrid = actor.plane === 'matrix';
-    const skill = onGrid
-        ? Math.max(actor.skillRating('perception'), actor.skillRating('computer'))
-        : actor.skillRating('perception');
-    const attribute = onGrid ? actor.logic : actor.intuition;
-    // Unskilled defaults at -1 (p.130), exactly as both callers already did.
-    const pool = Math.max(1, attribute
+export function matrixSearchTest(actor) {
+    const skill = actor.skillRating('computer');
+    const pool = Math.max(1, actor.intuition
         + (skill > 0 ? skill : -1)
-        + (opts.browse ?? 0)
-        + (opts.active ? ACTIVELY_LOOKING : 0)
         + actor.bonus('perception')
+        + (typeof actor.matrixActionPenalty === 'number' ? actor.matrixActionPenalty : 0)
         + actor.woundModifier
         - actor.sustainingPenalty);
-    const dataProcessing = onGrid ? actor.matrixAttribute('dataProcessing') : 0;
-    const limit = onGrid
-        ? (dataProcessing > 0 ? dataProcessing : undefined)
-        : mentalLimit(actor);
-    return { pool, limit };
+    const dataProcessing = actor.matrixAttribute('dataProcessing');
+    return { pool, limit: dataProcessing > 0 ? dataProcessing : undefined };
+}
+/** The Matrix Search Table (p.241-242): threshold and base time in
+ *  seconds. Inside a host the base time is one minute regardless. */
+export const MATRIX_SEARCH = {
+    public: { threshold: 1, seconds: 60 },
+    inHost: { threshold: 3, seconds: 60 },
+};
+/** How long a search takes once rolled: the base time divided by the
+ *  net hits over the threshold, never under one Combat Turn (3s); a
+ *  failure spends the whole base time. Browse halves the base. */
+export function matrixSearchSeconds(baseSeconds, hits, threshold, browse) {
+    const base = browse ? Math.ceil(baseSeconds / 2) : baseSeconds;
+    if (hits < threshold)
+        return base;
+    const net = hits - threshold;
+    return net > 0 ? Math.max(3, Math.ceil(base / net)) : base;
 }
 /**
  * PERCEPTION THRESHOLDS (p.136). Named because the numbers appear in

package/bundle/typescript/src/commands/game/sideQuest/utilities/persistence.js

@@ -164,6 +164,8 @@ export function serializeItem(item) {
         out.loadedAmmo = item.loadedAmmo;
     if (item.jammed)
         out.jammed = true;
+    if (item.bricked)
+        out.bricked = true;
     if (item.deckDamage > 0)
         out.deckDamage = item.deckDamage;
     if (item.droneDamage > 0)
@@ -219,6 +221,8 @@ export function restoreItem(json) {
         item.loadedAmmo = json.loadedAmmo;
     if (json.jammed)
         item.jammed = true;
+    if (json.bricked)
+        item.bricked = true;
     if (json.deckDamage)
         item.takeDeckDamage(json.deckDamage);
     if (json.droneDamage)
@@ -663,7 +667,7 @@ export function captureHubOverlay(scene, hubSeed, player, homeRoom) {
         .map(n => n.player.name)
         .filter(name => !scene.getActor(name));
     const devices = [...collectDevices(scene).entries()]
-        .map(([name, d]) => ({ name, open: d.isOpen(), ...(d.barrierDamage > 0 ? { damage: d.barrierDamage } : {}) }));
+        .map(([name, d]) => ({ name, open: d.isOpen(), ...(d.barrierDamage > 0 ? { damage: d.barrierDamage } : {}), ...(d.isBricked ? { bricked: true } : {}) }));
     // THE TOMBSTONE (see ISavedHub.puzzles): always [], never read here.
     // Omitting it crashes v5.64.0's unguarded for-of on resume, and
     // saves move between builds via the cloud mirror.
@@ -824,7 +828,7 @@ export function applyHubOverlay(scene, saved, player, homeRoom) {
     for (const d of saved.devices ?? []) {
         const live = liveDevices.get(d.name);
         if (live)
-            live.restoreState({ open: d.open, damage: d.damage });
+            live.restoreState({ open: d.open, damage: d.damage, bricked: d.bricked });
     }
     // A SAVE WRITTEN BEFORE DEVICES EXISTED has no `devices` key at all,
     // so every device would read shut -- while the door it holds stays

package/bundle/typescript/src/commands/game/sideQuest/utilities/planes.js

@@ -209,6 +209,11 @@ export const DUMPSHOCK_DV = 6;
 export function leaveMatrix(scene, actor, opts) {
     const lines = [];
     const body = actor.bodyRoom;
+    // OUT OF THE MATRIX IS OUT OF THE FIGHT (utilities/host-combat.ts): a
+    // persona leaving its host arena -- jack out, link-lock broken, deck
+    // bricked, Scramble, convergence -- is no longer a participant. Before
+    // endPersona clears the position the arena is read off.
+    scene.encounterFor?.(actor)?.leave(actor);
     if (opts?.forced) {
         lines.push(...applyDumpshock(actor, opts.reason ?? `The connection is severed from the other side.`));
     }

package/bundle/typescript/src/commands/game/sideQuest/utilities/surveillance.js

@@ -85,6 +85,10 @@ export function directConnectionBlocker(actor, room) {
 export function camerasLive(rooms, room) {
     if (!isWatched(room))
         return false;
+    // Looped by Control Device or bricked by a Data Spike (commands/
+    // disable.ts): the house sees nothing from this cluster either way.
+    if (room.camerasLooped || room.camerasBricked)
+        return false;
     if (room.hasNode)
         return !room.hostCracked;
     const hosts = Object.values(rooms).filter(r => r.hasNode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.181.0",
+  "version": "5.183.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",