@maka/maka-cli 5.77.0 → 5.79.0

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

@@ -20,6 +20,8 @@ import { getPref } from './utilities/prefs.js';
 import { rollPool, formatRoll } from './utilities/dice.js';
 import { Direction } from './types/shared/direction-enum.js';
 import { Logger } from './utilities/logger.js';
+import { runHostTurn } from './utilities/ic.js';
+import { leaveMatrix } from './utilities/planes.js';
 import { CommandQueue } from './utilities/command-queue.js';
 import { currentSession } from './utilities/session-context.js';
 import { PlayersCommand } from './commands/players.js';
@@ -3047,6 +3049,12 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.player.plane = 'meat';
         this.player.bodyRoom = undefined;
         this.player.simMode = undefined;
+        // This path leaves the Matrix WITHOUT going through leaveMatrix, so
+        // it has to drop the keep-alives itself. Found by enumerating every
+        // exit rather than trusting the choke point: a link-lock left set
+        // here would ride the cab home and the next jack-in would start
+        // already trapped, with nothing on the grid holding it.
+        this.player.linkLockedBy.clear();
         this.player.astralTicks = 0;
         this.player.activeDeck = undefined;
         this.player.riggedDrone = undefined;
@@ -3092,6 +3100,9 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         this.player.plane = 'meat';
         this.player.bodyRoom = undefined;
         this.player.simMode = undefined;
+        // Same reason as settleTravelState: an exit that bypasses
+        // leaveMatrix must drop the link-lock itself.
+        this.player.linkLockedBy.clear();
         this.player.astralTicks = 0;
         this.player.activeDeck = undefined;
         this.player.riggedDrone = undefined;
@@ -4528,8 +4539,6 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
                 isOtherPlayer: a => this.scene.isHumanControlled(a),
             });
             if (roomLines.length > 0) {
-                // roomCaption owns BOTH halves now -- where you stand, and that
-                // somebody here has no cell to be drawn in (S6b4TLQWq46RN5kGu).
                 roomLines.push(caption(roomCaption(here, this.player), boxWidth));
             }
             this.setRoomOverlay(roomLines);
@@ -4682,7 +4691,7 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         const command = CommandFactory.createCommand(verb, context);
         if (command) {
             const result = await command.execute(args);
-            return out(result);
+            return out(this.withICTurn(actor, result));
         }
         // Typo tolerance: two straight sessions bounced on slips like "searh"
         // and "maop". Reuse the same fuzzy matcher item/NPC names go through
@@ -4709,6 +4718,81 @@ ${client.name} won't be remembering anything. Dead Johnsons pay nothing -- and t
         }
         return out(`I don't understand the command "${verb}".`);
     }
+    /**
+     * THE HOST'S TURN, appended to whatever the player's action returned.
+     *
+     * This is the Combat Turn mapping from the IC design, and it is an
+     * ENGINE MAPPING rather than a rule: canon paces IC in Combat Turns
+     * (one program launched per turn, at the beginning of it) and this
+     * engine has no Matrix initiative structure, so ONE PLAYER ACTION
+     * TAKEN INSIDE AN ALERTED HOST counts as one turn. Not a citation, and
+     * not presented as one.
+     *
+     * It hangs off the single command dispatch rather than off hack.ts on
+     * purpose. Ice hunts you while you do ANYTHING in the host -- looking,
+     * moving, taking -- so hooking only the hacking verb would have made
+     * the host blind to every other action, which is the "fixed one verb,
+     * left its siblings" shape CLAUDE.md warns about.
+     *
+     * utilities/ic.ts decides whether anything happens at all
+     * (hostIsHunting); this only carries the result to the panes.
+     */
+    withICTurn(actor, result) {
+        if (result === null)
+            return null;
+        const room = actor.currentLocation;
+        // Phase 1b widened this gate. It used to ask hostIsHunting, which is
+        // only true AFTER the host had made someone -- so the host could
+        // never notice you in the first place, and measurement said so:
+        // twelve runs, twelve cracked hosts, zero sightings. A host with a
+        // node gets its turn whenever a persona is standing in it, and
+        // ic.ts decides whether that turn is eyes or ice.
+        if (!room || actor.plane !== 'matrix' || !room.hasNode)
+            return result;
+        const turn = runHostTurn(room, actor);
+        if (turn.lines.length === 0 && turn.meta.length === 0)
+            return result;
+        // Dice to the Mechanics pane, and only for a human -- the same gate
+        // every other roll in this engine uses.
+        if (this.scene.isHumanControlled(actor)) {
+            const logger = Logger.getInstance();
+            for (const m of turn.meta)
+                logger.meta(m);
+        }
+        for (const w of turn.world)
+            this.scene.addWorldEvent(w);
+        // A deck bricked by IC owes the same forced dump a convergence does.
+        // ic.ts reports it rather than performing it -- leaveMatrix needs the
+        // Scene and that module deliberately takes none, exactly as hack.ts
+        // splits the convergence hammer from the dump that follows it.
+        if (turn.bricked) {
+            turn.lines.push(...leaveMatrix(this.scene, actor, {
+                forced: true,
+                reason: `The host's ice burns your deck out from under you.`,
+            }));
+        }
+        else if (turn.scrambled) {
+            // SCRAMBLE IC (p.248): "you reboot immediately, taking dumpshock if
+            // you were in VR." A forced exit through the same door, which is
+            // what makes it a reboot rather than a graceful drop -- and the
+            // reboot is also what hands the reducers' damage back.
+            //
+            // `else if` on purpose: a deck already bricked this turn has been
+            // dumped, and dumping a persona twice would bill dumpshock twice.
+            turn.lines.push(...leaveMatrix(this.scene, actor, {
+                forced: true,
+                reason: `Scramble IC rips the connection out at the root --`,
+            }));
+        }
+        if (turn.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
+            // world, rather than a second parallel notion of "they know".
+            this.addHeat(4, `Track IC reported ${actor.name}'s location`);
+        }
+        const body = turn.lines.join('\n');
+        return result.length > 0 ? `${result}\n${body}` : body;
+    }
     /**
      * The help taxonomy: every entry is [primary, ...aliases], grouped the
      * way a player thinks, not the order commands were registered. The