@maka/maka-cli 5.3.17 → 5.5.0

package/bundle/typescript/src/commands/game/sideQuest/models/player.d.ts

@@ -5,10 +5,87 @@ import { Room } from './room.js';
 import { Item } from './item.js';
 import { Inventory } from './inventory.js';
 import { AbstractPlayer } from '../types/shared/abstracts.js';
+/**
+ * Shadowrun-style combat attributes, deliberately trimmed to the four that
+ * drive dice pools here: Body (soak + condition monitor size), Agility
+ * (attack pool), Reaction (defense pool), and a single flat combat skill
+ * (attack pool). Everything else a real character sheet would carry is out
+ * of scope until something actually needs it.
+ */
+export type FightStance = 'manual' | 'guarded' | 'aggressive';
+export declare const STANCE_CYCLE: FightStance[];
+export type Plane = 'meat' | 'matrix' | 'astral';
+export type SimMode = 'cold' | 'hot';
+/**
+ * The SR5e-condensed active skill list. Every pool that used to lean on
+ * the single generic `combatSkill` attribute now draws the SPECIFIC
+ * skill (firearms for guns, blades for melee weapons, unarmed for fists
+ * and subdual, hacking for cybercombat). Non-combat skills back their own
+ * mechanics as they land -- perception drives search rolls today; the
+ * rest are rated on the sheet and waiting for their verbs.
+ */
+export type SkillName = 'firearms' | 'blades' | 'unarmed' | 'sneaking' | 'perception' | 'athletics' | 'hacking' | 'locksmith' | 'negotiation' | 'con' | 'intimidation' | 'first-aid' | 'assensing' | 'spellcasting' | 'piloting';
+export declare const SKILL_NAMES: SkillName[];
+/**
+ * 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 declare const COMBAT_SKILL_FALLBACK: ReadonlySet<SkillName>;
+export interface ICombatAttributes {
+    body?: number;
+    agility?: number;
+    reaction?: number;
+    combatSkill?: number;
+    /**
+     * Per-skill ratings (1-8; see SkillName). Any skill omitted here
+     * defaults: combat skills to `combatSkill`, everything else to 0
+     * (unskilled -- rolled as the linked attribute MINUS ONE where a
+     * mechanic supports defaulting, e.g. perception on search).
+     */
+    skills?: Partial<Record<SkillName, number>>;
+    /**
+     * Innate magical talent -- 0 (the default) is mundane, like most of the
+     * Sixth World. An Awakened actor (magic > 0) knows every spell innately
+     * and casts from this attribute instead of needing formulas; see the
+     * magic section below.
+     */
+    magic?: number;
+    /** Melee/unarmed damage and carrying capacity. */
+    strength?: number;
+    /** Stun track size and drain resistance. */
+    willpower?: number;
+    /** First aid effectiveness; NPC hacking. */
+    logic?: number;
+    /** Defense pool (half, rounded down) and future perception checks. */
+    intuition?: number;
+    /** Social presence -- listed on the sheet now, mechanics to come. */
+    charisma?: number;
+    /** Luck: per-job pool of edge points, burned to push a strike (see edge.ts). */
+    edge?: number;
+    /**
+     * Technomancer talent -- 0 (the default) for everyone else. A resonance
+     * actor is a LIVING PERSONA: they jack into the Matrix with no deck and
+     * no commlink (their brain is the hardware), resonance boosts every
+     * Matrix pool, and ALL Matrix damage lands on their real stun track --
+     * there's no deck to brick, only a mind to burn.
+     */
+    resonance?: number;
+    /**
+     * Physical adept: magic channeled into the body instead of spells.
+     * Counts as Awakened (auras read them, assensing works) but they cast
+     * NOTHING -- not even from formulas -- and cannot astrally project.
+     * Instead, half their magic (rounded down) is added to their meat-plane
+     * attack and defense pools: improved reflexes, killing hands.
+     */
+    adept?: boolean;
+}
 export interface IPlayerConstructorConfig {
     playerName: string;
     startLocation: Room;
     lifestyleChoices?: LifestyleChoices;
+    combat?: ICombatAttributes;
 }
 export declare class Player extends AbstractPlayer {
     readonly _playerName: string;
@@ -19,7 +96,86 @@ export declare class Player extends AbstractPlayer {
     protected _lifestyleChoices: LifestyleChoices;
     protected logger: Logger;
     private _currency;
+    activeCallPartner?: Player;
+    runningSilent: boolean;
+    combatOpponent?: Player;
+    lastExchangeAt: number;
+    inExchange: boolean;
+    autoStance: FightStance;
+    surrendered: boolean;
+    archetypeName?: string;
+    weaponDrawn: boolean;
+    plane: Plane;
+    bodyRoom?: Room;
+    simMode?: SimMode;
+    astralTicks: number;
+    activeDeck?: Item;
+    /** The best working cyberdeck carried (bricked ones don't count). */
+    getCyberdeck(): Item | undefined;
+    /** Any deck at all, bricked included -- for status displays and repair. */
+    getAnyCyberdeck(): Item | undefined;
+    arOffline: boolean;
+    /**
+     * 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(): Item | undefined;
+    /**
+     * Defense against a PAN intrusion: Logic + the master's firewall
+     * (+2 while running silent -- a hidden PAN must be FOUND first).
+     */
+    getPanDefensePool(): number;
+    get matrixTaken(): number;
+    get maxMatrixBoxes(): number;
+    /** Routes Matrix combat damage into the jacked-in deck's hardware track. */
+    takeMatrixDamage(boxes: number): number;
+    get matrixCrashed(): boolean;
+    /** The deck track, same rendering as conditionSummary(). */
+    matrixSummary(): string;
+    /**
+     * 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: Player): boolean;
+    waitingForLull: boolean;
+    body: number;
+    agility: number;
+    reaction: number;
+    combatSkill: number;
+    magic: number;
+    strength: number;
+    willpower: number;
+    logic: number;
+    intuition: number;
+    charisma: number;
+    edge: number;
+    resonance: number;
+    adept: boolean;
+    edgeRemaining: number;
+    edgeBoostArmed: boolean;
+    private _damageTaken;
+    private _stunTaken;
     constructor(config: IPlayerConstructorConfig);
+    /** Explicit per-skill ratings; anything absent resolves via skillRating(). */
+    skills: Partial<Record<SkillName, number>>;
+    karma: number;
+    /**
+     * 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: SkillName): number;
+    /**
+     * 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(): SkillName;
     private initializeEquipment;
     get name(): string;
     get currentLocation(): Room;
@@ -33,6 +189,8 @@ export declare class Player extends AbstractPlayer {
     addInventory(item: Item): void;
     removeInventory(item: Item): boolean;
     equip(item: Item): string;
+    /** True for the hand slots that hold a wielded weapon. */
+    static isWeaponSlot(group: keyof PlayerEquipment, slot: string): boolean;
     unequip(input: string): string;
     determineEquipmentSlot(input: string): {
         group: keyof PlayerEquipment;
@@ -50,6 +208,126 @@ export declare class Player extends AbstractPlayer {
     }) => void;
     enterRoom(room: Room): void;
     leaveRoom(): void;
+    private static readonly ARMOR_CATEGORIES;
+    get maxConditionBoxes(): number;
+    get damageTaken(): number;
+    get maxStunBoxes(): number;
+    get stunTaken(): number;
+    /**
+     * 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(): number;
+    /** Dead: the physical track is full. */
+    isDown(): boolean;
+    /** Out cold: the stun track is full (but not necessarily dead). */
+    isUnconscious(): boolean;
+    /** Out of the fight either way -- the gate every action should check. */
+    isIncapacitated(): boolean;
+    /** Applies damage boxes; returns the number actually taken. */
+    takeDamage(boxes: number): number;
+    /**
+     * 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: number): number;
+    /**
+     * 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: number): {
+        stun: number;
+        overflow: number;
+    };
+    /** e.g. "■■■□□□□□□□ (3/10)" */
+    conditionSummary(): string;
+    /** Clears stun boxes; returns how many were actually recovered. */
+    healStun(boxes: number): number;
+    /** The stun track, same rendering as conditionSummary(). */
+    stunSummary(): string;
+    /**
+     * 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(): {
+        name: string;
+        damage: number;
+        poolBonus: number;
+    };
+    /** The weapon riding in a hand slot, drawn or holstered. */
+    getCarriedWeapon(): Item | null;
+    /** Draws the carried weapon; returns it, or null if nothing changed
+     * (unarmed, or already in hand). */
+    drawWeapon(): Item | null;
+    /** Stows the drawn weapon; returns it, or null if nothing changed. */
+    stowWeapon(): Item | null;
+    /** Total soak dice from every equipped armor-category item. */
+    getArmorValue(): number;
+    getAttackPool(): number;
+    /**
+     * 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(): number;
+    getDefensePool(): number;
+    getSoakPool(): number;
+    /**
+     * 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(): number;
+    /**
+     * 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(): number;
+    /** New job, fresh luck -- and a fresh seat at the negotiating table. */
+    refreshEdge(): void;
+    /** Base casting dice for a mundane casting from a formula/grimoire. */
+    private static readonly BASE_MAGIC_POOL;
+    /** 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(): boolean;
+    /** Technomancer: living persona -- the Matrix without a deck (see ICombatAttributes.resonance). */
+    isTechnomancer(): boolean;
+    private _sustainedArmor;
+    get sustainedArmor(): number;
+    setSustainedArmor(bonus: number): void;
+    get sustainingPenalty(): number;
+    astralPerceiving: boolean;
+    sneaking: boolean;
+    haggledThisJob: boolean;
+    cameFrom?: {
+        room: string;
+        back: string;
+    };
+    socialMarks: Set<string>;
+    /** The best Focus item on this actor, if any -- scales casting power. */
+    getBestFocus(): Item | undefined;
+    getMagicPool(): number;
+    /**
+     * 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: string): boolean;
+    /**
+     * The gate for attempting magic at all (ward bypass included): innate
+     * talent, or any magic gear.
+     */
+    isCaster(): boolean;
     get lifestyleChoices(): LifestyleChoices;
     set lifestyleChoices(choices: LifestyleChoices);
     get currency(): number;