@maka/maka-cli 5.180.0 → 5.182.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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.180.0",
+  "version": "5.182.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.",