@maka/maka-cli 5.120.0 → 5.122.0

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

@@ -1,3 +1,5 @@
+import { getSoft, getProgram } from '../utilities/programs.js';
+import { catalogRowFor } from '../utilities/catalog.js';
 import { getQuality, resolveQualityKey } from '../qualities.js';
 import { isAspectKey } from '../aspects.js';
 import { hint } from '../utilities/hints.js';
@@ -15,6 +17,23 @@ import { AbstractPlayer } from '../types/shared/abstracts.js';
 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 const MATRIX_STANCE_CYCLE = ['attack', 'sleaze'];
+/** What each stance is CALLED in the book -- printed everywhere the
+ *  engine used to say "loud"/"quiet", so the vocabulary teaches the
+ *  real action names (the whole point of uMQAhaAysgaKpWFkn). */
+export const MATRIX_STANCE_ACTION = {
+    attack: 'Brute Force',
+    sleaze: 'Hack on the Fly',
+};
+/** The words a player may type, including the engine's older ones. */
+export const MATRIX_STANCE_ALIASES = {
+    loud: 'attack', force: 'attack', brute: 'attack', 'brute force': 'attack', bf: 'attack',
+    quiet: 'sleaze', sneak: 'sleaze', 'hack on the fly': 'sleaze', hotf: 'sleaze', fly: 'sleaze',
+};
+export function normalizeMatrixStance(v) {
+    const k = (v ?? 'attack').toLowerCase();
+    return MATRIX_STANCE_ALIASES[k] ?? (MATRIX_STANCE_CYCLE.includes(k) ? k : 'attack');
+}
 export function normalizeStance(v) {
     const k = (v ?? 'manual').toLowerCase();
     return STANCE_ALIASES[k] ?? (STANCE_CYCLE.includes(k) ? k : 'manual');
@@ -49,6 +68,7 @@ export const SKILL_NAMES = [
     'alchemy', 'disenchanting', 'artificing',
     'aeronautics-mechanic', 'industrial-mechanic', 'automotive-mechanic', 'nautical-mechanic',
     'navigation', 'tracking', 'survival',
+    'heavy-weapons', 'throwing-weapons', 'exotic-melee', 'exotic-ranged',
 ];
 /**
  * Skills that fall back to the legacy `combatSkill` attribute when no
@@ -61,8 +81,8 @@ export const COMBAT_SKILL_FALLBACK = new Set([
     // `combatSkill`, and after the split the skill it rolls depends on the
     // gun it happens to be holding. Listing one would leave every guard
     // with a shotgun rolling zero.
-    'automatics', 'pistols', 'longarms', 'archery',
-    'blades', 'unarmed', 'hacking',
+    'automatics', 'pistols', 'longarms', 'archery', 'heavy-weapons', 'throwing-weapons',
+    'blades', 'clubs', 'unarmed', 'exotic-melee', 'exotic-ranged', 'hacking',
 ]);
 /**
  * WHICH GUN ROLLS WHICH SKILL (SR5 p.130, p.132).
@@ -101,8 +121,13 @@ export const COMBAT_SKILL_FALLBACK = new Set([
  * (p.433 firearm accessory), a drone's armed mount -- do not apply to a
  * crossbow.
  */
-export const FIREARM_SKILLS = ['automatics', 'pistols', 'longarms'];
+export const FIREARM_SKILLS = ['automatics', 'pistols', 'longarms', 'heavy-weapons'];
 export function firearmSkillFor(weapon) {
+    // THE ROW SAYS (catalog v13): an Item carries its weapon block's skill,
+    // and the regexes below are the fallback for a plain seed object or
+    // generated gear (Item.weaponSkill reads the same block first).
+    if (weapon.weaponSkill)
+        return weapon.weaponSkill;
     const hay = `${weapon.name} ${weapon.shape ?? ''}`.toLowerCase();
     if (/bow|crossbow|sling/.test(hay))
         return 'archery';
@@ -168,6 +193,16 @@ export class Player extends AbstractPlayer {
         this._autoStance = v;
         this.noteConditionChanged();
     }
+    /** Which of the book's two intrusion actions the next hack uses
+     *  (see MatrixStance). Sheet-visible, like its meat-world twin. */
+    _matrixStance = 'attack';
+    get matrixStance() { return this._matrixStance; }
+    set matrixStance(v) {
+        if (this._matrixStance === v)
+            return;
+        this._matrixStance = v;
+        this.noteConditionChanged();
+    }
     // SUBDUING (RAW p.195, the "restrain" ask from a real session's runaway
     // NPC): a grapple links two actors BY NAME -- grappledBy/grappling are
     // the two ends, grappleThreshold the escape test's bar (the original
@@ -587,6 +622,10 @@ export class Player extends AbstractPlayer {
     }
     /** True for the one Electronics item that is a trode net (p.439-440). */
     static isTrodeNet(item) {
+        if (item.hasCapability('dni'))
+            return true;
+        if (item.row)
+            return false;
         return item.category === Category.Electronics && /\btrodes?\b/i.test(item.name);
     }
     /**
@@ -783,8 +822,10 @@ export class Player extends AbstractPlayer {
     panDefence(against = 'sleaze') {
         const master = this.getPanMaster();
         const silent = this.runningSilent ? 2 : 0;
-        const scrub = master?.hasProgram('signal-scrub') ? 1 : 0;
-        const sneak = master?.hasProgram('sneak') && this.runningSilent ? 2 : 0;
+        // What the running programs add (catalog v13): Signal Scrub always,
+        // Sneak only while silent -- the rows carry both, and the `only`.
+        const scrub = this.gearBonus('pan-defense');
+        const sneak = this.runningSilent ? this.gearBonus('pan-defense', { only: 'silent' }) - scrub : 0;
         const attributeName = against === 'attack' ? 'Willpower' : 'Intuition';
         const attribute = against === 'attack' ? this.willpower : this.intuition;
         const firewall = this.isTechnomancer()
@@ -887,7 +928,7 @@ export class Player extends AbstractPlayer {
             // SMARTLINK, so the bonus belongs to the pairing. Item.accuracy
             // stays the bare table value -- a gun on a table has no idea who
             // will pick it up -- and the shooter supplies the other half here.
-            return acc + this.smartlinkAccuracyBonus(weapon);
+            return acc + Math.max(this.smartlinkAccuracyBonus(weapon), this.laserSightBonus(weapon));
         }
         return undefined;
     }
@@ -955,6 +996,13 @@ export class Player extends AbstractPlayer {
         // generated gear that carries the fiction but not the tag.
         const eyeCategory = (i) => i.category === Category.Glasses || i.category === Category.EyeCyberwere;
         const eyeWords = /goggles|glasses|contacts|cybereyes|monocle|visor/;
+        // THE ROW FIRST (catalog v13): a Smartlink fitted into the goggles
+        // grants the capability through Item.effects; the name pattern is
+        // the fallback for generated eyewear with no row.
+        if (onFace.hasCapability('smartlink'))
+            return 'gear';
+        if (onFace.row)
+            return undefined;
         const found = /smartlink/.test(hay(onFace))
             && (eyeCategory(onFace) || eyeWords.test(hay(onFace)));
         return found ? 'gear' : undefined;
@@ -976,10 +1024,25 @@ export class Player extends AbstractPlayer {
      * never a die, and a die is never a limit.
      */
     smartlinkAccuracyBonus(weapon) {
-        if (!weapon?.isFirearm?.())
+        // A SMARTGUN, not any gun (catalog v13; p.433): the system is an
+        // accessory -- built in (Predator V) or bolted on (smartgun-external).
+        // Before v13 every firearm counted; that was the engine's shortcut,
+        // not the book's rule.
+        if (!weapon?.isFirearm?.() || !weapon.isSmartgun)
             return 0;
         return this.smartlinkTier() ? 2 : 0;
     }
+    /**
+     * A LASER SIGHT's +1 Accuracy (p.432), built in or fitted -- and never
+     * cumulative with a smartlink: getAttackLimit takes the larger of the two.
+     */
+    laserSightBonus(weapon) {
+        if (!weapon?.isFirearm?.())
+            return 0;
+        if (weapon.hasBuiltIn('laser-sight'))
+            return 1;
+        return weapon.effects.reduce((n, e) => n + (e.type === 'limit' && e.property === 'accuracy' ? e.value : 0), 0);
+    }
     get matrixTaken() {
         return this.getAnyCyberdeck()?.deckDamage ?? 0;
     }
@@ -1156,6 +1219,53 @@ export class Player extends AbstractPlayer {
     hasAug(key) {
         return this.augmentations.has(key);
     }
+    /**
+     * THE WEAPON BUILT INTO YOUR HANDS (core p.458, xHarA3TNgxZXtZwgp).
+     * Canon routes these through Unarmed Combat and the Physical limit,
+     * so they REPLACE the bare-fists profile rather than sitting in a
+     * hand slot -- see getWeaponProfile and utilities/combat-exchange.ts,
+     * the two places that compute a punch.
+     *
+     * A drawn weapon always wins: chrome in the palm does not stop you
+     * shooting. Mutually exclusive by row (excludes), so at most one is
+     * ever installed and the find is the answer rather than a contest.
+     */
+    implantWeapon() {
+        for (const key of this.augmentations) {
+            const w = getAug(key)?.implantWeapon;
+            if (!w)
+                continue;
+            // A shock hand out of charges is a hand (p.458).
+            if (w.charges !== undefined && this.implantCharges <= 0)
+                return undefined;
+            return w;
+        }
+        return undefined;
+    }
+    /**
+     * Jolts left in a shock hand. Ten per hand in the book, recharging
+     * one per ten seconds while plugged in -- there is no wall clock here
+     * for a hand to be plugged into, so the trickle is compressed to a
+     * refill on rest (commands/rest.ts). Session state: a fresh install
+     * arrives charged.
+     */
+    implantCharges = 0;
+    /** Spends one jolt. Returns what is left. */
+    spendImplantCharge() {
+        if (this.implantCharges > 0)
+            this.implantCharges--;
+        return this.implantCharges;
+    }
+    /** Back to full -- a rest, or the moment the chrome goes in. */
+    refillImplantCharges() {
+        for (const key of this.augmentations) {
+            const w = getAug(key)?.implantWeapon;
+            if (w?.charges !== undefined) {
+                this.implantCharges = w.charges;
+                return;
+            }
+        }
+    }
     /** Full essence points lost, rounded up -- the toll Magic/Resonance pay. */
     get essenceBurn() {
         return Math.ceil(Player.ESSENCE_MAX - this.essence - 1e-9);
@@ -1177,6 +1287,95 @@ export class Player extends AbstractPlayer {
         const burn = this.essenceBurn;
         this.magic = Math.max(0, this.baseMagic - burn);
         this.resonance = Math.max(0, this.baseResonance - burn);
+        // A shock hand wakes up charged (p.458: ten per hand).
+        this.refillImplantCharges();
+        // A HOUSING TAKES THE DECK YOU BROUGHT (Chrome Flesh p.222). Nothing
+        // is granted -- the book charges 5,000 PLUS the deck, so this moves
+        // the one you own inside your skull and it stops being liftable.
+        if (getAug(aug.key)?.implantsCarriedDeck)
+            this.getAnyCyberdeck()?.implantIntoBody();
+    }
+    // ==================== Gear effects (catalog v13) ====================
+    // A catalog row says what it does (`effects`), and this is the one
+    // place the engine reads that: what is worn (and fitted into it), what
+    // is drawn, what is carried, what runs on the deck, what is stored on
+    // a commlink. Same shape as augBonus / qualityBonus so a pool adds the
+    // three the same way.
+    /** Every effect that applies right now, with the rating it scales by. */
+    applyingEffects() {
+        const out = [];
+        const take = (effects, defaultWhen, state, rating) => {
+            for (const e of effects)
+                if ((e.when ?? defaultWhen) === state)
+                    out.push({ effect: e, rating: rating ?? 1 });
+        };
+        for (const [groupName, group] of Object.entries(this._equipment)) {
+            if (!group)
+                continue;
+            for (const [slot, item] of Object.entries(group)) {
+                if (!item)
+                    continue;
+                if (Player.isWeaponSlot(groupName, slot)) {
+                    if (this.weaponDrawn)
+                        take(item.effects, item.defaultWhen, 'held', item.ratingValue);
+                    continue;
+                }
+                take(item.effects, item.defaultWhen, 'worn', item.ratingValue);
+            }
+        }
+        for (const item of this._inventory.getAllItems())
+            take(item.effects, item.defaultWhen, 'carried', item.ratingValue);
+        const runningOn = new Set();
+        const deck = this.activeDeck ?? this.getCyberdeck();
+        if (deck)
+            runningOn.add(deck);
+        const master = this.getPanMaster();
+        if (master)
+            runningOn.add(master);
+        for (const device of runningOn) {
+            for (const key of device.loadedPrograms) {
+                const p = getProgram(key);
+                const row = p ? catalogRowFor(`${p.name} Program`) ?? catalogRowFor(p.name) : undefined;
+                if (row?.effects)
+                    take(row.effects, 'running', 'running', row.ratingValue);
+            }
+        }
+        for (const device of [...this.commlinks(), ...this._inventory.getAllItems().filter(i => i.isCyberdeck())]) {
+            for (const key of device.storedPrograms) {
+                const soft = getSoft(key);
+                const row = soft ? catalogRowFor(soft.name) : undefined;
+                if (row?.effects)
+                    take(row.effects, 'stored', 'stored', row.ratingValue);
+            }
+        }
+        return out;
+    }
+    sumEffects(type, property, only) {
+        let total = 0;
+        for (const { effect, rating } of this.applyingEffects()) {
+            if (effect.type !== type || effect.property !== property)
+                continue;
+            if (effect.only !== undefined && effect.only !== only)
+                continue;
+            total += effect.value * (effect.scaleBy === 'rating' ? rating : 1);
+        }
+        return total;
+    }
+    /**
+     * Dice the gear adds to a pool or a skill's tests (cf. augBonus,
+     * qualityBonus): `kind` is a pool kind or a SkillName; `only` names a
+     * narrowing an effect may carry ('haggle', 'silent', 'matrix-search').
+     */
+    gearBonus(kind, opts = {}) {
+        return this.sumEffects('dice', kind, opts.only);
+    }
+    /** What the gear adds to a LIMIT (a Shopsoft's +1 Social on a haggle). */
+    gearLimit(kind, opts = {}) {
+        return this.sumEffects('limit', kind, opts.only);
+    }
+    /** A capability the gear grants (dni, smartlink, no-fog, low-light...), by key. */
+    hasCapability(key) {
+        return this.sumEffects('flag', key) > 0;
     }
     /**
      * The single tap every pool reads chrome through. Wired Reflexes tiers
@@ -1442,15 +1641,9 @@ export class Player extends AbstractPlayer {
         const weapon = this.weaponDrawn ? this.getCarriedWeapon() : null;
         if (!weapon)
             return 'unarmed';
-        if (weapon.isFirearm())
-            return firearmSkillFor(weapon);
-        // CLUBS vs BLADES (canon splits them): blunt instruments read as
-        // clubs by name/shape; everything else edged defaults to blades.
-        // Short tokens are boundary-anchored both sides -- "bat" once
-        // matched the tail of "Combat Knife".
-        return /club|\bbat\b|baton|staff|hammer|\bpipe\b|wrench|\bsap\b|\bmace\b|crowbar|cudgel/i.test(`${weapon.name} ${weapon.shape}`)
-            ? 'clubs'
-            : 'blades';
+        // The weapon block names the skill (catalog v13); Item.weaponSkill
+        // keeps the name/shape duck-typing for generated gear.
+        return weapon.weaponSkill;
     }
     initializeEquipment() {
         return {
@@ -1883,6 +2076,28 @@ export class Player extends AbstractPlayer {
     static isWeaponSlot(group, slot) {
         return (group === 'rightHand' || group === 'leftHand') && slot === 'weapon';
     }
+    /**
+     * WHERE A THING ACTUALLY IS RIGHT NOW, which for a weapon is not a
+     * property of the slot (user report, 2026-09-03: "when looking at
+     * equipment, and I have a Katana Holstered, I should not see Right
+     * hand Katana (weapon hand) -- it's not in hand, it's in holster").
+     *
+     * SLOT_WORDS is static, so it can only ever say where a weapon lives
+     * when drawn. The weapon slot is really two places -- the hand and the
+     * holster -- and `weaponDrawn` is which one. Everything else in the
+     * game already knew: the HUD prints "Holstered:", equip prints "You
+     * slide it into your holster", and the equipment screen's own top line
+     * prints HOLSTERED. Only the worn listing underneath still read the
+     * static word, so one screen contradicted itself.
+     *
+     * Instance method, not static, precisely because the answer depends on
+     * the actor rather than the slot.
+     */
+    wornSlotWord(group, slot) {
+        if (Player.isWeaponSlot(group, slot) && !this.weaponDrawn)
+            return 'holstered';
+        return Player.slotWord(group, slot);
+    }
     unequip(input) {
         const slotInfo = this.determineEquipmentSlot(input);
         if (slotInfo) {
@@ -2318,15 +2533,33 @@ export class Player extends AbstractPlayer {
         // partly from ignoring armor. Quality still rides on top. A HOLSTERED
         // weapon counts for nothing -- until it's drawn (brandish, or the
         // auto-draw when an exchange opens), your hands are empty.
-        const strengthBase = Math.floor(this.strength / 2);
+        // CANON NUMBERS (catalog v13, project owner 2026-09-03): the DV is the
+        // book's -- a Predator's 8, a knife's Strength + 2 -- read off the
+        // weapon block (Item.weaponDv / dvAttribute), with the class value as
+        // the fallback for generated gear. The PRICE TIER NO LONGER ADDS DAMAGE
+        // OR DICE: canon has no such thing, and a Legendary knife is a knife.
+        // Unarmed is (STR)S (p.187); bone lacing's +2 rides augBonus.
         const weapon = this.weaponDrawn ? this.getCarriedWeapon() : null;
         if (!weapon) {
-            // Bone lacing turns the fists themselves into weapons.
-            return { name: 'bare fists', damage: 1 + strengthBase + this.augBonus('unarmed-damage'), poolBonus: 0, armorPen: 0 };
+            // CHROME IN THE HANDS REPLACES THE FISTS (core p.458,
+            // xHarA3TNgxZXtZwgp): cyber melee weapons use Unarmed Combat and
+            // the Physical limit, so they arrive here rather than in a hand
+            // slot. SURFACE ONE OF TWO -- utilities/combat-exchange.ts computes
+            // this same punch independently, and both read implantWeapon.
+            const implant = this.implantWeapon();
+            if (implant) {
+                const aug = [...this.augmentations].map(k => getAug(k)).find(a => a?.implantWeapon);
+                return {
+                    name: aug?.name?.toLowerCase() ?? 'implanted blades',
+                    damage: implant.dv + (implant.dvAttribute === 'strength' ? this.strength : 0),
+                    poolBonus: 0,
+                    armorPen: implant.ap,
+                };
+            }
+            return { name: 'bare fists', damage: this.strength + this.augBonus('unarmed-damage'), poolBonus: 0, armorPen: 0 };
         }
-        const bonus = weapon.qualityBonus;
-        const base = weapon.category === Category.MeleeWeapon ? weapon.meleeBase + strengthBase : weapon.rangedBase;
-        return { name: weapon.name, damage: base + bonus, poolBonus: bonus, armorPen: weapon.armorPen };
+        const base = weapon.weaponDv + (weapon.dvAttribute === 'strength' ? this.strength : 0);
+        return { name: weapon.name, damage: base, poolBonus: 0, armorPen: weapon.armorPen };
     }
     /** The weapon riding in a hand slot, drawn or holstered. */
     getCarriedWeapon() {
@@ -2378,18 +2611,16 @@ export class Player extends AbstractPlayer {
             for (const item of Object.values(group)) {
                 if (!item || !Player.ARMOR_CATEGORIES.has(item.category))
                     continue;
-                if (item.category === Category.Helmet) {
-                    extras.push({ item, bonus: 1 });
-                    continue;
-                }
-                if (item.category === Category.Shield) {
-                    extras.push({ item, bonus: 2 });
+                // CANON NUMBERS (catalog v13): the row's Armor rating -- a jacket's
+                // 12, a helmet's +2 -- with the class value as the fallback.
+                const bonus = item.armorBonus;
+                if (bonus > 0) {
+                    extras.push({ item, bonus });
                     continue;
                 }
-                if (item.category === Category.Boots || item.category === Category.Gloves
-                    || item.category === Category.ArmArmor || item.category === Category.LegArmor)
+                const value = item.armorValue;
+                if (value <= 0)
                     continue;
-                const value = 1 + item.qualityBonus + (item.isHeavyArmor ? 1 : 0);
                 if (value > best) {
                     if (piece)
                         ignored.push(piece);
@@ -2401,7 +2632,16 @@ export class Player extends AbstractPlayer {
                 }
             }
         }
-        return { total: best + extras.reduce((n, e) => n + e.bonus, 0), piece, extras, ignored };
+        // p.169: the bonus from "+" accessories is capped at Strength, and
+        // every 2 full points over it costs -1 Agility and Reaction.
+        const bonusRaw = extras.reduce((n, e) => n + e.bonus, 0);
+        const bonusCapped = Math.min(bonusRaw, this.strength);
+        const encumbrance = Math.floor(Math.max(0, bonusRaw - this.strength) / 2);
+        return { total: best + bonusCapped, piece, extras, ignored, bonusCapped, encumbrance };
+    }
+    /** The p.169 encumbrance penalty on Agility and Reaction, as dice off those pools. */
+    get encumbrancePenalty() {
+        return this.armorBreakdown().encumbrance;
     }
     getAttackPool() {
         // Plane decides which attribute drives the fight: meat is muscle
@@ -2477,7 +2717,10 @@ export class Player extends AbstractPlayer {
         // weapon exercises a FIREARM skill at all. Archery is deliberately
         // not in that set -- a smartgun system is a firearm accessory
         // (p.433), and a crossbow has nothing to plug into.
-        const smartlink = FIREARM_SKILLS.includes(this.activeCombatSkill()) && this.weaponDrawn
+        // AND THE GUN MUST BE A SMARTGUN (catalog v13, p.433): the wireless
+        // bonus is the smartgun system talking to the smartlink.
+        const drawnGun = this.weaponDrawn ? this.getCarriedWeapon() : null;
+        const smartlink = drawnGun?.isSmartgun && FIREARM_SKILLS.includes(this.activeCombatSkill())
             ? (this.smartlinkTier() === 'gear' ? 1 : this.augBonus('firearms'))
             : 0;
         // RUNNING COSTS YOU (p.162 Running Modifiers): -2 dice on everything
@@ -2488,7 +2731,7 @@ export class Player extends AbstractPlayer {
         // sprinted across a room to reach someone arrived shooting exactly
         // as straight as one who strolled -- and the movement budget's whole
         // point is that ground has a price.
-        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.augBonus('attack') + smartlink + this.woundModifier - this.sustainingPenalty - this.runningPenalty);
+        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.augBonus('attack') + this.gearBonus('attack') + this.gearBonus(this.activeCombatSkill()) + smartlink + this.woundModifier - this.sustainingPenalty - this.runningPenalty - this.encumbrancePenalty);
     }
     /**
      * The subdual pool: bare-hands work regardless of what's in the other
@@ -2535,7 +2778,7 @@ export class Player extends AbstractPlayer {
         // Improved Reflexes rides Reaction itself (p.309), so it lands here too.
         const adeptBonus = this.adeptDefenseBonus() + this.adeptReactionBonus();
         const grappled = this.grappledBy ? 2 : 0;
-        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.augBonus('defense') + this.woundModifier - this.sustainingPenalty - grappled);
+        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.augBonus('defense') + this.gearBonus('defense') + this.woundModifier - this.sustainingPenalty - grappled - this.encumbrancePenalty);
     }
     getSoakPool() {
         // Matrix: firewall -- Logic plus the DECK's quality (your deck is your
@@ -2544,7 +2787,8 @@ export class Player extends AbstractPlayer {
         // meat left behind. Drone: the HULL soaks -- airframe body scaled by
         // build quality; the rider's armor is streets away with their body.
         if (this.plane === 'drone') {
-            return Math.max(0, 4 + 2 * (this.riggedDrone?.qualityBonus ?? 0));
+            // Body + Armor (p.199), from the drone's vehicle block (catalog v13).
+            return Math.max(0, (this.riggedDrone?.droneBody ?? 0) + (this.riggedDrone?.droneArmor ?? 0));
         }
         if (this.plane === 'matrix') {
             // MATRIX DAMAGE IS RESISTED WITH DEVICE RATING + FIREWALL
@@ -2561,13 +2805,13 @@ export class Player extends AbstractPlayer {
             }
             // A loaded Armor program hardens it further (+2, p.245 cited).
             const deck = this.activeDeck ?? this.getCyberdeck();
-            return Math.max(0, (deck?.deviceRating ?? 0) + this.matrixAttribute('firewall') + (deck?.hasProgram('armor') ? 2 : 0));
+            return Math.max(0, (deck?.deviceRating ?? 0) + this.matrixAttribute('firewall') + this.gearBonus('matrix-soak'));
         }
         if (this.plane === 'astral') {
             return Math.max(0, this.willpower);
         }
         // Mystic Armor (p.309): the adept power is armor that was never worn.
-        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor + this.adeptArmorBonus() + this.augBonus('soak') + this.qualityBonus('soak'));
+        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor + this.adeptArmorBonus() + this.augBonus('soak') + this.qualityBonus('soak') + this.gearBonus('soak'));
     }
     /**
      * THE INITIATIVE ATTRIBUTE -- what the dice are added TO (p.159,
@@ -3156,12 +3400,9 @@ export class Player extends AbstractPlayer {
     // whose quality feeds the drone pools, and whose destruction is a
     // DUMPSHOCK (see planes.ts leaveDrone).
     riggedDrone;
-    /** Whether the ridden drone carries a weapon mount (name/description duck-typing). */
+    /** Whether the ridden drone carries a weapon mount (its vehicle block, catalog v13; the name for generated frames). */
     get droneArmed() {
-        const d = this.riggedDrone;
-        if (!d)
-            return false;
-        return /armed|combat|gun|roto|assault|sentry|weapon/i.test(`${d.name} ${d.description ?? ''}`);
+        return this.riggedDrone?.hasWeaponMount ?? false;
     }
     // Dumpshock disorientation (SR5e p.229): -2 on everything for
     // (10 - Willpower) minutes after a forced dump, wall-clock -- the
@@ -3193,15 +3434,16 @@ export class Player extends AbstractPlayer {
     // "persuaded-by:<name>" marks who already made their play on this actor
     // this job. NPCs are rebuilt each scene, so it resets naturally.
     socialMarks = new Set();
-    /** The best Focus item on this actor, if any -- scales casting power. */
+    /** The best Focus item on this actor, if any -- by Force (catalog v13: ratingValue). */
     getBestFocus() {
         return this._inventory.getAllItems()
             .filter(i => i.category === Category.Focus)
-            .sort((a, b) => b.qualityBonus - a.qualityBonus)[0];
+            .sort((a, b) => (b.ratingValue ?? 0) - (a.ratingValue ?? 0))[0];
     }
     getMagicPool() {
-        const focus = this.getBestFocus();
-        const focusBonus = focus ? 1 + focus.qualityBonus : 0;
+        // A focus adds its Force to the tests it is bonded for (p.318): the
+        // row's effects, scaled by Force (catalog v13).
+        const focusBonus = this.gearBonus('spellcasting');
         // SR-proper when the SPELLCASTING skill is rated: Magic + Spellcasting
         // for the Awakened, base + skill for a book-caster. Unrated falls back
         // to the legacy shapes (talent max(5, magic+2); scholar's flat 5), so