@maka/maka-cli 5.167.0 → 5.169.0

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

@@ -6,7 +6,8 @@ import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { describeFledTarget } from '../utilities/pursuit.js';
 import { shellsInRoom, resolveBodyAttack, crossPlaneRefusal } from '../utilities/planes.js';
 import { heldBy, holding } from '../utilities/grapple.js';
-import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_FLOOR } from '../utilities/spots.js';
+import { spotOf, ensureAtSpot, ensureAtExit, canReach, spotDistanceMeters, OPEN_FLOOR, inMeleeReach, actorCell, standingRoomNear, spotForCell } from '../utilities/spots.js';
+import { distanceMeters } from '../utilities/room-grid.js';
 import { resolveBarrierStrike } from '../utilities/barrier-combat.js';
 import { billAction, notYourPhase, phaseHint } from '../utilities/action-cost.js';
 import { spendMovementMeters } from '../utilities/movement-cost.js';
@@ -400,6 +401,31 @@ export class AttackCommand extends Command {
                 if (reach.line)
                     report.push(reach.line);
             }
+            // THE LAST FEW PACES (HBssKNQahWxGR95wB: "Ellis is able to attack
+            // me, however his position is several squares away from me, not
+            // in melee range"). Sharing a SPOT is not standing together: the
+            // open floor is one spot across most of a room, and bodies hold
+            // their own cells on it. The gate above closes spot to spot and
+            // stopped there, so a swing landed from wherever on the floor the
+            // attacker happened to be seated. Close cell to cell the way
+            // "move to <person>" does (move.ts crossToActor) -- billed as
+            // ground in a fight, walked for free outside one -- and if the
+            // ground can't be covered this phase, the blow does not happen.
+            if (!inMeleeReach(actor, target)) {
+                const theirs = actorCell(room, target);
+                const cell = theirs ? standingRoomNear(room, theirs, actor) : undefined;
+                if (cell) {
+                    const from = actorCell(room, actor);
+                    const paces = from ? distanceMeters(from, cell) : 0;
+                    const spend = spendMovementMeters(this.scene, actor, paces, 'walk', this.logger);
+                    if (spend)
+                        return `${target.name} is ${Math.round(paces)} m away. ${spend}`;
+                    actor.atCell = cell;
+                    actor.atSpot = spotForCell(room, cell);
+                    actor.performAction('steps up beside', target.name);
+                    report.push(`${actor === this.scene.getPlayer() ? 'You close' : `${actor.name} closes`} the last few paces on ${target.name}.`);
+                }
+            }
         }
         // THE ACTION.
         const label = isMelee ? (this.usesEquippedWeapon() ? 'Melee Attack' : 'Subdue') : 'Fire Weapon';

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

@@ -4,6 +4,7 @@ import { hint } from '../utilities/hints.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { spotOf, spotsActive, sealedRouteTo } from '../utilities/spots.js';
 import { distanceMeters } from '../utilities/room-grid.js';
+import { onTheWall } from '../utilities/climb-state.js';
 class VerticalCommand extends Command {
     async travel(way, args) {
         const actor = this.actor;
@@ -19,6 +20,26 @@ class VerticalCommand extends Command {
         // rule move applies to every other crossing.
         const from = mine ? grid.spotCells.get(mine) : undefined;
         const myZ = from?.z ?? 0;
+        // ALREADY ON A WALL (6SmvvRRtn9eEMZSbF: "when I'm 1m up, and I use
+        // 'descend', it says I'm already on the floor").
+        //
+        // Destinations here are chosen by STOREY, and a runner a metre up
+        // a climb is still, by spot, on the storey they left. So "descend"
+        // looked for a level below the floor, found none, and reported the
+        // ground floor -- true, and useless to someone hanging off a wall.
+        // Part-way up, the two verbs mean the two directions along the
+        // wall you are on: the one the climb is going is more of it, the
+        // other is the way back. Naming a different place falls through to
+        // move, which refuses it (you are not on the floor to cross).
+        const wall = onTheWall(actor);
+        const query = (args ?? []).filter(w => !/^(to|the|a|an|up|down)$/i.test(w)).join(' ').trim();
+        if (wall && (query.length === 0 || fuzzyPickName(query, [wall.target, wall.from]) !== undefined)) {
+            const onward = way === 'up' ? wall.up : !wall.up;
+            const mover = new MoveCommand({
+                actor, scene: this.scene, rooms: this.rooms, screen: this.screen, game: this.game,
+            });
+            return onward ? await mover.execute([wall.target]) : await mover.retreatFromClimb();
+        }
         // Every spot on a level in the direction asked for.
         const candidates = [...grid.spotCells.entries()]
             .filter(([, c]) => (way === 'up' ? c.z > myZ : c.z < myZ))
@@ -45,7 +66,6 @@ class VerticalCommand extends Command {
                 : `You're on the ground floor already.${hint(` ("${other}" goes up.)`)}`;
         }
         let target = candidates[0];
-        const query = (args ?? []).filter(w => !/^(to|the|a|an|up|down)$/i.test(w)).join(' ').trim();
         if (query.length > 0) {
             const picked = fuzzyPickName(query, candidates);
             if (!picked) {

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

@@ -10,6 +10,7 @@ import { hint } from '../utilities/hints.js';
 import { fuzzyPickName } from '../utilities/fuzzy-match.js';
 import { gridIconBlock } from '../utilities/grid-view.js';
 import { requirePhase } from '../utilities/action-cost.js';
+import { midClimbRefusal } from '../utilities/climb-state.js';
 import { camerasLive } from '../utilities/surveillance.js';
 import { maybeSinSweep } from '../utilities/sin.js';
 import { despawnEphemerals } from '../utilities/ephemeral.js';
@@ -167,6 +168,12 @@ export class GoCommand extends Command {
         if (gripHeld) {
             return `You're holding ${gripHeld.name} -- walk away and the hold is gone. "release" first if that's the plan.`;
         }
+        // ON A WALL, NOT ON THE FLOOR (6SmvvRRtn9eEMZSbF): a runner
+        // part-way up a climb has no door within reach. Same gate as
+        // move.ts; the refusal names both ways off the wall.
+        const wall = midClimbRefusal(this.actor);
+        if (wall)
+            return wall;
         // THE COMBAT TURN (utilities/combat-turn.ts): leaving the room is
         // movement, and movement happens on your own Action Phase.
         const phase = requirePhase(this.scene, this.actor);

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

@@ -12,7 +12,7 @@ import { matchesCameraName, hostLabel } from '../utilities/grid-names.js';
 import { TapCommand } from './tap.js';
 import { sameHostSide } from '../models/player.js';
 import { MAX_MARKS } from '../utilities/marks.js';
-import { declarationPenalty, parseMarkDeclaration, hostDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
+import { declarationPenalty, parseMarkDeclaration, hostDefensePool, wanDefensePool, freeMatrixPerceptionHits, bruteForceMatrixDv, overwatchFromDefense, GO_BIG_QUALITY, deviceDefensePool } from '../utilities/matrix-intrusion.js';
 /**
  * MARKS A PAN INTRUSION MUST ALREADY HOLD before it can command the
  * device rather than merely key it (Control Device, p.238: 1 mark for a
@@ -453,20 +453,53 @@ export class HackCommand extends BypassCommand {
      */
     async tryDeviceHack(args, mode, declaredMarks) {
         const actor = this.actor;
-        const host = actor.insideHost;
         const named = args.join(' ').trim();
-        if (!host || !named)
-            return null;
-        const devices = host.openableDevices().filter(d => d.rating > 0);
-        if (devices.length === 0)
+        if (!named)
             return null;
         const raw = named.toLowerCase();
-        const matches = devices.filter(d => d.name.toLowerCase().includes(raw)
+        const matching = (room) => room.openableDevices().filter(d => d.rating > 0).filter(d => d.name.toLowerCase().includes(raw)
             || (d.opensExit ?? '').toLowerCase() === raw
             || d.description.toLowerCase().includes(raw));
-        if (matches.length !== 1)
-            return null;
-        const device = matches[0];
+        // INSIDE THE HOST you are directly connected to every device on
+        // its WAN (p.233; Data Trails p.87-88): the slave defends with its
+        // own rating and nothing more.
+        let host = actor.insideHost;
+        let viaWan = false;
+        let device;
+        if (host) {
+            const matches = matching(host);
+            if (matches.length !== 1)
+                return null;
+            device = matches[0];
+        }
+        else {
+            // FROM THE GRID (ZdhkP8mAP9QhpqFvA: "shouldn't I be able to hack
+            // the Warehouse maglock, it has DR 2 and I can see the icon").
+            // The icon IS on the map, and this fell through to "nothing on
+            // the grid answers to 'maglock'" -- a lie about a thing the same
+            // screen had just drawn. Canon (p.233, p.355-356): a device on a
+            // host's WAN "cannot be accessed without first gaining access
+            // (via a mark) to the Host itself", and when it IS attacked
+            // through the network it defends with its own or its master's
+            // rating, whichever is higher, per rating. So: no mark on the
+            // host, the lock is named and refused with the rule; a mark
+            // held, the lock is hackable from out here against the host's
+            // numbers. Getting inside is still the way to face the lock's
+            // own DR alone.
+            const rooms = this.rooms ?? this.scene.getRooms();
+            const found = hostsInReach(rooms, actor)
+                .map(r => ({ room: r, matches: matching(r) }))
+                .filter(x => x.matches.length === 1);
+            if (found.length !== 1)
+                return null;
+            host = found[0].room;
+            device = found[0].matches[0];
+            viaWan = true;
+            const onHost = host.hostMarksBy.get(actor.name) ?? 0;
+            if (onHost < 1) {
+                return `${device.name} is on the map, but it hangs off ${hostLabel(host)}'s WAN -- slaved, and a host's devices answer nobody who holds no mark on the host itself (p.233).${hint(` ("hack ${hostLabel(host)}" for a mark first; "enter" once you have one and the lock defends with its own DR ${device.rating} alone.)`)}`;
+            }
+        }
         const held = device.marksBy.get(actor.name) ?? 0;
         if (held >= MAX_MARKS) {
             return `You already hold ${MAX_MARKS} marks on ${device.name} -- it answers to you as readily as to the house.`;
@@ -484,7 +517,9 @@ export class HackCommand extends BypassCommand {
                 + silence + actor.woundModifier - actor.sustainingPenalty + declarePenalty);
         actor.performAction('works a slaved icon', device.name);
         const roll = rollPool(pool, limit, { gremlins: actor.deckGremlins });
-        const defense = deviceDefensePool(device);
+        // From the grid the slave borrows its master's numbers where they are
+        // higher (p.233); inside, it stands alone (Data Trails p.87-88).
+        const defense = viaWan ? wanDefensePool(device, host.host) : deviceDefensePool(device);
         const defenseRoll = rollPool(defense.pool);
         const netHits = roll.hits - defenseRoll.hits;
         if (this.scene.isHumanControlled(actor)) {
@@ -507,6 +542,14 @@ export class HackCommand extends BypassCommand {
         }
         const now = Math.min(MAX_MARKS, held + declared);
         device.marksBy.set(actor.name, now);
+        // A MARK ON A SLAVE IS A MARK ON THE MASTER (p.233: "if you get a
+        // mark on a slave you also get a mark on the master"; Data Trails
+        // p.87-88 works it: "1 mark on the device and its master (the
+        // host)"). One, not `declared` -- the declaration bought marks on
+        // the lock; the host gets the one canon hands over with it.
+        const onHost = host.hostMarksBy.get(actor.name) ?? 0;
+        if (onHost < MAX_MARKS)
+            host.hostMarksBy.set(actor.name, onHost + 1);
         this.logger.write(`Mark: ${actor.name} -> device ${device.name} (${now}/${MAX_MARKS}, ${mode}).`);
         const lines = [`${device.name} takes your key -- ${now} of ${MAX_MARKS} mark${now === 1 ? '' : 's'} on it now.`];
         // BRUTE FORCE BURNS WHAT IT FORCES (p.238): 1 DV per two full net