@maka/maka-cli 5.119.0 → 5.121.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/catalog-data.d.ts

@@ -20,11 +20,211 @@
  * gear -- these strings are what the player reads, and what an NPC's
  * swag briefing quotes.
  */
-export declare const CATALOG_VERSION = 12;
-export interface ICatalogItem {
+import type { SkillName } from '../models/player.js';
+import type { AugBonusKind } from '../augmentations.js';
+export declare const CATALOG_VERSION = 13;
+export type CatalogKind = 'gear' | 'quality' | 'spell' | 'augmentation' | 'metatype';
+/** The skill a weapon is fired or swung with. The last four have no engine
+ *  skill yet (SkillName); the engine falls back per models/player.ts. */
+export type WeaponSkill = 'pistols' | 'automatics' | 'longarms' | 'archery' | 'blades' | 'clubs' | 'unarmed' | 'heavy-weapons' | 'throwing-weapons' | 'exotic-melee' | 'exotic-ranged';
+/** The p.185 Range Table rows (utilities/range.ts carries the metres). */
+export type WeaponRange = 'taser' | 'holdout' | 'light-pistol' | 'heavy-pistol' | 'machine-pistol' | 'smg' | 'assault-rifle' | 'shotgun' | 'sniper' | 'lmg' | 'mmg' | 'bow' | 'light-crossbow' | 'medium-crossbow' | 'heavy-crossbow' | 'thrown-knife' | 'grenade' | 'melee';
+export type FireMode = 'SS' | 'SA' | 'BF' | 'FA';
+export type AmmoFeed = 'c' | 'm' | 'cy' | 'b' | 'd' | 'ml' | 'belt';
+/** SR5 p.417-418, p.432: hold-outs have no mounts; tasers top only;
+ *  pistols, machine pistols and SMGs top + barrel; rifles, shotguns and
+ *  heavy weapons all three. One accessory per mount. */
+export type MountPoint = 'top' | 'under' | 'barrel';
+/** A weapon's combat values, the book's table row (p.421-431, p.435). */
+export interface ICatalogWeapon {
+    skill: WeaponSkill;
+    /** The BARE number, never the smartlink/laser parenthetical (the shooter
+     *  supplies those -- Player.getAttackLimit). 'physical' is the table's own
+     *  word for "use the Physical limit" (shock gloves, throwing knives). */
+    accuracy: number | 'physical';
+    /** The flat part of the DV: 8 for "8P", 2 for "(STR+2)P". */
+    dv: number;
+    /** Melee: DV = this attribute + dv. */
+    dvAttribute?: 'strength';
+    damageType: 'P' | 'S';
+    /** "(e)": electricity, Stun by canon (p.170-171). */
+    electric?: true;
+    /** Armor penetration, <= 0 for the usual, > 0 where the book prints "+". 0 for "--". */
+    ap: number;
+    reach?: number;
+    modes?: FireMode[];
+    /** Recoil compensation as the table prints it ("RC (1)" -> 1). Data until
+     *  a recoil model exists. */
+    rc?: number;
+    ammo?: {
+        rounds: number;
+        feed: AmmoFeed;
+    };
+    range?: WeaponRange;
+    /** Grenades: the blast falls off this much per metre. */
+    blast?: number;
+    /** The accessory seats this gun has. Absent = none (hold-outs). */
+    mounts?: MountPoint[];
+    /** Accessories fitted at the factory, by identifier. They occupy no
+     *  mount. Identifiers, not slugs: 'smartgun-internal', 'laser-sight',
+     *  'silencer', 'gas-vent-2', 'folding-stock', 'shock-pad',
+     *  'imaging-scope', 'grenade-launcher'. */
+    builtIn?: string[];
+}
+/** Ammunition (p.433-434): how a loaded round shifts the gun's line. */
+export interface ICatalogAmmo {
+    dvMod: number;
+    apMod: number;
+    /** Stun rounds. Absent = the gun's own damage type. */
+    damageType?: 'S';
+    electric?: true;
+    note?: string;
+}
+export type ModKind = 'vision' | 'audio' | 'armor' | 'trodes' | 'weapon';
+/** Something worn: armor (p.436-438) and/or capacity for mods (p.443-445). */
+export interface ICatalogWearable {
+    /** The piece's own Armor rating. Only the highest worn piece counts (p.169). */
+    armor?: number;
+    /** A "+" accessory (helmet, shield): adds to the worn piece, capped by
+     *  Strength (p.169, p.438). */
+    armorBonus?: number;
+    /** How much it holds (goggles 4, helmet 6). */
+    capacity?: number;
+    /** What may be fitted into it. */
+    holds?: ModKind[];
+    /** Concealability modifier for what is worn under it (lined coat -2).
+     *  Data only: the engine has no concealment test yet. */
+    concealment?: number;
+}
+/** A Matrix device (p.438-439). Device Rating is NUMERIC. */
+export interface ICatalogDevice {
+    deviceRating: number;
+    /** Cyberdecks: the p.227 attribute array, highest first as the book prints it. */
+    attack?: number;
+    sleaze?: number;
+    dataProcessing?: number;
+    firewall?: number;
+    /** Running-program limit (p.227). */
+    programs?: number;
+}
+/** A drone or vehicle (SR5 p.466, Rigger 5.0 p.126-149). A value stays a
+ *  string only where the book prints two figures ("4/2" on/off-road,
+ *  "1G/1W" two travel modes, "--" for an immobile frame). */
+export interface ICatalogVehicle {
+    handling: number | string;
+    speed: number | string;
+    acceleration: number | string;
+    body: number;
+    armor: number;
+    pilot: number;
+    sensor: number;
+    seats?: number;
+    /** A weapon mount: the drone can be armed (Player.droneArmed). */
+    mount?: 'standard' | 'heavy';
+    /** Rigger 5.0 p.145: an anthroform's monitor is 8 + (Body/2). */
+    anthro?: boolean;
+}
+/** A modification that is FITTED into something else (fit.ts). */
+export interface ICatalogMod {
+    kind: ModKind;
+    /** Wearable capacity it uses (vision/audio/armor/trodes, p.444-445). */
+    capacityCost?: number;
+    /** Weapon accessories: the mounts it may take (p.432). */
+    mount?: MountPoint[];
+    /** An accessory that itself holds mods (imaging scope: Capacity 3). */
+    capacity?: number;
+    /** Weapon classes it refuses: a silencer fits no revolver or shotgun (p.432). */
+    excludes?: ('shotgun' | 'revolver')[];
+}
+export type EffectPool = AugBonusKind | 'pan-defense' | 'matrix-soak' | 'biofeedback' | 'toxin' | 'climbing';
+export type EffectLimit = 'physical' | 'mental' | 'social' | 'accuracy';
+export type EffectAttribute = 'body' | 'agility' | 'reaction' | 'strength' | 'willpower' | 'logic' | 'intuition' | 'charisma' | 'edge' | 'magic' | 'resonance' | 'reach' | 'armor-bonus';
+export type EffectMatrixAttribute = 'attack' | 'sleaze' | 'dataProcessing' | 'firewall' | 'damage';
+/** A capability is a flag the engine asks for by key (Player.hasCapability). */
+export type EffectCapability = 'dni' | 'smartlink' | 'smartgun' | 'low-light' | 'thermographic' | 'no-fog' | 'silenced' | 'full-body' | 'autopicker' | 'maglock-opposed';
+/**
+ * A modifier the row grants while it applies. `value` is a NUMBER, never a
+ * string: every reader adds it, and a string would need parsing at each
+ * one and would drift in the web's seed. `scaleBy` multiplies it by the
+ * row's `ratingValue` (rating), the cast Force (force) or the hits of a
+ * sustained spell (hits). `when` defaults by kind: a wearable's effects
+ * apply worn, a weapon's held, a program's running, a data soft's stored,
+ * a mod's fitted, an augmentation's installed, a quality's held.
+ */
+export type ICatalogEffect = {
+    type: 'dice';
+    category: 'skills';
+    property: SkillName;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'dice';
+    category: 'pools';
+    property: EffectPool;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'limit';
+    category: 'limits';
+    property: EffectLimit;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'attribute';
+    category: 'attributes';
+    property: EffectAttribute;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'attribute';
+    category: 'matrix';
+    property: EffectMatrixAttribute;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'initiative';
+    category: 'pools';
+    property: 'dice' | 'score';
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+} | {
+    type: 'flag';
+    category: 'capability';
+    property: EffectCapability;
+    value: number;
+    scaleBy?: EffectScale;
+    when?: EffectWhen;
+    only?: string;
+};
+export type EffectScale = 'rating' | 'force' | 'hits';
+export type EffectWhen = 'worn' | 'held' | 'carried' | 'running' | 'stored' | 'fitted' | 'installed' | 'held-quality' | 'sustained';
+/** Every kind shares this. */
+export interface ICatalogBase {
+    /** Absent = 'gear'. */
+    kind?: CatalogKind;
+    /** Unique across the whole collection, every kind. Qualities, spells,
+     *  augmentations and metatypes use their existing `key`. */
     slug: string;
     name: string;
     description: string;
+    page?: string;
+    approx?: boolean;
+    effects?: ICatalogEffect[];
+}
+export interface ICatalogItem extends ICatalogBase {
+    kind?: 'gear';
     category: string;
     rating: string;
     size: string;
@@ -34,9 +234,84 @@ export interface ICatalogItem {
     weight: number;
     price: number;
     availability: number;
-    page?: string;
-    approx?: boolean;
     legality?: 'R' | 'F';
     stats?: string;
+    /** The SR5 Rating / Force / Capacity the NAME carries ("Medkit (Rating 3)"
+     *  -> 3). What `scaleBy: 'rating'` multiplies by. */
+    ratingValue?: number;
+    weapon?: ICatalogWeapon;
+    ammo?: ICatalogAmmo;
+    wearable?: ICatalogWearable;
+    device?: ICatalogDevice;
+    vehicle?: ICatalogVehicle;
+    mod?: ICatalogMod;
+    /**
+     * WHAT "use" SHOULD SAY when the generic "Nothing special happens." would
+     * read as broken (user, 2026-09-03: a Lockpick Set at a pickable door
+     * giving that line is confusing, not a shrug). Only for gear whose NAME
+     * implies a specific action that lives at a DIFFERENT verb -- a Lockpick
+     * Set means "pick", not "use". Absent = the generic line stays; most
+     * gear needs no hint at all. Read by Item.use() (models/item.ts).
+     */
+    useHint?: string;
+}
+export type Metatype = 'human' | 'elf' | 'dwarf' | 'ork' | 'troll';
+export interface ICatalogQuality extends ICatalogBase {
+    kind: 'quality';
+    quality: {
+        polarity: 'positive' | 'negative';
+        karma: number;
+        maxRating?: number;
+        retired?: string;
+        requires?: 'awakened' | 'mundane' | 'caster-or-technomancer';
+        requiresQuality?: string;
+        requiresMetatype?: Metatype[];
+    };
+}
+export interface ICatalogSpell extends ICatalogBase {
+    kind: 'spell';
+    spell: {
+        category: 'Combat' | 'Detection' | 'Health' | 'Illusion' | 'Manipulation';
+        type: 'mana' | 'physical';
+        range: 'LOS' | 'LOS(A)' | 'touch';
+        duration: 'I' | 'S' | 'P';
+        drainOffset: number;
+        soak?: 'willpower' | 'body' | 'armor';
+        stun?: boolean;
+        area?: boolean;
+        touch?: boolean;
+    };
+}
+export interface ICatalogAugmentation extends ICatalogBase {
+    kind: 'augmentation';
+    augmentation: {
+        ware: 'cyberware' | 'bioware';
+        essence: number;
+        cost: number;
+        wakeLine: string;
+        excludes?: string[];
+        avail?: number;
+        legality?: 'R' | 'F';
+        canonCost?: number;
+        canonEssence?: number;
+    };
+}
+export interface ICatalogMetatype extends ICatalogBase {
+    kind: 'metatype';
+    metatype: {
+        attributes: Record<string, {
+            min: number;
+            max: number;
+        }>;
+        sprintMetersPerHit: 1 | 2;
+        lifestyleCostMult?: number;
+    };
 }
+export type ICatalogRow = ICatalogItem | ICatalogQuality | ICatalogSpell | ICatalogAugmentation | ICatalogMetatype;
+/** Gear or not -- the discriminator every consumer of the gear list uses. */
+export declare function isGearRow(r: ICatalogRow): r is ICatalogItem;
 export declare const CATALOG_ITEMS: ICatalogItem[];
+/** THE WHOLE SEED, every kind. Gear today; qualities, spells, augmentations
+ *  and metatypes join it in v14. The loader (utilities/catalog.ts) weighs
+ *  THIS against the server and the cache. */
+export declare const CATALOG_ROWS: ICatalogRow[];