@maka/maka-cli 5.3.17 → 5.5.0

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

@@ -2,6 +2,24 @@ import { Category } from '../types/shared/item-enum.js';
 import { Logger } from '../utilities/logger.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
+export const STANCE_CYCLE = ['manual', 'guarded', 'aggressive'];
+export const SKILL_NAMES = [
+    'firearms', 'blades', 'unarmed',
+    'sneaking', 'perception', 'athletics',
+    'hacking', 'locksmith',
+    'negotiation', 'con', 'intimidation',
+    'first-aid',
+    'assensing', 'spellcasting', 'piloting',
+];
+/**
+ * Skills that fall back to the legacy `combatSkill` attribute when no
+ * explicit rating is given -- this is what keeps every existing NPC seed
+ * (which only carries combatSkill) rolling exactly the pools it always
+ * has, ice included (its Matrix strikes ride `hacking`).
+ */
+export const COMBAT_SKILL_FALLBACK = new Set([
+    'firearms', 'blades', 'unarmed', 'hacking',
+]);
 export class Player extends AbstractPlayer {
     _playerName;
     _currentLocation;
@@ -11,6 +29,180 @@ export class Player extends AbstractPlayer {
     _lifestyleChoices = [];
     logger;
     _currency = 0; // for seeding/debug only
+    // Whoever this actor most recently placed/received a commlink call with.
+    // No explicit "hang up" -- placing a new call just replaces it. Lets a
+    // reply via the ordinary "say" command reach a call partner in a
+    // different room, the same way a real call would, without the NPC (or
+    // player) needing to learn a separate reply verb. See say.ts and call.ts.
+    activeCallPartner;
+    // Running silent (see commands/silent.ts): the commlink stays equipped
+    // but stops broadcasting -- no calls out, and nobody can raise this
+    // actor (call.ts checks both ends). Toggling it drops any active call.
+    runningSilent = false;
+    // Whoever this actor most recently traded combat exchanges with, and
+    // when -- set for BOTH sides by CombatExchange.beginExchange(). Walking
+    // out on a live, recent opponent invites a parting shot (see go.ts);
+    // firing one (or a death) clears it.
+    combatOpponent;
+    lastExchangeAt = 0;
+    // True while this actor is a combatant in an exchange that's still
+    // resolving. Serializes combat per actor: a second attack involving a
+    // busy combatant is refused instead of interleaving -- found via a real
+    // session where an NPC's overlapping AI loops fired two exchanges at
+    // once and the target died TWICE (two kill events, two narrations).
+    inExchange = false;
+    // Fight-or-flight autopilot (see utilities/auto-fight.ts): the FIGHT
+    // half runs automatically at the set temperature, the flight stays
+    // manual -- always. Tab cycles it in the UI; "stance" sets it by name.
+    //   manual     -- today's behavior, you type every swing
+    //   guarded    -- auto-fights, but finishes non-lethally (switches to
+    //                 subdue when the target is nearly down) and stands down
+    //                 if they surrender
+    //   aggressive -- fights until they're dead; surrender means nothing
+    autoStance = 'manual';
+    // Set by the "surrender" command: this actor has thrown their hands up.
+    // Cleared the moment they initiate violence again (see
+    // CombatExchange.beginExchange). Guarded auto-fight honors it;
+    // aggressive doesn't have to.
+    surrendered = false;
+    // The archetype picked at launch (ui.ts), kept by NAME so downstream
+    // consumers -- scene generation's player dossier, above all -- can say
+    // "this is a Decker" instead of re-deriving the concept from stats.
+    // undefined for NPCs and for players created outside the launch flow.
+    archetypeName;
+    // An equipped weapon rides in a HOLSTER until it's deliberately drawn --
+    // "brandish"/"holster" flip this by hand (see commands/brandish.ts), and
+    // opening an exchange draws steel automatically for anyone whose weapon
+    // is about to speak (CombatExchange.beginExchange), so combat never
+    // punishes forgetting the verb. What the flag actually buys is the
+    // walking-around state: a holstered gun is polite, a drawn one is a
+    // threat display every NPC in the room sees happen.
+    weaponDrawn = false;
+    // ==================== Planes (see utilities/planes.ts) ====================
+    // Which plane this actor currently exists on. Ice NPCs live on 'matrix',
+    // spirits on 'astral', natively and permanently; a player shifts planes
+    // via jack in / project and back.
+    plane = 'meat';
+    // While off the meat plane, the empty body slumps HERE -- visible,
+    // attackable (see planes.ts resolveBodyAttack), and where you snap back
+    // to. undefined while on the meat plane, or for native off-plane actors
+    // (ice and spirits have no body to leave behind).
+    bodyRoom;
+    // Matrix only: cold or hot sim, chosen at jack-in. undefined off-Matrix
+    // and for native ice.
+    simMode;
+    // Astral only: room-moves made while projecting. The longer you're out,
+    // the harder the snap-back -- drained as stun on return (planes.ts).
+    astralTicks = 0;
+    // The DECK you're jacked in on (set by planes.ts enterMatrix, cleared on
+    // leaving). Matrix damage is HARDWARE damage: it lands on this item's
+    // device condition monitor (see Item's cyberdeck section), persists
+    // across jack-outs, and a full track BRICKS the deck -- forced dump,
+    // and no re-entry on that deck until it's repaired.
+    activeDeck;
+    /** The best working cyberdeck carried (bricked ones don't count). */
+    getCyberdeck() {
+        return this._inventory.getAllItems()
+            .filter(i => i.isCyberdeck() && !i.isBricked)
+            .sort((a, b) => b.qualityBonus - a.qualityBonus)[0];
+    }
+    /** Any deck at all, bricked included -- for status displays and repair. */
+    getAnyCyberdeck() {
+        return this.activeDeck ?? this._inventory.getAllItems()
+            .filter(i => i.isCyberdeck())
+            .sort((a, b) => b.qualityBonus - a.qualityBonus)[0];
+    }
+    // ==================== PAN (see commands/pan.ts, hack.ts) ====================
+    // Hacked dark: an enemy cracked your PAN and cut the AR overlay. Costs
+    // the commlink initiative bonus and drops calls, until "reboot". Distinct
+    // from runningSilent (chosen dark) -- this one was done TO you.
+    arOffline = false;
+    /**
+     * The PAN's master device: your slaved gear defends behind its
+     * firewall (SR slaving, simplified). Best working deck beats the
+     * equipped commlink; no devices = no PAN (and nothing to hack).
+     */
+    getPanMaster() {
+        const deck = this.getCyberdeck();
+        const link = this._equipment.head?.commlink ?? undefined;
+        if (deck && link)
+            return deck.qualityBonus >= link.qualityBonus ? deck : link;
+        return deck ?? link;
+    }
+    /**
+     * Defense against a PAN intrusion: Logic + the master's firewall
+     * (+2 while running silent -- a hidden PAN must be FOUND first).
+     */
+    getPanDefensePool() {
+        const master = this.getPanMaster();
+        const silentBonus = this.runningSilent ? 2 : 0;
+        return Math.max(0, this.logic + (master?.qualityBonus ?? 0) + silentBonus);
+    }
+    get matrixTaken() {
+        return this.getAnyCyberdeck()?.deckDamage ?? 0;
+    }
+    get maxMatrixBoxes() {
+        return this.getAnyCyberdeck()?.maxDeckBoxes ?? 0;
+    }
+    /** Routes Matrix combat damage into the jacked-in deck's hardware track. */
+    takeMatrixDamage(boxes) {
+        const deck = this.getAnyCyberdeck();
+        return deck ? deck.takeDeckDamage(boxes) : 0;
+    }
+    get matrixCrashed() {
+        return this.getAnyCyberdeck()?.isBricked ?? false;
+    }
+    /** The deck track, same rendering as conditionSummary(). */
+    matrixSummary() {
+        return this.getAnyCyberdeck()?.deckSummary() ?? '(no deck)';
+    }
+    /**
+     * Cross-plane perception, the single rule everything filters through:
+     * same plane sees same plane; the astral perceives the meat world
+     * (shifted, not gone -- auras and movement, dimly); meat and Matrix see
+     * nothing beyond their own plane. Used by see/hear guards, targeting,
+     * and room listings.
+     */
+    canPerceive(other) {
+        if (this.plane === other.plane)
+            return true;
+        return this.plane === 'astral' && other.plane === 'meat';
+    }
+    // True while an AI-driven action is parked waiting for an in-flight
+    // exchange to settle (CombatExchange.waitForLull). One queued action per
+    // actor: a second colliding attempt is refused outright instead of
+    // stacking a burst of delayed attacks behind the same lull.
+    waitingForLull = false;
+    // Combat attributes (see ICombatAttributes). Defaults make an unseeded
+    // actor a competent-but-mortal street-level runner; seeds can override
+    // per-NPC to make a hardened enforcer or a soft civilian.
+    body;
+    agility;
+    reaction;
+    combatSkill;
+    magic;
+    strength;
+    willpower;
+    logic;
+    intuition;
+    charisma;
+    edge;
+    resonance;
+    adept;
+    // Edge is a per-job pool: spend a point (see commands/edge.ts) to arm a
+    // boost that supercharges your next strike. Refreshed to `edge` on every
+    // new job (see Game.continueToNextScene).
+    edgeRemaining = 0;
+    edgeBoostArmed = false;
+    // Physical condition monitor, straight from SR5: 8 + (Body / 2, rounded
+    // up) boxes. Damage fills boxes; a full track is death.
+    _damageTaken = 0;
+    // Stun condition monitor -- the second track, filled by spell drain (see
+    // cast.ts). A full stun track is a knockout, not death, but overflow
+    // past it spills into the physical track. Sized off Reaction as the
+    // stand-in for SR's Willpower (the closest thing to a mental attribute
+    // here without adding one): 8 + (Reaction / 2, rounded up).
+    _stunTaken = 0;
     constructor(config) {
         super();
         this._playerName = config.playerName;
@@ -18,8 +210,53 @@ export class Player extends AbstractPlayer {
         this._inventory = new Inventory();
         this.logger = Logger.getInstance();
         this._lifestyleChoices = config.lifestyleChoices ?? [];
+        this.body = config.combat?.body ?? 4;
+        this.agility = config.combat?.agility ?? 4;
+        this.reaction = config.combat?.reaction ?? 4;
+        this.combatSkill = config.combat?.combatSkill ?? 3;
+        this.magic = config.combat?.magic ?? 0;
+        this.strength = config.combat?.strength ?? 3;
+        this.willpower = config.combat?.willpower ?? 3;
+        this.logic = config.combat?.logic ?? 3;
+        this.intuition = config.combat?.intuition ?? 3;
+        this.charisma = config.combat?.charisma ?? 3;
+        this.edge = config.combat?.edge ?? 2;
+        this.edgeRemaining = this.edge;
+        this.resonance = config.combat?.resonance ?? 0;
+        this.adept = config.combat?.adept ?? false;
+        this.skills = { ...(config.combat?.skills ?? {}) };
         this._equipment = this.initializeEquipment();
     }
+    // ======================== Skills (see SkillName) ========================
+    /** Explicit per-skill ratings; anything absent resolves via skillRating(). */
+    skills = {};
+    // Karma: the advancement currency, earned per completed job (see
+    // Scene.checkWinCondition) and spent in the hideout via "advance" --
+    // gear stops being the only progression axis.
+    karma = 0;
+    /**
+     * The effective rating for a skill: explicit rating if set; otherwise
+     * combat skills fall back to the legacy `combatSkill` attribute (which
+     * keeps every skill-less NPC seed rolling its historical pools), and
+     * everything else is 0 (unskilled).
+     */
+    skillRating(name) {
+        const explicit = this.skills[name];
+        if (typeof explicit === 'number')
+            return Math.max(0, explicit);
+        return COMBAT_SKILL_FALLBACK.has(name) ? this.combatSkill : 0;
+    }
+    /**
+     * Which combat skill the current armament exercises: firearms for a
+     * drawn gun, blades for a drawn melee weapon, unarmed for empty hands
+     * (or anything holstered -- see weaponDrawn).
+     */
+    activeCombatSkill() {
+        const weapon = this.weaponDrawn ? this.getCarriedWeapon() : null;
+        if (!weapon)
+            return 'unarmed';
+        return weapon.isFirearm() ? 'firearms' : 'blades';
+    }
     initializeEquipment() {
         return {
             head: {
@@ -31,6 +268,7 @@ export class Player extends AbstractPlayer {
                 commlink: null
             },
             torso: {
+                clothing: null,
                 armorVest: null,
                 armorCoat: null,
                 backpack: null,
@@ -97,7 +335,9 @@ export class Player extends AbstractPlayer {
         this._equipment = newEquipment;
     }
     get maxCarryingWeight() {
-        return this._maxCarryingWeight;
+        // Strength-derived: 20 + 10/point. The old flat default (50kg) is
+        // exactly what a strength-3 runner gets, so pre-sheet balance holds.
+        return 20 + this.strength * 10;
     }
     set maxCarryingWeight(weight) {
         if (weight > 0) {
@@ -109,10 +349,19 @@ export class Player extends AbstractPlayer {
     }
     get currentWeight() {
         let totalWeight = this._inventory.getWeight();
-        for (const slot in this._equipment) {
-            const equippedItem = this._equipment[slot];
-            if (equippedItem) {
-                totalWeight += equippedItem.weight;
+        // Equipment is nested one level deeper than inventory: groups (head,
+        // torso...) containing slots. This used to add `group.weight` --
+        // undefined -- which turned the total into NaN, so the carrying cap
+        // NEVER triggered (NaN compares false against everything). Found when
+        // a "take all" verification watched a 100kg engine block walk into a
+        // 50kg pack.
+        for (const group of Object.values(this._equipment)) {
+            if (!group)
+                continue;
+            for (const item of Object.values(group)) {
+                if (item) {
+                    totalWeight += item.weight;
+                }
             }
         }
         return totalWeight;
@@ -149,12 +398,29 @@ export class Player extends AbstractPlayer {
         if (!groupRef) {
             return `You have no ${group} equipment group initialized.`;
         }
-        if (groupRef[slot]) {
-            return `You already have something equipped in your ${group}.${slot} slot.`;
+        const previousItem = groupRef[slot];
+        let swapNotice = '';
+        if (previousItem) {
+            if (previousItem.name === item.name) {
+                return `You already have ${item.name} equipped in your ${group}.${slot} slot.`;
+            }
+            this.unequipBySlot(group, slot);
+            swapNotice = ` (unequipped ${previousItem.name})`;
         }
         groupRef[slot] = item;
         this.removeInventory(item);
-        return `You equipped ${item.name} in your ${group}.${slot} slot.`;
+        // A freshly equipped weapon goes to the HOLSTER, not the hand -- see
+        // the weaponDrawn field. Swapping weapons re-holsters even if the old
+        // one was out: the moment of the exchange, both hands are busy.
+        if (Player.isWeaponSlot(group, slot)) {
+            this.weaponDrawn = false;
+            return `You slide ${item.name} into your holster.${swapNotice} "brandish" when you want it in hand.`;
+        }
+        return `You equipped ${item.name} in your ${group}.${slot} slot.${swapNotice}`;
+    }
+    /** True for the hand slots that hold a wielded weapon. */
+    static isWeaponSlot(group, slot) {
+        return (group === 'rightHand' || group === 'leftHand') && slot === 'weapon';
     }
     unequip(input) {
         const slotInfo = this.determineEquipmentSlot(input);
@@ -197,8 +463,14 @@ export class Player extends AbstractPlayer {
             case Category.Commlink:
                 return { group: 'head', slot: 'commlink' };
             // TORSO
+            case Category.Clothing:
+            case 'shirt':
+            case 'hoodie':
+            case 'top':
+                return { group: 'torso', slot: 'clothing' };
             case Category.Armor:
             case Category.BodyArmor:
+            case Category.ArmorClothing:
             case 'armor vest':
                 return { group: 'torso', slot: 'armorVest' };
             case 'armor coat':
@@ -292,14 +564,21 @@ export class Player extends AbstractPlayer {
         }
         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.`;
     }
     hear(actor, message) {
+        // Cross-plane silence: a Matrix persona's chatter never reaches meat
+        // ears and vice versa; the astral hears the meat world it overlays.
+        if (!this.canPerceive(actor))
+            return;
         this.logger.write(`${this.name} heard ${actor.name}`);
         this.logger.logWithColor(`{white-fg}${actor.name}:{/white-fg} ${message}`, (actor === this) ? 'yellow' : 'green');
     }
     see(actor, verb, details) {
-        if (actor !== this) {
+        if (actor !== this && this.canPerceive(actor)) {
             this.logger.write(`You see ${actor.name} ${verb} ${details}`);
             this.logger.logWithColor(`${actor.name} ${verb} ${details}`, 'cyan');
         }
@@ -323,6 +602,379 @@ export class Player extends AbstractPlayer {
             this.logger.write(`${this.name} has left ${this._currentLocation.name}`);
         }
     }
+    // ======================== Combat (see commands/attack.ts) ========================
+    static ARMOR_CATEGORIES = new Set([
+        Category.Armor, Category.BodyArmor, Category.ArmorClothing, Category.Shield,
+        Category.Helmet, Category.ArmArmor, Category.LegArmor, Category.Boots, Category.Gloves,
+    ]);
+    get maxConditionBoxes() {
+        return 8 + Math.ceil(this.body / 2);
+    }
+    get damageTaken() {
+        return this._damageTaken;
+    }
+    get maxStunBoxes() {
+        // Willpower-based, as SR intends (Reaction stood in before Willpower
+        // existed on the sheet). Default willpower 3 keeps the same 10 boxes
+        // the old reaction-4 default produced.
+        return 8 + Math.ceil(this.willpower / 2);
+    }
+    get stunTaken() {
+        return this._stunTaken;
+    }
+    /**
+     * SR5 wound modifier: -1 die on every pool per 3 full boxes of damage,
+     * and the two tracks STACK -- being shot and drained both make you worse
+     * at everything, including not getting shot.
+     */
+    get woundModifier() {
+        return -(Math.floor(this._damageTaken / 3) + Math.floor(this._stunTaken / 3));
+    }
+    /** Dead: the physical track is full. */
+    isDown() {
+        return this._damageTaken >= this.maxConditionBoxes;
+    }
+    /** Out cold: the stun track is full (but not necessarily dead). */
+    isUnconscious() {
+        return this._stunTaken >= this.maxStunBoxes;
+    }
+    /** Out of the fight either way -- the gate every action should check. */
+    isIncapacitated() {
+        return this.isDown() || this.isUnconscious();
+    }
+    /** Applies damage boxes; returns the number actually taken. */
+    takeDamage(boxes) {
+        const taken = Math.max(0, Math.floor(boxes));
+        this._damageTaken = Math.min(this.maxConditionBoxes, this._damageTaken + taken);
+        return taken;
+    }
+    /**
+     * Clears damage boxes; returns how many were actually healed (can be
+     * less than asked when the track is nearly clean). Healing also restores
+     * wound-modifier dice, since that's derived from damageTaken.
+     */
+    healDamage(boxes) {
+        const before = this._damageTaken;
+        this._damageTaken = Math.max(0, before - Math.max(0, Math.floor(boxes)));
+        return before - this._damageTaken;
+    }
+    /**
+     * Applies stun boxes; anything past a full stun track OVERFLOWS into the
+     * physical track (SR's rule -- enough drain doesn't just knock you out,
+     * it starts killing you). Returns what landed where.
+     */
+    takeStun(boxes) {
+        const asked = Math.max(0, Math.floor(boxes));
+        const space = this.maxStunBoxes - this._stunTaken;
+        const stun = Math.min(asked, space);
+        this._stunTaken += stun;
+        const overflow = asked - stun;
+        if (overflow > 0) {
+            this.takeDamage(overflow);
+        }
+        return { stun, overflow };
+    }
+    /** e.g. "■■■□□□□□□□ (3/10)" */
+    conditionSummary() {
+        const max = this.maxConditionBoxes;
+        const filled = Math.min(max, this._damageTaken);
+        return `${'■'.repeat(filled)}${'□'.repeat(max - filled)} (${filled}/${max})`;
+    }
+    /** Clears stun boxes; returns how many were actually recovered. */
+    healStun(boxes) {
+        const before = this._stunTaken;
+        this._stunTaken = Math.max(0, before - Math.max(0, Math.floor(boxes)));
+        return before - this._stunTaken;
+    }
+    /** The stun track, same rendering as conditionSummary(). */
+    stunSummary() {
+        const max = this.maxStunBoxes;
+        const filled = Math.min(max, this._stunTaken);
+        return `${'■'.repeat(filled)}${'□'.repeat(max - filled)} (${filled}/${max})`;
+    }
+    /**
+     * The weapon actually in hand (right hand first, then left), or bare
+     * fists. Damage value and the attack-pool bonus both come off the item's
+     * quality rating -- gear is the whole progression system in this game,
+     * so it has to be what combat power flows from.
+     */
+    getWeaponProfile() {
+        // Off the meat plane your gun is just a memory: Matrix combat runs on
+        // attack programs (Logic-scaled), astral combat on raw will given
+        // form (Magic-scaled). Hot-sim's deeper immersion sharpens the
+        // programs' bite.
+        if (this.plane === 'matrix') {
+            const hot = this.simMode === 'hot' ? 1 : 0;
+            // The deck IS the arsenal: its quality feeds program damage the way
+            // a better gun feeds DV. A technomancer's living persona weaves
+            // resonance instead of running programs.
+            if (this.isTechnomancer()) {
+                return { name: 'resonance surge', damage: 2 + Math.floor(this.logic / 2) + Math.floor(this.resonance / 2) + hot, poolBonus: 0 };
+            }
+            const deck = this.activeDeck ?? this.getCyberdeck();
+            return { name: 'attack programs', damage: 2 + Math.floor(this.logic / 2) + (deck?.qualityBonus ?? 0) + hot, poolBonus: 0 };
+        }
+        if (this.plane === 'astral') {
+            return { name: 'astral strike', damage: 2 + Math.floor(Math.max(1, this.magic) / 2), poolBonus: 0 };
+        }
+        // Muscle drives melee: unarmed 1 + STR/2, melee weapons 2 + STR/2 +
+        // quality (a strength-3 actor lands exactly the old flat numbers).
+        // Firearms don't care how strong you are. 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);
+        const weapon = this.weaponDrawn ? this.getCarriedWeapon() : null;
+        if (!weapon) {
+            return { name: 'bare fists', damage: 1 + strengthBase, poolBonus: 0 };
+        }
+        const bonus = weapon.qualityBonus;
+        const base = weapon.category === Category.MeleeWeapon ? 2 + strengthBase : 4;
+        return { name: weapon.name, damage: base + bonus, poolBonus: bonus };
+    }
+    /** The weapon riding in a hand slot, drawn or holstered. */
+    getCarriedWeapon() {
+        return this._equipment.rightHand?.weapon ?? this._equipment.leftHand?.weapon ?? null;
+    }
+    /** Draws the carried weapon; returns it, or null if nothing changed
+     * (unarmed, or already in hand). */
+    drawWeapon() {
+        const weapon = this.getCarriedWeapon();
+        if (!weapon || this.weaponDrawn)
+            return null;
+        this.weaponDrawn = true;
+        return weapon;
+    }
+    /** Stows the drawn weapon; returns it, or null if nothing changed. */
+    stowWeapon() {
+        const weapon = this.getCarriedWeapon();
+        if (!weapon || !this.weaponDrawn)
+            return null;
+        this.weaponDrawn = false;
+        return weapon;
+    }
+    /** Total soak dice from every equipped armor-category item. */
+    getArmorValue() {
+        let total = 0;
+        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)) {
+                    total += 1 + item.qualityBonus;
+                }
+            }
+        }
+        return total;
+    }
+    getAttackPool() {
+        // Plane decides which attribute drives the fight: meat is muscle
+        // (Agility), the Matrix is mind (Logic, hot-sim +2), the astral is
+        // will (Willpower + half Magic). The SKILL is per-armament now (see
+        // activeCombatSkill / skillRating): firearms, blades, or unarmed in
+        // the meat; hacking is cybercombat; astral strikes ride unarmed (will
+        // given form). Wounds and sustaining drag everywhere.
+        if (this.plane === 'matrix') {
+            const hot = this.simMode === 'hot' ? 2 : 0;
+            return Math.max(0, this.logic + this.skillRating('hacking') + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+        }
+        if (this.plane === 'astral') {
+            return Math.max(0, this.willpower + Math.floor(this.magic / 2) + this.skillRating('unarmed') + this.woundModifier - this.sustainingPenalty);
+        }
+        // An adept's magic lives in their hands: half of it (rounded down)
+        // rides every meat-plane strike -- killing hands, improved reflexes.
+        const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
+        return Math.max(0, this.agility + this.skillRating(this.activeCombatSkill()) + adeptBonus + this.getWeaponProfile().poolBonus + this.woundModifier - this.sustainingPenalty);
+    }
+    /**
+     * The subdual pool: bare-hands work regardless of what's in the other
+     * fist -- Agility + unarmed (never the drawn weapon's skill or bonus).
+     * See subdue.ts.
+     */
+    getUnarmedAttackPool() {
+        const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
+        return Math.max(0, this.agility + this.skillRating('unarmed') + adeptBonus + this.woundModifier - this.sustainingPenalty);
+    }
+    getDefensePool() {
+        // Reaction plus HALF intuition (rounded down) -- full SR
+        // Reaction+Intuition turned text-paced exchanges into whiff-fests, so
+        // gut feel contributes at half weight. Intuition 3 (the default) adds
+        // +1 over the old reaction-only pool. Off-plane variants swap the
+        // reflex attribute but keep the same shape.
+        if (this.plane === 'matrix') {
+            const hot = this.simMode === 'hot' ? 1 : 0;
+            return Math.max(0, this.intuition + Math.floor(this.logic / 2) + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+        }
+        if (this.plane === 'astral') {
+            return Math.max(0, this.intuition + Math.floor(this.magic / 2) + this.woundModifier - this.sustainingPenalty);
+        }
+        // Combat sense: the adept's magic reads the fight before it happens.
+        const adeptBonus = this.adept ? Math.floor(this.magic / 2) : 0;
+        return Math.max(0, this.reaction + Math.floor(this.intuition / 2) + adeptBonus + this.woundModifier - this.sustainingPenalty);
+    }
+    getSoakPool() {
+        // Matrix: firewall -- Logic plus the DECK's quality (your deck is your
+        // armor); a technomancer's firewall is Willpower plus half resonance
+        // (their mind guards itself). Astral: pure Willpower; worn armor is
+        // meat left behind.
+        if (this.plane === 'matrix') {
+            if (this.isTechnomancer()) {
+                return Math.max(0, this.willpower + Math.floor(this.resonance / 2));
+            }
+            const deck = this.activeDeck ?? this.getCyberdeck();
+            return Math.max(0, this.logic + (deck?.qualityBonus ?? 0));
+        }
+        if (this.plane === 'astral') {
+            return Math.max(0, this.willpower);
+        }
+        return Math.max(0, this.body + this.getArmorValue() + this._sustainedArmor);
+    }
+    /**
+     * Initiative: Reaction + Intuition (straight SR), plus the AR edge from
+     * an equipped, ONLINE commlink -- the tactical overlay feeding you
+     * angles. Running silent kills the overlay along with the broadcast, so
+     * going dark costs you speed on the draw: the silent tradeoff grows
+     * teeth. Wounds and sustained spells slow you like everything else.
+     */
+    getInitiativePool() {
+        // Matrix speed is thought-speed: Logic + Intuition, hot-sim +2 (the
+        // whole point of running hot). Astral forms move at the speed of
+        // intention: Intuition doubled.
+        if (this.plane === 'matrix') {
+            const hot = this.simMode === 'hot' ? 2 : 0;
+            return Math.max(0, this.logic + this.intuition + Math.floor(this.resonance / 2) + hot + this.woundModifier - this.sustainingPenalty);
+        }
+        if (this.plane === 'astral') {
+            return Math.max(0, this.intuition * 2 + this.woundModifier - this.sustainingPenalty);
+        }
+        const link = this._equipment.head?.commlink;
+        // AR needs a link that's on you, broadcasting, and not hacked dark.
+        const arBonus = link && !this.runningSilent && !this.arOffline ? link.qualityBonus : 0;
+        return Math.max(0, this.reaction + this.intuition + arBonus + this.woundModifier - this.sustainingPenalty);
+    }
+    /**
+     * If an edge boost is armed (see commands/edge.ts), consume it: returns
+     * the bonus dice for the strike being rolled right now and disarms.
+     * Called by the strike-profile builders, so the boost lands on the next
+     * attack/subdue/manabolt this actor initiates.
+     */
+    consumeEdgeBoost() {
+        if (!this.edgeBoostArmed)
+            return 0;
+        this.edgeBoostArmed = false;
+        return this.edge;
+    }
+    /** New job, fresh luck -- and a fresh seat at the negotiating table. */
+    refreshEdge() {
+        this.edgeRemaining = this.edge;
+        this.edgeBoostArmed = false;
+        this.haggledThisJob = false;
+    }
+    // ======================== Magic (see commands/cast.ts) ========================
+    // Two roads to casting. GEAR-DRIVEN: what a mundane can cast comes from
+    // the spell formulas/grimoires they carry, at a flat scholar's base pool
+    // -- consistent with the rest of the game, where gear IS the progression
+    // system. INNATE: an Awakened actor (magic attribute > 0) knows every
+    // spell without any gear -- the talent is the knowledge; formulas are
+    // how mundanes fake it -- and casts from magic + 2 instead of the flat
+    // base, so a strong mage out-throws any book-taught scholar. A Focus
+    // stacks on top of either road.
+    /** Base casting dice for a mundane casting from a formula/grimoire. */
+    static BASE_MAGIC_POOL = 5;
+    /** Awakened: innate talent, no gear required. Adepts count -- their
+     * aura burns like any mage's, and assensing works -- but they channel
+     * magic into the body, not spells (see knowsSpell/isCaster). */
+    isAwakened() {
+        return this.magic > 0;
+    }
+    /** Technomancer: living persona -- the Matrix without a deck (see ICombatAttributes.resonance). */
+    isTechnomancer() {
+        return this.resonance > 0;
+    }
+    // A sustained spell (currently only the armor spell) grants its bonus
+    // continuously but costs concentration: -2 dice on every active pool
+    // while it's up. See cast.ts.
+    _sustainedArmor = 0;
+    get sustainedArmor() {
+        return this._sustainedArmor;
+    }
+    setSustainedArmor(bonus) {
+        this._sustainedArmor = Math.max(0, Math.floor(bonus));
+    }
+    get sustainingPenalty() {
+        // Each sustained effect costs -2 dice across the board: the armor
+        // spell, and open astral senses (see commands/assense.ts). They stack
+        // -- holding both is walking around half-blind.
+        return (this._sustainedArmor > 0 ? 2 : 0) + (this.astralPerceiving ? 2 : 0);
+    }
+    // Astral perception (see commands/assense.ts): senses held OPEN as a
+    // sustained state -- passive aura reads, at -2 dice to everything else.
+    // Meat-plane only; projecting IS full astral senses (cleared on
+    // project), and the Matrix has no auras at all.
+    astralPerceiving = false;
+    // Sneak-walking (see commands/sneak.ts): room entries become opposed
+    // Sneaking-vs-Perception rolls per witness (NPC.see). Broken by any
+    // loud act -- attacking, casting, speaking, brandishing, calling.
+    sneaking = false;
+    // One haggle per job (see commands/haggle.ts); reset with the edge pool
+    // on each new job (refreshEdge).
+    haggledThisJob = false;
+    // Where this actor just came from and the direction BACK -- the HUD's
+    // breadcrumb (see game.ts updateStatus / go.ts). Big scenes (the hub's
+    // 18 rooms) made "which way did I come in" a real question. Cleared on
+    // scene transitions; only meaningful room-to-room.
+    cameFrom;
+    // Social-play bookkeeping ON THE TARGET (see commands/persuade.ts):
+    // "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. */
+    getBestFocus() {
+        return this._inventory.getAllItems()
+            .filter(i => i.category === Category.Focus)
+            .sort((a, b) => b.qualityBonus - a.qualityBonus)[0];
+    }
+    getMagicPool() {
+        const focus = this.getBestFocus();
+        const focusBonus = focus ? 1 + focus.qualityBonus : 0;
+        // 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
+        // skill-less NPC mages keep their historical pools.
+        const spellSkill = this.skillRating('spellcasting');
+        const base = this.isAwakened()
+            ? (spellSkill > 0 ? this.magic + spellSkill : Math.max(Player.BASE_MAGIC_POOL, this.magic + 2))
+            : Player.BASE_MAGIC_POOL + spellSkill;
+        return Math.max(0, base + focusBonus + this.woundModifier - this.sustainingPenalty);
+    }
+    /**
+     * Awakened actors know every spell innately. A mundane knows a spell if
+     * they carry its formula (item name must contain the spell's name) or
+     * any grimoire (a spellbook teaches everything).
+     */
+    knowsSpell(spellName) {
+        // An adept's magic is muscle memory, not incantation -- no spells,
+        // not even from a formula in hand. Their magic already lives in their
+        // meat-plane combat pools.
+        if (this.adept)
+            return false;
+        if (this.isAwakened())
+            return true;
+        const wanted = spellName.toLowerCase();
+        return this._inventory.getAllItems().some(i => i.category === Category.Grimoire ||
+            (i.category === Category.SpellFormula && i.name.toLowerCase().includes(wanted)));
+    }
+    /**
+     * The gate for attempting magic at all (ward bypass included): innate
+     * talent, or any magic gear.
+     */
+    isCaster() {
+        if (this.adept)
+            return false; // body-magic only -- see knowsSpell
+        return this.isAwakened() || this._inventory.getAllItems().some(i => i.category === Category.SpellFormula ||
+            i.category === Category.Grimoire ||
+            i.category === Category.Focus);
+    }
+    // ================================================================================
     get lifestyleChoices() {
         return this._lifestyleChoices;
     }