@maka/maka-cli 5.118.0 → 5.119.0

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

@@ -1,3 +1,4 @@
+import { getQuality, resolveQualityKey } from '../qualities.js';
 import { isAspectKey } from '../aspects.js';
 import { hint } from '../utilities/hints.js';
 import { Category } from '../types/shared/item-enum.js';
@@ -11,7 +12,13 @@ import { physicalLimit } from '../utilities/grapple.js';
 import { astralLimit } from '../utilities/limits.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
-export const STANCE_CYCLE = ['manual', 'guarded', 'aggressive'];
+export const STANCE_CYCLE = ['manual', 'non-lethal', 'lethal'];
+/** The old names, still accepted from saves and the stance command. */
+export const STANCE_ALIASES = { guarded: 'non-lethal', aggressive: 'lethal', nonlethal: 'non-lethal', 'non lethal': 'non-lethal' };
+export function normalizeStance(v) {
+    const k = (v ?? 'manual').toLowerCase();
+    return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'manual');
+}
 /** Meat and a jumped-in drone share the physical world. */
 export function isPhysicalPlane(plane) {
     return plane === 'meat' || plane === 'drone';
@@ -576,7 +583,29 @@ export class Player extends AbstractPlayer {
             return true;
         if (this.hasAug('datajack'))
             return true;
-        return this._inventory.getAllItems().some(i => i.category === Category.Electronics && /\btrodes?\b/i.test(i.name));
+        return this.dniSource() !== null;
+    }
+    /** True for the one Electronics item that is a trode net (p.439-440). */
+    static isTrodeNet(item) {
+        return item.category === Category.Electronics && /\btrodes?\b/i.test(item.name);
+    }
+    /**
+     * WHAT CARRIES THE DIRECT NEURAL INTERFACE, for the equipment panel and
+     * the jack-in gate: a living persona, an implanted datajack, a trode net
+     * worn on the head, or one still in the bag (it works from there too --
+     * the engine has never made the player put it on, and a net in the bag
+     * was the only place it could live before the head slot existed).
+     */
+    dniSource() {
+        if (this.isTechnomancer())
+            return { kind: 'technomancer' };
+        if (this.hasAug('datajack'))
+            return { kind: 'datajack' };
+        const worn = this._equipment.head?.trodes;
+        if (worn)
+            return { kind: 'trodes', worn: true, item: worn };
+        const bagged = this._inventory.getAllItems().find(i => Player.isTrodeNet(i));
+        return bagged ? { kind: 'trodes', worn: false, item: bagged } : null;
     }
     /**
      * THE PRICE OF SILENCE (canon p.235-236 "Running Silent",
@@ -1189,7 +1218,23 @@ export class Player extends AbstractPlayer {
      * the only quality that edits an attribute (RAW raises the Edge ceiling;
      * with no attribute point-buy here, the point lands directly).
      */
-    addQuality(key) {
+    /** Rating per rated quality (qualities.ts maxRating); absent = 1. */
+    qualityRatings = new Map();
+    /** The rating held, 0 when the quality is not held; a flat quality reads 1. */
+    qualityRating(key) {
+        if (!this.qualities.has(key))
+            return 0;
+        return this.qualityRatings.get(key) ?? 1;
+    }
+    addQuality(rawKey, rating) {
+        // A legacy "<key>-1" resolves to the rated key at 1 (qualities.ts).
+        const resolved = resolveQualityKey(rawKey);
+        const key = resolved.key;
+        const q = getQuality(key);
+        if (q?.maxRating) {
+            const r = Math.max(1, Math.min(q.maxRating, Math.floor(rating ?? resolved.rating)));
+            this.qualityRatings.set(key, r);
+        }
         if (this.qualities.has(key))
             return;
         this.qualities.add(key);
@@ -1415,7 +1460,8 @@ export class Player extends AbstractPlayer {
                 ears: null,
                 mouth: null,
                 nose: null,
-                commlink: null
+                commlink: null,
+                trodes: null
             },
             torso: {
                 clothing: null,
@@ -1423,31 +1469,26 @@ export class Player extends AbstractPlayer {
                 armorCoat: null,
                 backpack: null,
                 tacticalRig: null,
-                leftShoulder: null,
-                rightShoulder: null,
+                shoulder: null,
                 bandolier: null
             },
             legs: {
                 pants: null,
                 thighRig: null,
-                leftHip: null,
-                rightHip: null
+                hip: null
             },
             feet: {
                 boots: null,
-                leftAnkle: null,
-                rightAnkle: null
+                ankle: null
             },
             arms: {
-                leftBicept: null,
-                rightBicept: null,
-                leftForearm: null,
-                rightForearm: null,
+                bicep: null,
+                forearm: null,
                 cyberware: null
             },
             gloves: {
-                leftWrist: null,
-                rightWrist: null
+                gloves: null,
+                wrist: null
             },
             leftHand: {
                 weapon: null,
@@ -1642,8 +1683,143 @@ export class Player extends AbstractPlayer {
             this.logger.write("Failed to add item to inventory due to weight limits.");
             throw new Error("The item is too heavy to add to your inventory.");
         }
+        // A PROGRAM CHIP IS CONSUMED BY THE DECK (p.227, p.243): programs are
+        // files in deck storage, not gear in the pack. With a deck on you the
+        // chip installs and is gone; with none it waits in the bag for one.
+        // A PAPER GOES ON THE COMMLINK (p.443): with a device on you it lands
+        // there and never touches the pack; a license links to the SIN you
+        // present. With no device it waits in the bag like a chip does.
+        if (item.isPaper()) {
+            const device = this.paperDevice();
+            if (device) {
+                this.filePaper(device, item);
+                this.logger.write(`${item.name} filed on ${device.name}${item.linkedSin ? ` (linked to ${item.linkedSin})` : ''}.`);
+                this.noteConditionChanged();
+                return;
+            }
+        }
+        const key = item.programKey ?? item.softKey;
+        const deck = key ? (item.softKey ? this.softDevice() : this.getAnyCyberdeck()) : undefined;
+        if (key && deck) {
+            const fresh = deck.installProgram(key);
+            this.logger.write(`${item.name} ${fresh ? 'installed into' : 'already on'} ${deck.name} -- chip consumed.`);
+            this.noteConditionChanged();
+            return;
+        }
         this._inventory.addItem(item);
         this.logger.write(`Added ${item.name} to ${this.name}'s inventory.`);
+        // A new deck takes every chip that was waiting for it.
+        if (item.isCyberdeck() || item.category === Category.Commlink) {
+            this.sweepProgramChipsIntoDeck();
+            this.sweepPapersOntoDevice();
+        }
+    }
+    /** Where papers live (p.443): the commlink, else the deck -- the PAN's master. */
+    paperDevice() {
+        return this.commlinks()[0] ?? this.getAnyCyberdeck();
+    }
+    /** Every device that can hold papers, commlinks first. */
+    paperDevices() {
+        const deck = this.getAnyCyberdeck();
+        return [...this.commlinks(), ...(deck ? [deck] : [])];
+    }
+    /** Every paper on every device. */
+    papers() {
+        return this.paperDevices().flatMap(d => d.papers);
+    }
+    /** Files a paper on a device; a license links to the presented fake SIN (utilities/sin.ts resolves "presented"). */
+    filePaper(device, paper) {
+        if (paper.category === Category.License && !paper.linkedSin) {
+            const sins = this.papers().filter(p => p.category === Category.FakeSIN);
+            const chosen = sins.find(p => p.name === this.activeSin) ?? sins[0];
+            if (chosen)
+                paper.linkedSin = chosen.name;
+        }
+        device.papers.push(paper);
+        // A SIN arriving after an unlinked license takes it.
+        if (paper.category === Category.FakeSIN) {
+            for (const lic of this.papers())
+                if (lic.category === Category.License && !lic.linkedSin)
+                    lic.linkedSin = paper.name;
+        }
+    }
+    /** Burns a fake SIN: gone from its device, and every license linked to it goes with it (p.443). Returns the licenses lost. */
+    burnPaper(sin) {
+        const lost = [];
+        for (const device of this.paperDevices()) {
+            device.papers = device.papers.filter(p => {
+                if (p === sin)
+                    return false;
+                if (p.category === Category.License && p.linkedSin === sin.name) {
+                    lost.push(p);
+                    return false;
+                }
+                return true;
+            });
+        }
+        if (this.activeSin === sin.name)
+            this.activeSin = undefined;
+        this.noteConditionChanged();
+        return lost;
+    }
+    /** Every paper in the pack files onto the carried device; returns how many moved. */
+    sweepPapersOntoDevice() {
+        const device = this.paperDevice();
+        if (!device)
+            return 0;
+        let n = 0;
+        // SINs first, so a loose license has one to link to.
+        const loose = [...this._inventory.getAllItems()].filter(i => i.isPaper())
+            .sort((a, b) => (a.category === Category.License ? 1 : 0) - (b.category === Category.License ? 1 : 0));
+        for (const paper of loose) {
+            this._inventory.removeItem(paper.name);
+            this.filePaper(device, paper);
+            n++;
+        }
+        if (n > 0)
+            this.noteConditionChanged();
+        return n;
+    }
+    /** The commlinks on this runner: worn on the head, or in the pack. */
+    commlinks() {
+        const worn = this._equipment.head?.commlink;
+        return [...(worn ? [worn] : []), ...this._inventory.getAllItems().filter(i => i.category === Category.Commlink)];
+    }
+    /** Where a data soft lives (p.441-442): the deck if there is one, else a commlink. */
+    softDevice() {
+        return this.getAnyCyberdeck() ?? this.commlinks()[0];
+    }
+    /** A soft in the storage of any device on you -- a chip in the bag is not installed. */
+    hasSoft(key) {
+        const deck = this.getAnyCyberdeck();
+        return [...(deck ? [deck] : []), ...this.commlinks()].some(d => d.hasStored(key));
+    }
+    /**
+     * THE SOCIAL LIMIT (SR5 p.100-101): [(Charisma x 2) + Willpower + Essence]
+     * / 3, rounded up, with Essence rounded up first (p.95, p.100 -- the
+     * rounding rule is cited; the table row itself the RAG did not return,
+     * see rag-table-rows-missing). A Shopsoft adds one when buying or
+     * selling what it covers (p.442) -- see commands/haggle.ts.
+     */
+    get socialLimit() {
+        return Math.ceil((this.charisma * 2 + this.willpower + Math.ceil(this.essence - 1e-9)) / 3);
+    }
+    /** Every program chip in the pack installs into the carried deck; returns how many chips were consumed. */
+    sweepProgramChipsIntoDeck() {
+        const deck = this.getAnyCyberdeck();
+        const softHome = this.softDevice();
+        let n = 0;
+        for (const chip of [...this._inventory.getAllItems()]) {
+            const device = chip.programKey ? deck : chip.softKey ? softHome : undefined;
+            if (!device)
+                continue;
+            device.installProgram((chip.programKey ?? chip.softKey));
+            this._inventory.removeItem(chip.name);
+            n++;
+        }
+        if (n > 0)
+            this.noteConditionChanged();
+        return n;
     }
     removeInventory(item) {
         if (this._inventory.removeItem(item.name)) {
@@ -1660,7 +1836,7 @@ export class Player extends AbstractPlayer {
         if (!this.canEquip(item)) {
             return `You can't equip ${item.name}.`;
         }
-        const slotInfo = this.determineEquipmentSlot(item.category);
+        const slotInfo = this.slotForItem(item);
         if (!slotInfo) {
             return `${item.name} doesn't fit any known equipment slot.`;
         }
@@ -1673,7 +1849,7 @@ export class Player extends AbstractPlayer {
         let swapNotice = '';
         if (previousItem) {
             if (previousItem.name === item.name) {
-                return `You already have ${item.name} equipped in your ${group}.${slot} slot.`;
+                return `You already have ${item.name} on -- ${Player.slotWord(group, slot)}.`;
             }
             this.unequipBySlot(group, slot);
             swapNotice = ` (unequipped ${previousItem.name})`;
@@ -1687,7 +1863,21 @@ export class Player extends AbstractPlayer {
             this.weaponDrawn = false;
             return `You slide ${item.name} into your holster.${swapNotice}${hint(` "brandish" when you want it in hand.`)}`;
         }
-        return `You equipped ${item.name} in your ${group}.${slot} slot.${swapNotice}`;
+        return `You put on ${item.name} -- ${Player.slotWord(group, slot)}.${swapNotice}`;
+    }
+    /** The word a player would use for a slot -- never the key ("body armor", not "torso.armorVest"). */
+    static SLOT_WORDS = {
+        head: { eyes: 'eyes', skull: 'head', ears: 'ears', mouth: 'face', nose: 'nose', commlink: 'commlink', trodes: 'trode net' },
+        torso: { clothing: 'clothes', armorVest: 'body armor', armorCoat: 'coat', backpack: 'backpack', tacticalRig: 'rig', shoulder: 'shoulder', bandolier: 'bandolier' },
+        legs: { pants: 'legs', thighRig: 'thigh rig', hip: 'hip' },
+        feet: { boots: 'feet', ankle: 'ankle' },
+        arms: { forearm: 'forearm', bicep: 'upper arm', cyberware: 'arm implant' },
+        gloves: { gloves: 'hands', wrist: 'wrist' },
+        leftHand: { weapon: 'off hand', shield: 'shield arm', ring: 'ring', device: 'off hand' },
+        rightHand: { weapon: 'weapon hand', ring: 'ring', device: 'hand' },
+    };
+    static slotWord(group, slot) {
+        return Player.SLOT_WORDS[group]?.[slot] ?? `${group}.${slot}`;
     }
     /** True for the hand slots that hold a wielded weapon. */
     static isWeaponSlot(group, slot) {
@@ -1711,6 +1901,23 @@ export class Player extends AbstractPlayer {
         }
         return `No equipped item matches "${input}".`;
     }
+    /**
+     * The slot an ITEM wears in: the category decides (determineEquipmentSlot)
+     * except where the name has to -- a trode net is Electronics like a
+     * flashlight, and the flashlight has no slot. Kit devices (a deck, a
+     * drone, uninstalled 'ware) answer null: they are carried, not worn.
+     */
+    slotForItem(item) {
+        if (Player.isTrodeNet(item))
+            return { group: 'head', slot: 'trodes' };
+        if (item.category === Category.Cyberdeck || item.category === Category.Drone || item.category === Category.Cyberware)
+            return null;
+        return this.determineEquipmentSlot(item.category);
+    }
+    /** Everything in the bag that has a slot and is not in it -- armor left in the pack (a real save: Armor Clothing carried, nothing worn). */
+    wearablesInBag() {
+        return this._inventory.getAllItems().filter(i => this.slotForItem(i) !== null);
+    }
     determineEquipmentSlot(input) {
         const normalized = input.toLowerCase();
         switch (normalized) {
@@ -1752,10 +1959,10 @@ export class Player extends AbstractPlayer {
                 return { group: 'torso', slot: 'tacticalRig' };
             case 'backpack':
                 return { group: 'torso', slot: 'backpack' };
+            case 'shoulder holster':
             case 'left shoulder holster':
-                return { group: 'torso', slot: 'leftShoulder' };
             case 'right shoulder holster':
-                return { group: 'torso', slot: 'rightShoulder' };
+                return { group: 'torso', slot: 'shoulder' };
             case 'bandolier':
                 return { group: 'torso', slot: 'bandolier' };
             // LEGS
@@ -1766,39 +1973,38 @@ export class Player extends AbstractPlayer {
             case 'thigh rig':
             case 'thigh holster':
                 return { group: 'legs', slot: 'thighRig' };
+            case 'hip pouch':
             case 'left hip pouch':
-                return { group: 'legs', slot: 'leftHip' };
             case 'right hip pouch':
-                return { group: 'legs', slot: 'rightHip' };
+                return { group: 'legs', slot: 'hip' };
             // FEET
             case Category.Boots:
             case 'combat boots':
             case 'shoes':
                 return { group: 'feet', slot: 'boots' };
+            case 'anklet':
             case 'left anklet':
-                return { group: 'feet', slot: 'leftAnkle' };
             case 'right anklet':
-                return { group: 'feet', slot: 'rightAnkle' };
+                return { group: 'feet', slot: 'ankle' };
             // ARMS
             case Category.ArmArmor:
             case 'arm sleeve':
+            case 'bracer':
             case 'left forearm implant':
-                return { group: 'arms', slot: 'leftForearm' };
             case 'right forearm implant':
-                return { group: 'arms', slot: 'rightForearm' };
+                return { group: 'arms', slot: 'forearm' };
+            case 'armband':
             case 'left armband':
-                return { group: 'arms', slot: 'leftBicept' };
             case 'right armband':
-                return { group: 'arms', slot: 'rightBicept' };
+                return { group: 'arms', slot: 'bicep' };
             case Category.Cyberware:
                 return { group: 'arms', slot: 'cyberware' };
             // GLOVES / WRIST
             case Category.Gloves:
             case 'glove':
             case 'left glove':
-                return { group: 'gloves', slot: 'leftWrist' };
             case 'right glove':
-                return { group: 'gloves', slot: 'rightWrist' };
+                return { group: 'gloves', slot: 'gloves' };
             // WRIST-WORN gear -- a DocWagon band, a smartwatch, a med
             // bracelet (player note 2026-08-25: "docwagon wristband should
             // be wearable"). No new equipment GROUP was needed: the wrist
@@ -1811,9 +2017,9 @@ export class Player extends AbstractPlayer {
             case 'wristband':
             case 'bracelet':
             case 'watch':
-                return { group: 'gloves', slot: 'leftWrist' };
+            case 'left wrist':
             case 'right wrist':
-                return { group: 'gloves', slot: 'rightWrist' };
+                return { group: 'gloves', slot: 'wrist' };
             // LEFT HAND
             case Category.Shield:
                 return { group: 'leftHand', slot: 'shield' };
@@ -1846,14 +2052,14 @@ export class Player extends AbstractPlayer {
         }
         const itemToUnequip = groupRef[slot];
         if (!itemToUnequip) {
-            return `Nothing is equipped in the ${group}.${slot} slot.`;
+            return `Nothing on your ${Player.slotWord(group, slot)}.`;
         }
         this.addInventory(itemToUnequip);
         groupRef[slot] = null;
         // No weapon, nothing drawn -- keeps the flag honest for the next equip.
         if (Player.isWeaponSlot(group, slot))
             this.weaponDrawn = false;
-        return `You unequipped ${itemToUnequip.name} from your ${group}.${slot} slot.`;
+        return `You take off ${itemToUnequip.name} (${Player.slotWord(group, slot)}) and bag it.`;
     }
     hear(actor, message, opts) {
         // Cross-plane silence: a Matrix persona's chatter never reaches meat
@@ -2151,25 +2357,51 @@ export class Player extends AbstractPlayer {
         // point, and trim (boots, gloves, arm/leg pieces) is flavor, not
         // dice -- stacking four rated accessories used to out-armor the
         // jacket they hung off.
-        let total = 0;
+        return this.armorBreakdown().total;
+    }
+    /**
+     * ARMOR DOES NOT STACK (SR5 p.169, RAG-checked 2026-09-02): "only the
+     * highest Armor rating applies; all other pieces only add bulk". A helmet
+     * or shield is a "+" accessory and adds to that one piece (p.438). The
+     * old sum let a vest under a coat out-armor either -- the same deviation
+     * the trim rule below already closed for boots and gloves. `ignored` is
+     * what the player is wearing for nothing, so the panel can say so.
+     */
+    armorBreakdown() {
+        let piece = null;
+        let best = 0;
+        const extras = [];
+        const ignored = [];
         for (const group of Object.values(this._equipment)) {
             if (!group)
                 continue;
             for (const item of Object.values(group)) {
                 if (!item || !Player.ARMOR_CATEGORIES.has(item.category))
                     continue;
-                if (item.category === Category.Helmet)
-                    total += 1;
-                else if (item.category === Category.Shield)
-                    total += 2;
-                else if (item.category === Category.Boots || item.category === Category.Gloves
+                if (item.category === Category.Helmet) {
+                    extras.push({ item, bonus: 1 });
+                    continue;
+                }
+                if (item.category === Category.Shield) {
+                    extras.push({ item, bonus: 2 });
+                    continue;
+                }
+                if (item.category === Category.Boots || item.category === Category.Gloves
                     || item.category === Category.ArmArmor || item.category === Category.LegArmor)
-                    total += 0;
-                else
-                    total += 1 + item.qualityBonus + (item.isHeavyArmor ? 1 : 0);
+                    continue;
+                const value = 1 + item.qualityBonus + (item.isHeavyArmor ? 1 : 0);
+                if (value > best) {
+                    if (piece)
+                        ignored.push(piece);
+                    piece = item;
+                    best = value;
+                }
+                else {
+                    ignored.push(item);
+                }
             }
         }
-        return total;
+        return { total: best + extras.reduce((n, e) => n + e.bonus, 0), piece, extras, ignored };
     }
     getAttackPool() {
         // Plane decides which attribute drives the fight: meat is muscle
@@ -2863,6 +3095,15 @@ export class Player extends AbstractPlayer {
     get formDefenseBonus() {
         return this.sustainedForms.some(f => f.key === 'static-veil') ? 2 : 0;
     }
+    /** The Force each sustained spell was cast at (cast.ts records it) -- Focused Concentration reads it. */
+    sustainedForces = new Map();
+    noteSustainedForce(kind, force) {
+        this.sustainedForces.set(kind, force);
+    }
+    /** GREMLINS (p.81): the 1s a glitch needs, one fewer per rating, on external equipment -- the deck. */
+    get deckGremlins() {
+        return this.isTechnomancer() ? 0 : this.qualityRating('gremlins');
+    }
     get sustainingPenalty() {
         // Each sustained effect costs -2 dice across the board: the armor
         // spell, invisibility, hot reflexes, and open astral senses (see
@@ -2871,11 +3112,22 @@ export class Player extends AbstractPlayer {
         // QUICKENING (metamagic, p.326 adapted): the armor spell anchors into
         // the world and sustains itself -- its -2 simply never bills.
         const armorCost = this._sustainedArmor > 0 && !this.hasMetamagic('quickening') ? 2 : 0;
-        return armorCost
-            + (this.sustainedInvisibility ? 2 : 0)
-            + (this.sustainedReflexes ? 2 : 0)
-            + (this.sustainedBarrier ? 2 : 0)
-            + (this.sustainedManaBarrier ? 2 : 0)
+        // FOCUSED CONCENTRATION (p.74, RAG-checked 2026-09-02): "sustain one
+        // spell with a Force equal to or less than your rating without
+        // penalty". One spell, whose Force the cast recorded; a spell with
+        // no recorded Force is not eligible (honest, not generous).
+        const spells = [
+            { cost: armorCost, force: this.sustainedForces.get('armor') },
+            { cost: this.sustainedInvisibility ? 2 : 0, force: this.sustainedForces.get('invisibility') },
+            { cost: this.sustainedReflexes ? 2 : 0, force: this.sustainedForces.get('reflexes') },
+            { cost: this.sustainedBarrier ? 2 : 0, force: this.sustainedBarrier?.force },
+            { cost: this.sustainedManaBarrier ? 2 : 0, force: this.sustainedManaBarrier?.force },
+        ];
+        const focus = this.qualityRating('focused-concentration');
+        const waived = focus > 0 ? spells.find(sp => sp.cost > 0 && sp.force !== undefined && sp.force <= focus) : undefined;
+        if (waived)
+            waived.cost = 0;
+        return spells.reduce((n, sp) => n + sp.cost, 0)
             + (this.astralPerceiving ? 2 : 0)
             + (this.dumpshocked ? 2 : 0)
             + this.sustainedForms.length * 2;