@maka/maka-cli 5.129.0 → 5.131.0

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

@@ -3631,7 +3631,7 @@ export class Player extends AbstractPlayer {
             return;
         this._sustainedArmor = next;
         if (next === 0)
-            this.sustainedForces.delete('armor');
+            this.onSustainDropped('armor');
         // SUSTAINS BEAT ON FLIP (web report 2026-09-02: "I cast armor on myself
         // and don't see it in the sustained list"): the sheet only caught up on
         // the next unrelated beat. Every sustain mutator fires the hook now.
@@ -3682,8 +3682,27 @@ export class Player extends AbstractPlayer {
      * spells in `sustainedForces`.
      */
     sustainedWorkings() {
+        const mine = this.wornWorkings().filter(w => w.caster === undefined).map(({ caster: _c, ...w }) => w);
+        const onOthers = [];
+        for (const bearer of this.sustainedBearers) {
+            const held = bearer.wornWorkings().filter(w => w.caster === this);
+            if (held.length === 0) {
+                this.sustainedBearers.delete(bearer);
+                continue;
+            }
+            for (const { caster: _c, ...w } of held)
+                onOthers.push({ ...w, bearer: bearer.name });
+        }
+        return [...mine, ...onOthers];
+    }
+    /**
+     * Every working whose STATE is on this character, with who holds it
+     * up when that is somebody else. The bearer's view; sustainedWorkings
+     * is the holder's.
+     */
+    wornWorkings() {
         const spell = (key, force) => ({
-            key, kind: 'spell', force, category: spellFor(key)?.category.toLowerCase(),
+            key, kind: 'spell', force, category: spellFor(key)?.category.toLowerCase(), caster: this.sustainedCasters.get(key),
         });
         return [
             ...this.sustainedForms.map((f) => ({ key: f.key, kind: 'form', force: f.level })),
@@ -3749,15 +3768,22 @@ export class Player extends AbstractPlayer {
         }
     }
     releaseSustainedWorkings() {
-        const count = this.sustainedWorkings().length;
-        this.sustainedForms = [];
-        this._sustainedArmor = 0;
-        this.sustainedInvisibility = false;
-        this.sustainedReflexes = false;
-        this.sustainedBarrier = undefined;
-        this.sustainedManaBarrier = undefined;
-        this.sustainedForces.clear();
-        return count;
+        // What this character HOLDS -- their own, and what they hold on
+        // others (which ends on the bearer). A spell somebody else holds on
+        // this character is that caster's concentration, and sleeping in
+        // it does not break it.
+        const held = this.sustainedWorkings();
+        for (const w of held) {
+            if (w.bearer === undefined) {
+                this.dropSustainedWorking(w.key);
+                continue;
+            }
+            for (const bearer of this.sustainedBearers) {
+                if (bearer.name === w.bearer)
+                    bearer.dropSustainedWorking(w.key);
+            }
+        }
+        return held.length;
     }
     // The other sustained spells (RAW gear/spell pass): invisibility bends
     // light around the bearer (+3 on sneak contests, npc.ts), increase
@@ -3770,7 +3796,7 @@ export class Player extends AbstractPlayer {
             return;
         this._sustainedInvisibility = v;
         if (!v)
-            this.sustainedForces.delete('invisibility');
+            this.onSustainDropped('invisibility');
         this.noteConditionChanged();
     }
     _sustainedReflexes = false;
@@ -3780,9 +3806,72 @@ export class Player extends AbstractPlayer {
             return;
         this._sustainedReflexes = v;
         if (!v)
-            this.sustainedForces.delete('reflexes');
+            this.onSustainDropped('reflexes');
         this.noteConditionChanged();
     }
+    /**
+     * WHO HOLDS A SPELL THAT IS ON THIS CHARACTER, when it is not them
+     * (2026-09-06: "bill the caster, not the bearer"). SR5 p.282 puts the
+     * -2 on whoever SUSTAINS the spell; the subject only wears it. Until
+     * this the engine taxed the bearer -- a mundane street sam with an
+     * ally's armor on them lost two dice off every pool, and the mage
+     * holding it up paid nothing.
+     *
+     * The effect state stays on the bearer (that is what grants the
+     * soak); this map is the other half, and the caster's ledger reads
+     * it through `sustainedBearers`. Session-only, like every sustain.
+     */
+    sustainedCasters = new Map();
+    /** The characters this one holds a spell on. Pruned at read time. */
+    sustainedBearers = new Set();
+    /** Record that `caster` is the one holding `key` up on this character. */
+    sustainedBy(key, caster) {
+        if (caster === this) {
+            this.sustainedCasters.delete(key);
+            return;
+        }
+        this.sustainedCasters.set(key, caster);
+        caster.sustainedBearers.add(this);
+        caster.noteConditionChanged();
+    }
+    /** The caster holding `key` on this character, when it is somebody else. */
+    wornSpellCaster(key) {
+        return this.sustainedCasters.get(key);
+    }
+    /** Bookkeeping when a spell on this character ends, whoever ended it. */
+    onSustainDropped(key) {
+        this.sustainedForces.delete(key);
+        const caster = this.sustainedCasters.get(key);
+        if (caster) {
+            this.sustainedCasters.delete(key);
+            caster.noteConditionChanged();
+        }
+    }
+    /** End one working by key, whatever kind it is. */
+    dropSustainedWorking(key) {
+        switch (key) {
+            case 'armor':
+                this.setSustainedArmor(0);
+                return;
+            case 'invisibility':
+                this.sustainedInvisibility = false;
+                return;
+            case 'reflexes':
+                this.sustainedReflexes = false;
+                return;
+            case 'barrier':
+                this.sustainedBarrier = undefined;
+                return;
+            case 'manabarrier':
+                this.sustainedManaBarrier = undefined;
+                return;
+            default: {
+                const i = this.sustainedForms.findIndex(f => f.key === key);
+                if (i >= 0)
+                    this.sustainedForms.splice(i, 1);
+            }
+        }
+    }
     /** The sustained PHYSICAL BARRIER spell (ruling 2026-08-24): seals
      *  one exit of one room while held -- go.ts and move refuse passage
      *  for everyone (the caster included; walls don't play favorites).
@@ -3793,6 +3882,8 @@ export class Player extends AbstractPlayer {
         if (this._sustainedBarrier === v)
             return;
         this._sustainedBarrier = v;
+        if (!v)
+            this.onSustainDropped('barrier');
         this.noteConditionChanged();
     }
     /** The MANA BARRIER twin (canon p.294, RAG-checked): blocks SPIRITS
@@ -3804,6 +3895,8 @@ export class Player extends AbstractPlayer {
         if (this._sustainedManaBarrier === v)
             return;
         this._sustainedManaBarrier = v;
+        if (!v)
+            this.onSustainDropped('manabarrier');
         this.noteConditionChanged();
     }
     // THREADED COMPLEX FORMS (M4.15, see commands/thread.ts): the

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

@@ -105,7 +105,18 @@ export function parseCatalogVersion(raw) {
     const n = Number(raw);
     return Number.isFinite(n) ? n : undefined;
 }
+/**
+ * Set by resetCatalogForTest and never cleared: a suite that has reset
+ * the catalog wants ONLY what it applies. Found 2026-09-06, the day the
+ * developer's cache moved to v17 -- every fixture pinned at 16 lost the
+ * "highest version wins" contest to a file in the home directory, and
+ * eleven accessor tests went red on one machine and green on every
+ * other. Exactly the failure the note above says a test must not have.
+ */
+let diskCacheDisabled = false;
 function readCache() {
+    if (diskCacheDisabled)
+        return undefined;
     try {
         const parsed = JSON.parse(fs.readFileSync(cachePath(), 'utf8'));
         if (Array.isArray(parsed?.items) && parsed.items.length > 0)
@@ -571,6 +582,10 @@ export function resetCatalogForTest() {
     liveSource = undefined;
     resolved = undefined;
     fetchAttempted = false;
+    // The machine's cache is out of the contest from here on: a fixture
+    // applied after this is the whole catalog, whatever version it says.
+    // A test that wants a cache passes its own reader (CacheReader).
+    diskCacheDisabled = true;
     resetCatalogIndexes();
 }
 /**

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

@@ -3,6 +3,7 @@ import { crashIC } from './ic-actors.js';
 import { samePlace } from './matrix-roster.js';
 import { NPC } from '../models/npc.js';
 import { rollPool, formatRoll, rollInitiativeScore, formatInitiative, INITIATIVE_PASS_DROP } from './dice.js';
+import { droneComesApartLine } from './drone-prose.js';
 import { leaveMatrix, leaveDrone } from './planes.js';
 import { spotOf, spotCell, seatingIn, actorCell, OPEN_FLOOR, isInCover, coverAvailableFor, takeCoverHere } from './spots.js';
 import { heldBy } from './grapple.js';
@@ -619,7 +620,7 @@ export class CombatExchange {
                 lines.push(`  ${defender.name} takes ${dealt} box${dealt === 1 ? '' : 'es'} to the airframe: ${device.droneSummary()}`);
                 if (device.isWrecked) {
                     defender.takeDamage(defender.maxConditionBoxes);
-                    lines.push(`  The frame comes apart -- rotors, casing, sparks.`);
+                    lines.push(`  ${droneComesApartLine(device)}`);
                 }
                 return { world: [...lines, ...dryWarning], meta };
             }
@@ -660,7 +661,7 @@ export class CombatExchange {
                 }
             }
             if (drone.isWrecked) {
-                lines.push(`  ${drone.name} comes apart mid-air -- rotors, casing, sparks --`);
+                lines.push(`  ${droneComesApartLine(drone)}`);
                 lines.push(...leaveDrone(this.scene, defender, { forced: true, reason: `The airframe dies around you.` }));
             }
             return { world: [...lines, ...dryWarning], meta };
@@ -830,7 +831,9 @@ export class CombatExchange {
                     : companionKind === 'agent'
                         ? `${fallen.name} DEREZZES -- its icon shears into static and rains out of the grid, gone with the deck that ran it.`
                         : companionKind === 'drone'
-                            ? `${fallen.name} comes apart -- rotors, plating, and sparks skidding across ${room.name}. The frame is wrecked.`
+                            ? (fallen instanceof NPC && fallen.boundDevice
+                                ? droneComesApartLine(fallen.boundDevice, room.name)
+                                : `${fallen.name} comes apart -- plating and sparks skidding across ${room.name}. The frame is wrecked.`)
                             : (opts?.fatal ?? true)
                                 ? `${fallen.name} goes down -- dead before they hit the floor. The body lies where it fell.`
                                 : `${fallen.name} collapses, out cold -- down for the count, but still breathing.`;

package/bundle/typescript/src/commands/game/sideQuest/utilities/drone-prose.js

@@ -0,0 +1,289 @@
+import { Size } from '../types/shared/item-enum.js';
+import { hint } from './hints.js';
+/**
+ * ONE VOICE FOR EVERY FRAME (rigger pass, 2026-09-06). Every drone verb
+ * used to speak rotorcraft: a 120 kg wheeled Steel Lynx "lifts off your
+ * hand and settles into a watchful hover", a 400 kg Kodiak "autopilots
+ * home to your hand for the ride" and "folds back into your kit". The
+ * catalog knows better -- every drone row carries `shape`, `size`,
+ * `weight` and a vehicle block -- so the words come from here, classed
+ * by how the frame actually moves, and every verb that says anything
+ * about a frame moving (deploy, recall, order home, travel fold and
+ * curb, jump in, jump out, the recon sweep, a wreck) says it through
+ * one of these. The same shape as comm-style.ts: icon, colour, and the
+ * wording, in one place.
+ *
+ * AMBER IS THE RIGGER'S COLOUR (player ruling 2026-09-06: "when jumped
+ * into the drone, I'd like the player icon to change to amber to match
+ * the color scheme"). The drone rows of the HUD and the order feed used
+ * plain yellow; this is the first named colour in the game tree, a hex
+ * blessed accepts in a tag ({#ffbf00-fg}, the same way logo-mark.ts
+ * paints the mark), so "amber" means one thing on the map, the HUD and
+ * the feed. ✈ is the drone icon the feed already spoke; it is a BMP
+ * dingbat, so unlike 👤 it actually takes a foreground colour.
+ */
+export const DRONE_COLOUR = '#ffbf00';
+export const DRONE_ICON = '✈';
+export function droneLocomotion(item) {
+    const shape = (item.row?.shape ?? item.shape ?? '').toLowerCase();
+    if (shape === 'insect' || shape === 'disc')
+        return 'flier-palm';
+    if (shape === 'rotary' || shape === 'vtol' || shape === 'vstol')
+        return 'flier';
+    if (shape === 'missile')
+        return 'missile';
+    if (shape === 'walker')
+        return 'walker';
+    if (shape === 'anthroform' || item.vehicle?.anthro)
+        return 'anthro';
+    if (shape === 'wheeled' || shape === 'tracked' || shape === 'hull')
+        return 'ground';
+    if (item.size === Size.Tiny)
+        return 'flier-palm';
+    if (item.size === Size.Small && item.weight <= 5)
+        return 'flier';
+    return 'ground';
+}
+/**
+ * Whether the frame rides in your hands (or pocket, or pack) when you
+ * travel. Everything Large or bigger answers no, whatever its shape;
+ * fliers, walkers and the palm-sized answer yes; an anthroform or a
+ * missile only when it is Tiny/Small; a ground frame never. The rest
+ * follow a cab under their own dog-brain (SR5 p.269: the Pilot program
+ * drives; Rigger 5.0 p.174: the autopilot obeys traffic law) and meet
+ * you at the curb -- which is what foldCompanionsForTravel always did,
+ * it just used to claim a Kodiak fit in your hand.
+ */
+export function droneHandHeld(item) {
+    if (item.size === Size.Large || item.size === Size.VeryLarge)
+        return false;
+    const loco = droneLocomotion(item);
+    if (loco === 'flier-palm' || loco === 'flier' || loco === 'walker')
+        return true;
+    if (loco === 'ground')
+        return false;
+    return item.size === Size.Tiny || item.size === Size.Small;
+}
+const big = (item) => item.size === Size.Large || item.size === Size.VeryLarge;
+const pick = (item, lines) => lines[droneLocomotion(item)];
+/** The third-person fragment after "<name> --" in the deploy broadcast. */
+export function droneLaunchAction(item, from) {
+    if (from === 'garage') {
+        return pick(item, {
+            'flier-palm': 'whirring up off the bench and out of the bay',
+            flier: 'lifting off the bench and out of the bay',
+            ground: 'rolling out of the garage under its own power',
+            walker: 'walking out of the bay on its own legs',
+            anthro: 'stepping out of the bay',
+            missile: 'kicking off its rack and circling the bay',
+        });
+    }
+    return pick(item, {
+        'flier-palm': 'micro-rotors whining up off their palm',
+        flier: 'rotors spinning up to a hover',
+        ground: 'rolling off under its own power',
+        walker: 'unfolding its legs',
+        anthro: 'standing up and squaring its shoulders',
+        missile: 'kicking off its rail',
+    });
+}
+/** The deploy line itself, second person; the caller adds the Pilot. */
+export function droneLaunchLine(item, from) {
+    const name = item.name;
+    if (from === 'garage') {
+        return pick(item, {
+            'flier-palm': `The ${name} whirs up off the bench and out of the bay to hang at eye level`,
+            flier: `The ${name} lifts off the bench and out of the bay into a watchful hover`,
+            ground: `The ${name} wakes in the bay and rolls out under its own power, idling beside you`,
+            walker: `The ${name} walks out of the bay on its own legs and settles at your feet`,
+            anthro: `The ${name} steps out of the bay, squares its shoulders, and waits`,
+            missile: `The ${name} kicks off its rack and holds a tight circle over the bay`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} whines up off your palm and hangs at eye level`,
+        flier: `The ${name} lifts off your hand and settles into a watchful hover`,
+        ground: big(item)
+            ? `The ${name} wakes where it sits and rolls forward under its own power, idling beside you`
+            : `You set the ${name} down; it wakes and idles at your feet, motors ticking`,
+        walker: `The ${name} unfolds its legs off your hand and picks its way to the floor`,
+        anthro: big(item) || item.size === Size.Medium
+            ? `The ${name} stands up, squares its shoulders, and waits`
+            : `The ${name} climbs down off your pack and stands`,
+        missile: `The ${name} kicks off its rail and holds a tight circle overhead`,
+    });
+}
+/** Recall / "order <drone> home": the frame comes back to you. */
+export function droneRecallLine(item) {
+    const name = item.name;
+    const back = pick(item, {
+        'flier-palm': `The ${name} loops back and settles onto your palm, rotors stilling.`,
+        flier: `The ${name} banks once and settles back onto your hand, rotors folding.`,
+        ground: `The ${name} rolls back to your side and powers down.`,
+        walker: `The ${name} picks its way back and folds its legs into your hand.`,
+        anthro: `The ${name} walks back and powers down at your side.`,
+        missile: `The ${name} comes around and settles onto its rail, turbine spooling down.`,
+    });
+    const dents = item.droneDamage > 0
+        ? ` The frame carries its dents (${item.droneSummary()})${hint(' -- rest repairs it')}.`
+        : '';
+    return `${back}${dents}`;
+}
+/** Pre-travel: how the frame gets to the cab, or does not need one. */
+export function droneFoldForTravelLine(item) {
+    const name = item.name;
+    if (droneHandHeld(item)) {
+        return pick(item, {
+            'flier-palm': `The ${name} tucks into your pocket for the ride.`,
+            flier: `The ${name} autopilots home to your hand for the ride.`,
+            ground: `The ${name} rides in the pack.`,
+            walker: `The ${name} folds its legs and rides in the pack.`,
+            anthro: `The ${name} climbs into the pack for the ride.`,
+            missile: `The ${name} rides racked for the trip.`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} flies alongside the cab -- it will meet you at the curb.`,
+        flier: `The ${name} flies alongside the cab on its own dog-brain -- it will meet you at the curb.`,
+        ground: `The ${name} falls in behind the cab on its own dog-brain -- it will meet you at the curb.`,
+        walker: `The ${name} takes its own way there on its own legs -- it will meet you at the curb.`,
+        anthro: `The ${name} takes its own way there on its own two legs -- it will meet you at the curb.`,
+        missile: `The ${name} shadows the cab from altitude -- it will meet you at the curb.`,
+    });
+}
+/** Post-arrival: the frame re-shells at the curb. */
+export function droneUnfoldAtCurbLine(item) {
+    const name = item.name;
+    if (droneHandHeld(item)) {
+        return pick(item, {
+            'flier-palm': `The ${name} whirs up off your palm at the curb.`,
+            flier: `The ${name}'s rotors spin back up at the curb.`,
+            ground: `The ${name} drops off its sling and idles at the curb.`,
+            walker: `The ${name} unfolds its legs at the curb.`,
+            anthro: `The ${name} hops down at the curb and stands.`,
+            missile: `The ${name} kicks off its rail at the curb.`,
+        });
+    }
+    return pick(item, {
+        'flier-palm': `The ${name} is already hanging at the curb when you step out.`,
+        flier: `The ${name} is already hovering at the curb when you step out.`,
+        ground: `The ${name} pulls up at the curb behind the cab, motors ticking.`,
+        walker: `The ${name} is already waiting at the curb, legs folded under it.`,
+        anthro: `The ${name} is already waiting at the curb.`,
+        missile: `The ${name} drops out of its circle and picks up station over the curb.`,
+    });
+}
+/** The "jumps into" broadcast fragment after the verb. */
+export function droneJumpInAction(item, mode) {
+    const wake = pick(item, {
+        'flier-palm': 'the micro-rotors whine up',
+        flier: 'the rotors spin up',
+        ground: 'the drive motors wake',
+        walker: 'the legs take the weight',
+        anthro: 'the frame\'s limbs answer theirs',
+        missile: 'the turbine spools',
+    });
+    return `${item.name} -- body going slack as ${wake} (${mode}-sim)`;
+}
+/** The sensor-sight slot in the jump-in line ("...you ARE the X now, <this>, your body slumped..."). */
+export function droneJumpInFragment(item) {
+    return pick(item, {
+        'flier-palm': 'micro-rotors whining',
+        flier: 'rotors humming',
+        ground: 'drive motors humming under you',
+        walker: 'legs ticking under you',
+        anthro: 'servos whining in your limbs',
+        missile: 'turbine screaming',
+    });
+}
+/**
+ * Jump-out: the frame STAYS where it is on its dog-brain (SR5 p.266,
+ * p.268-269: the drone reverts to its Pilot program when the rigger
+ * leaves; nothing flies it home). Same room or another, the line says
+ * where it was left.
+ */
+export function droneJumpOutLine(item, frameRoom, bodyRoom) {
+    const holds = pick(item, {
+        'flier-palm': 'holds its hover',
+        flier: 'holds its hover',
+        ground: 'sits where it stopped, motors idling',
+        walker: 'stands where it is',
+        anthro: 'stands where it is, holding the pose',
+        missile: 'holds its circle overhead',
+    });
+    const where = frameRoom === bodyRoom ? 'where you left it' : `in ${frameRoom.name}`;
+    return `You're back in your body in ${bodyRoom.name}; the ${item.name} ${holds} ${where} -- dog-brain on the stick.${hint(' ("recall" brings it home.)')}`;
+}
+/** The recon sweep ("drone"): nowhere to go, launch, and return. */
+export function droneReconNowhereLine(item) {
+    return pick(item, {
+        'flier-palm': `The ${item.name} lifts, circles once -- nowhere to go from here.`,
+        flier: `The ${item.name} lifts, circles once -- nowhere to go from here.`,
+        ground: `The ${item.name} rolls a slow loop -- nowhere to go from here.`,
+        walker: `The ${item.name} picks a circle around your feet -- nowhere to go from here.`,
+        anthro: `The ${item.name} looks around -- nowhere to go from here.`,
+        missile: `The ${item.name} climbs, circles once -- nowhere to go from here.`,
+    });
+}
+export function droneReconLaunchLine(item, rollText, ok) {
+    const off = pick(item, {
+        'flier-palm': `The ${item.name} whirs off your palm`,
+        flier: `The ${item.name} lifts off your hand`,
+        ground: `The ${item.name} rolls off`,
+        walker: `The ${item.name} scuttles off`,
+        anthro: `The ${item.name} walks off`,
+        missile: `The ${item.name} kicks off its rail`,
+    });
+    if (!ok)
+        return `${off} -- Piloting: ${rollText}`;
+    const threads = pick(item, {
+        'flier-palm': 'threads the gaps',
+        flier: 'threads the gaps',
+        ground: 'noses through the doorways',
+        walker: 'picks through the gaps',
+        anthro: 'goes to look',
+        missile: 'makes a fast pass',
+    });
+    return `${off} and ${threads} -- Piloting: ${rollText}. Feed incoming:`;
+}
+export function droneReconReturnLine(item) {
+    return pick(item, {
+        'flier-palm': `The ${item.name} loops home and folds back into your kit.`,
+        flier: `The ${item.name} banks home and folds onto your hand.`,
+        ground: `The ${item.name} rolls back and powers down at your feet.`,
+        walker: `The ${item.name} picks its way back into your hand.`,
+        anthro: `The ${item.name} walks back and powers down.`,
+        missile: `The ${item.name} comes around and settles onto its rail.`,
+    });
+}
+/** Can this frame get past a locked door on the recon sweep? Only the
+ *  palm-sized fliers slip a vent; everything else is stopped by a door
+ *  like anyone. */
+export function droneSlipsVents(item) {
+    return droneLocomotion(item) === 'flier-palm';
+}
+/** What a wreck of this frame looks like: "bent rotors, dead boards". */
+export function droneWreckFragment(item) {
+    return pick(item, {
+        'flier-palm': 'crushed rotors, dead boards',
+        flier: 'bent rotors, dead boards',
+        ground: 'buckled frame, dead boards',
+        walker: 'snapped legs, dead boards',
+        anthro: 'dead servos, dead boards',
+        missile: 'torn fins, dead boards',
+    });
+}
+/** The moment of wrecking, in a fight. */
+export function droneComesApartLine(item, roomName) {
+    const bits = pick(item, {
+        'flier-palm': 'rotors, casing, sparks',
+        flier: 'rotors, casing, sparks',
+        ground: 'plating, wheels, sparks',
+        walker: 'legs, casing, sparks',
+        anthro: 'limbs, plating, sparks',
+        missile: 'fins, casing, fire',
+    });
+    const where = roomName ? ` skidding across ${roomName}` : '';
+    return `${item.name} comes apart -- ${bits}${where}. The frame is wrecked.`;
+}
+//# sourceMappingURL=drone-prose.js.map

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

@@ -7,6 +7,7 @@ import { fuzzyPickName } from './fuzzy-match.js';
 import { resetOverwatch } from './overwatch.js';
 import { rebootWipe } from './marks.js';
 import { hint } from './hints.js';
+import { droneJumpInAction, droneJumpInFragment, droneJumpOutLine, droneWreckFragment } from './drone-prose.js';
 /**
  * Plane transitions and their tolls -- the one place that moves an actor
  * between meat, Matrix, and astral (see Player.plane for the model).
@@ -288,7 +289,7 @@ export function enterDrone(scene, actor, drone, mode) {
     actor.simMode = mode;
     actor.riggedDrone = drone;
     actor.sneaking = false;
-    actor.performAction('jumps into', `${drone.name} -- body going slack as the rotors spin up (${mode}-sim)`);
+    actor.performAction('jumps into', droneJumpInAction(drone, mode));
     scene.addWorldEvent(`${actor.name} jumped into ${drone.name} in ${actor.bodyRoom.name}.`);
     Logger.getInstance().write(`${actor.name} jumped into ${drone.name} (${mode}-sim, hull ${drone.droneSummary()}) from ${actor.bodyRoom.name}.`);
     const hullNote = drone.droneDamage > 0 ? ` The airframe is already scarred: ${drone.droneSummary()}.` : '';
@@ -296,8 +297,8 @@ export function enterDrone(scene, actor, drone, mode) {
         ? ` Hot-sim: the machine answers like your own skin -- and every hit it takes bleeds PHYSICAL into yours.`
         : ` Cold-sim: hits on the hull sting through the link as stun, half strength.`;
     return [
-        `The rig takes hold and the world snaps to sensor-sight -- you ARE the ${drone.name} now, rotors humming, your body slumped and empty in ${actor.bodyRoom.name}.${hotWarning}${hullNote}`,
-        hint(`Move with "go" (you fly the meat world; locked doors still stop an airframe), "look" through the sensors, "jump" again to drop back into your body.`),
+        `The rig takes hold and the world snaps to sensor-sight -- you ARE the ${drone.name} now, ${droneJumpInFragment(drone)}, your body slumped and empty in ${actor.bodyRoom.name}.${hotWarning}${hullNote}`,
+        hint(`Move with "go" (you fly the meat world; locked doors still stop an airframe), "look" through the sensors, "jump" again to drop back into your body -- the frame stays out on its dog-brain where you leave it; "recall" brings it home.`),
     ].filter(l => l.length > 0);
 }
 /**
@@ -308,11 +309,27 @@ export function enterDrone(scene, actor, drone, mode) {
  * Willpower-only resist -- the same softening the Matrix side had, minus
  * the Firewall term, plus the only correct half either copy had (the
  * p.229 disorientation, which the Matrix side was missing entirely).
+ *
+ * THE FRAME STAYS WHERE IT IS (user ruling 2026-09-06, and canon: SR5
+ * p.266 / p.268-269 -- when the rigger leaves, the drone reverts to its
+ * Pilot program at the next Combat Turn; nothing flies it home). This
+ * used to say the frame "autopilots home to your hand", which was both
+ * a deviation and a lie to a rigger who deployed a frame, seized it two
+ * rooms away and let go: the frame vanished. Now it re-shells on its
+ * dog-brain in the frame's room, at the frame's cell, whether you
+ * deployed it first or jumped straight from your hand, and "recall"
+ * brings it home. A WRECKED frame (the forced dump) never re-shells.
+ * Ordered AFTER the body is put back so seatingIn sees the rigger on
+ * bodyCell before the shell claims frameCell.
  */
 export function leaveDrone(scene, actor, opts) {
     const lines = [];
     const body = actor.bodyRoom;
     const drone = actor.riggedDrone;
+    // Where the FRAME is, captured before the body restore overwrites it.
+    const frameRoom = actor.currentLocation;
+    const frameSpot = actor.atSpot;
+    const frameCell = actor.atCell;
     if (opts?.forced) {
         lines.push(...applyDumpshock(actor, opts.reason ?? `The link dies with the airframe.`));
     }
@@ -320,7 +337,7 @@ export function leaveDrone(scene, actor, opts) {
         lines.push(`You let go of the machine and drop back down the link.`);
     }
     if (drone?.isWrecked) {
-        lines.push(`The ${drone.name} is WRECKED -- bent rotors, dead boards. It repairs while you rest somewhere safe.`);
+        lines.push(`The ${drone.name} is WRECKED -- ${droneWreckFragment(drone)}. It repairs while you rest somewhere safe.`);
     }
     actor.plane = 'meat';
     actor.simMode = undefined;
@@ -336,8 +353,18 @@ export function leaveDrone(scene, actor, opts) {
         actor.atCell = actor.bodyCell;
         actor.bodySpot = undefined;
         actor.bodyCell = undefined;
-        lines.push(drone && !drone.isWrecked
-            ? `You're back in your body in ${body.name}; the ${drone.name} autopilots home to your hand.`
+        // The dog-brain takes the stick where the frame is (see above).
+        const game = scene.ownerGame;
+        const shell = drone && !drone.isWrecked && game && frameRoom
+            ? game.deployDroneShell(drone, frameRoom)
+            : null;
+        if (shell) {
+            shell.atSpot = frameSpot;
+            shell.atCell = frameCell;
+            Logger.getInstance().write(`${drone.name} re-shelled on its dog-brain in ${frameRoom.name} after ${actor.name} jumped out.`);
+        }
+        lines.push(shell && drone
+            ? droneJumpOutLine(drone, frameRoom, body)
             : `You're back in your body in ${body.name}.`);
     }
     actor.performAction('jumps out', 'stirring awake as the rig releases');