@datamoc/mw_games 0.1.1

package/dist/actors/Appearances.js

@@ -0,0 +1,50 @@
+import * as Random from '../core/Random.js';
+/**
+ * Deals each kind a distinct label from a shuffled copy of the pool - pure, so a game
+ * that wants the shuffle scoped (one seed per run, say) wraps it in `Random.withSeed`.
+ */
+export function assignAppearances(table) {
+    if (table.labels.length < table.kinds.length) {
+        throw new Error(`not enough appearances: ${table.kinds.length} kinds but only ${table.labels.length} labels`);
+    }
+    const pool = [...table.labels];
+    for (let i = pool.length - 1; i > 0; i--) {
+        const j = Random.int(0, i + 1);
+        [pool[i], pool[j]] = [pool[i], pool[j]];
+    }
+    const out = new Map();
+    table.kinds.forEach((kind, index) => out.set(kind, pool[index]));
+    return out;
+}
+export class Appearances {
+    constructor(tables) {
+        this.assigned = new Map();
+        this.tables = tables;
+    }
+    /** the look `kind` wears this run in `category`, drawing the shuffle on first ask */
+    appearanceOf(category, kind) {
+        let categoryMap = this.assigned.get(category);
+        if (!categoryMap) {
+            const table = this.tables[category];
+            if (!table)
+                throw new Error(`no such appearance category: "${category}"`);
+            categoryMap = assignAppearances(table);
+            this.assigned.set(category, categoryMap);
+        }
+        const label = categoryMap.get(kind);
+        if (label === undefined)
+            throw new Error(`"${kind}" is not in appearance category "${category}"`);
+        return label;
+    }
+    toJSON() {
+        return { assigned: [...this.assigned].map(([category, map]) => [category, [...map]]) };
+    }
+    /** rebuilds appearances from save data - the tables themselves are supplied fresh, the same as `QuestLog` definitions */
+    static fromJSON(tables, data) {
+        const appearances = new Appearances(tables);
+        for (const [category, entries] of data.assigned)
+            appearances.assigned.set(category, new Map(entries));
+        return appearances;
+    }
+}
+//# sourceMappingURL=Appearances.js.map

package/dist/actors/Appearances.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appearances.js","sourceRoot":"","sources":["../../src/actors/Appearances.ts"],"names":[],"mappings":"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"}

package/dist/actors/Charges.d.ts

@@ -0,0 +1,31 @@
+/**
+ * A resource that refills on its own as turns pass - a wand's limited charges regenerating
+ * one every few turns - distinct from a straight spendable pool (mana spent per cast,
+ * restored only by an explicit event, which a `StatBlock` stat already covers on its own).
+ * What that alone cannot express is "this refills automatically over time," so `Charges`
+ * carries its own regeneration progress instead of leaning on `TurnClock` for it - a charge
+ * either has or does not have enough banked turns to regenerate, which is exactly the kind
+ * of running total a class holds more naturally than a callback would.
+ */
+export interface ChargesOptions {
+    /** the most this can ever hold */
+    max: number;
+    /** starting amount; defaults to `max` (a fresh wand starts full) */
+    current?: number;
+    /** turns of banked time needed to regenerate one charge */
+    regenRate: number;
+}
+export declare class Charges {
+    readonly max: number;
+    private regenRate;
+    private value;
+    private progress;
+    constructor(options: ChargesOptions);
+    get current(): number;
+    canAfford(cost: number): boolean;
+    /** @returns false, spending nothing, if `cost` is not affordable right now */
+    spend(cost: number): boolean;
+    /** banks `turns` of regeneration time, converting whole `regenRate`-sized chunks into charges */
+    advance(turns?: number): void;
+}
+//# sourceMappingURL=Charges.d.ts.map

package/dist/actors/Charges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Charges.d.ts","sourceRoot":"","sources":["../../src/actors/Charges.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,cAAc;IAC9B,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IAEZ,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,2DAA2D;IAC3D,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,OAAO;IACnB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,QAAQ,CAAK;IAErB,YAAY,OAAO,EAAE,cAAc,EAIlC;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED,8EAA8E;IAC9E,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAI3B;IAED,iGAAiG;IACjG,OAAO,CAAC,KAAK,SAAI,GAAG,IAAI,CAWvB;CACD"}

package/dist/actors/Charges.js

@@ -0,0 +1,35 @@
+export class Charges {
+    constructor(options) {
+        this.progress = 0;
+        this.max = options.max;
+        this.regenRate = options.regenRate;
+        this.value = options.current ?? options.max;
+    }
+    get current() {
+        return this.value;
+    }
+    canAfford(cost) {
+        return this.value >= cost;
+    }
+    /** @returns false, spending nothing, if `cost` is not affordable right now */
+    spend(cost) {
+        if (!this.canAfford(cost))
+            return false;
+        this.value -= cost;
+        return true;
+    }
+    /** banks `turns` of regeneration time, converting whole `regenRate`-sized chunks into charges */
+    advance(turns = 1) {
+        if (this.value >= this.max)
+            return;
+        this.progress += turns;
+        while (this.progress >= this.regenRate && this.value < this.max) {
+            this.progress -= this.regenRate;
+            this.value++;
+        }
+        //full again: no point banking further progress towards a charge there is no room for
+        if (this.value >= this.max)
+            this.progress = 0;
+    }
+}
+//# sourceMappingURL=Charges.js.map

package/dist/actors/Charges.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Charges.js","sourceRoot":"","sources":["../../src/actors/Charges.ts"],"names":[],"mappings":"AAoBA,MAAM,OAAO,OAAO;IAMnB,YAAY,OAAuB;QAF3B,aAAQ,GAAG,CAAC,CAAC;QAGpB,IAAI,CAAC,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;QACvB,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC;QACnC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC;IAC7C,CAAC;IAED,IAAI,OAAO;QACV,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED,SAAS,CAAC,IAAY;QACrB,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;IAC3B,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,IAAY;QACjB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;QACxC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC;QACnB,OAAO,IAAI,CAAC;IACb,CAAC;IAED,iGAAiG;IACjG,OAAO,CAAC,KAAK,GAAG,CAAC;QAChB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG;YAAE,OAAO;QAEnC,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC;QACvB,OAAO,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACjE,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,SAAS,CAAC;YAChC,IAAI,CAAC,KAAK,EAAE,CAAC;QACd,CAAC;QAED,qFAAqF;QACrF,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,GAAG;YAAE,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;IAC/C,CAAC;CACD"}

package/dist/actors/Equipment.d.ts

@@ -0,0 +1,40 @@
+import type { StatBlock, Modifier } from './StatBlock.ts';
+export interface EquippableItem {
+    /** applied to the wearer's StatBlock while equipped, removed together on unequip */
+    modifiers?: Modifier[];
+}
+export interface EquipmentOptions<Slot extends string, Item extends EquippableItem> {
+    /**
+     * Whether whatever is currently in `slot` refuses to come off - a cursed ring, a
+     * quest-bound relic. A locked slot also refuses a swap, since swapping starts by
+     * removing what is there.
+     */
+    locked?: (slot: Slot, item: Item) => boolean;
+}
+/**
+ * Equipment slots, defined per game rather than fixed by the framework - `'leftHand'` and
+ * `'rightHand'`, or `'weapon'` / `'armor'` / `'amulet'`, or a dozen Diablo-style slots.
+ * Whatever an item's `modifiers` are, equipping it applies them to the given `StatBlock` and
+ * unequipping removes exactly those - tagged by the item itself as their `source`, so two
+ * rings of the same kind never remove each other's bonus by mistake.
+ */
+export declare class EquipmentSlots<Slot extends string, Item extends EquippableItem> {
+    private readonly names;
+    private worn;
+    private stats;
+    private isSlotLocked;
+    constructor(slots: readonly Slot[], stats?: StatBlock | null, options?: EquipmentOptions<Slot, Item>);
+    get(slot: Slot): Item | undefined;
+    /** true when the slot holds something that refuses to come off - check this, since a refused `unequip` is otherwise indistinguishable from an empty slot */
+    isLocked(slot: Slot): boolean;
+    /**
+     * @returns the item that was previously in this slot, if any - or undefined without
+     * changing anything when the slot is locked
+     */
+    equip(slot: Slot, item: Item): Item | undefined;
+    /** @returns the removed item, or undefined for an empty slot - or a locked one, which stays put */
+    unequip(slot: Slot): Item | undefined;
+    get slots(): readonly Slot[];
+    private assertSlot;
+}
+//# sourceMappingURL=Equipment.d.ts.map

package/dist/actors/Equipment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equipment.d.ts","sourceRoot":"","sources":["../../src/actors/Equipment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC9B,oFAAoF;IACpF,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB,CAAC,IAAI,SAAS,MAAM,EAAE,IAAI,SAAS,cAAc;IACjF;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC;CAC7C;AAED;;;;;;GAMG;AACH,qBAAa,cAAc,CAAC,IAAI,SAAS,MAAM,EAAE,IAAI,SAAS,cAAc;IAC3E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAC1C,OAAO,CAAC,IAAI,CAAyB;IACrC,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,YAAY,CAAsC;IAE1D,YAAY,KAAK,EAAE,SAAS,IAAI,EAAE,EAAE,KAAK,GAAE,SAAS,GAAG,IAAW,EAAE,OAAO,GAAE,gBAAgB,CAAC,IAAI,EAAE,IAAI,CAAM,EAI7G;IAED,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAEhC;IAED,4JAA4J;IAC5J,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAG5B;IAED;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAU9C;IAED,mGAAmG;IACnG,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAQpC;IAED,IAAI,KAAK,IAAI,SAAS,IAAI,EAAE,CAE3B;IAED,OAAO,CAAC,UAAU;CAGlB"}

package/dist/actors/Equipment.js

@@ -0,0 +1,57 @@
+/**
+ * Equipment slots, defined per game rather than fixed by the framework - `'leftHand'` and
+ * `'rightHand'`, or `'weapon'` / `'armor'` / `'amulet'`, or a dozen Diablo-style slots.
+ * Whatever an item's `modifiers` are, equipping it applies them to the given `StatBlock` and
+ * unequipping removes exactly those - tagged by the item itself as their `source`, so two
+ * rings of the same kind never remove each other's bonus by mistake.
+ */
+export class EquipmentSlots {
+    constructor(slots, stats = null, options = {}) {
+        this.worn = new Map();
+        this.names = new Set(slots);
+        this.stats = stats;
+        this.isSlotLocked = options.locked ?? (() => false);
+    }
+    get(slot) {
+        return this.worn.get(slot);
+    }
+    /** true when the slot holds something that refuses to come off - check this, since a refused `unequip` is otherwise indistinguishable from an empty slot */
+    isLocked(slot) {
+        const item = this.worn.get(slot);
+        return item !== undefined && this.isSlotLocked(slot, item);
+    }
+    /**
+     * @returns the item that was previously in this slot, if any - or undefined without
+     * changing anything when the slot is locked
+     */
+    equip(slot, item) {
+        this.assertSlot(slot);
+        if (this.isLocked(slot))
+            return undefined;
+        const previous = this.unequip(slot);
+        this.worn.set(slot, item);
+        for (const modifier of item.modifiers ?? []) {
+            this.stats?.addModifier({ ...modifier, source: item });
+        }
+        return previous;
+    }
+    /** @returns the removed item, or undefined for an empty slot - or a locked one, which stays put */
+    unequip(slot) {
+        const item = this.worn.get(slot);
+        if (!item)
+            return undefined;
+        if (this.isSlotLocked(slot, item))
+            return undefined;
+        this.worn.delete(slot);
+        this.stats?.removeModifiersFrom(item);
+        return item;
+    }
+    get slots() {
+        return [...this.names];
+    }
+    assertSlot(slot) {
+        if (!this.names.has(slot))
+            throw new Error(`no such equipment slot: "${slot}"`);
+    }
+}
+//# sourceMappingURL=Equipment.js.map

package/dist/actors/Equipment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equipment.js","sourceRoot":"","sources":["../../src/actors/Equipment.ts"],"names":[],"mappings":"AAgBA;;;;;;GAMG;AACH,MAAM,OAAO,cAAc;IAM1B,YAAY,KAAsB,EAAE,KAAK,GAAqB,IAAI,EAAE,OAAO,GAAiC,EAAE;QAJtG,SAAI,GAAG,IAAI,GAAG,EAAc,CAAC;QAKpC,IAAI,CAAC,KAAK,GAAG,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;IACrD,CAAC;IAED,GAAG,CAAC,IAAU;QACb,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IAED,4JAA4J;IAC5J,QAAQ,CAAC,IAAU;QAClB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjC,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC5D,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,IAAU,EAAE,IAAU;QAC3B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QACtB,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,OAAO,SAAS,CAAC;QAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAEpC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC1B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,SAAS,IAAI,EAAE,EAAE,CAAC;YAC7C,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE,GAAG,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,QAAQ,CAAC;IACjB,CAAC;IAED,mGAAmG;IACnG,OAAO,CAAC,IAAU;QACjB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI;YAAE,OAAO,SAAS,CAAC;QAC5B,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC;YAAE,OAAO,SAAS,CAAC;QAEpD,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,KAAK,EAAE,mBAAmB,CAAC,IAAI,CAAC,CAAC;QACtC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,IAAI,KAAK;QACR,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAEO,UAAU,CAAC,IAAU;QAC5B,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,IAAI,GAAG,CAAC,CAAC;IACjF,CAAC;CACD"}

package/dist/actors/Inventory.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Items a character carries: stacking, weight, and containers within containers.
+ *
+ * A slot holds a quantity of one kind of item rather than one entry per item, which is what
+ * stacking means in practice - forty arrows are one inventory slot, not forty. Weight and
+ * capacity are optional: a game that does not track carry weight simply never sets a
+ * capacity, and every check trivially passes.
+ */
+export interface InventoryItem {
+    /** identifies the kind of item; two stackable entries with the same id merge */
+    id: string;
+    quantity: number;
+    stackable?: boolean;
+    weight?: number;
+    /** an unidentified potion, a cursed ring the player does not yet know is cursed */
+    identified?: boolean;
+    cursed?: boolean;
+    blessed?: boolean;
+    /** an enchantment or upgrade level above the item's base, such as a weapon's "+2" */
+    level?: number;
+    /** a named affix - an enchantment, glyph, augment or curse id from an `AffixTable` */
+    affix?: string;
+    /** remaining durability; omit for an item that cannot wear out at all */
+    durability?: number;
+    maxDurability?: number;
+    /** a container - a bag, a chest - whose own weight adds to whatever is inside it */
+    contents?: Inventory;
+}
+export interface InventoryOptions {
+    /** total weight this inventory can hold; omit for no limit */
+    capacity?: number;
+}
+export declare class Inventory {
+    private slots;
+    readonly capacity?: number;
+    constructor(options?: InventoryOptions);
+    get items(): readonly InventoryItem[];
+    get totalWeight(): number;
+    private weightOf;
+    find(id: string): InventoryItem | undefined;
+    /**
+     * Adds an item, merging into an existing stack when both are stackable.
+     *
+     * @returns false when a capacity is set and this would exceed it - nothing is added
+     */
+    add(item: InventoryItem): boolean;
+    /** removes up to `quantity` (default: the whole stack); the slot disappears once empty */
+    remove(id: string, quantity?: number): void;
+}
+//# sourceMappingURL=Inventory.d.ts.map

package/dist/actors/Inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Inventory.d.ts","sourceRoot":"","sources":["../../src/actors/Inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,aAAa;IAC7B,gFAAgF;IAChF,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,mFAAmF;IACnF,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,qFAAqF;IACrF,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,sFAAsF;IACtF,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,oFAAoF;IACpF,QAAQ,CAAC,EAAE,SAAS,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAChC,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,SAAS;IACrB,OAAO,CAAC,KAAK,CAAuB;IACpC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,YAAY,OAAO,GAAE,gBAAqB,EAEzC;IAED,IAAI,KAAK,IAAI,SAAS,aAAa,EAAE,CAEpC;IAED,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,OAAO,CAAC,QAAQ;IAIhB,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE1C;IAED;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAehC;IAED,0FAA0F;IAC1F,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAO1C;CACD"}

package/dist/actors/Inventory.js

@@ -0,0 +1,56 @@
+/**
+ * Items a character carries: stacking, weight, and containers within containers.
+ *
+ * A slot holds a quantity of one kind of item rather than one entry per item, which is what
+ * stacking means in practice - forty arrows are one inventory slot, not forty. Weight and
+ * capacity are optional: a game that does not track carry weight simply never sets a
+ * capacity, and every check trivially passes.
+ */
+export class Inventory {
+    constructor(options = {}) {
+        this.slots = [];
+        this.capacity = options.capacity;
+    }
+    get items() {
+        return this.slots;
+    }
+    get totalWeight() {
+        return this.slots.reduce((sum, item) => sum + this.weightOf(item), 0);
+    }
+    weightOf(item) {
+        return (item.weight ?? 0) * item.quantity + (item.contents?.totalWeight ?? 0);
+    }
+    find(id) {
+        return this.slots.find((item) => item.id === id);
+    }
+    /**
+     * Adds an item, merging into an existing stack when both are stackable.
+     *
+     * @returns false when a capacity is set and this would exceed it - nothing is added
+     */
+    add(item) {
+        if (this.capacity !== undefined && this.totalWeight + this.weightOf(item) > this.capacity) {
+            return false;
+        }
+        if (item.stackable) {
+            const existing = this.slots.find((s) => s.id === item.id && s.stackable);
+            if (existing) {
+                existing.quantity += item.quantity;
+                return true;
+            }
+        }
+        this.slots.push({ ...item });
+        return true;
+    }
+    /** removes up to `quantity` (default: the whole stack); the slot disappears once empty */
+    remove(id, quantity) {
+        const index = this.slots.findIndex((item) => item.id === id);
+        if (index === -1)
+            return;
+        const item = this.slots[index];
+        item.quantity -= quantity ?? item.quantity;
+        if (item.quantity <= 0)
+            this.slots.splice(index, 1);
+    }
+}
+//# sourceMappingURL=Inventory.js.map

package/dist/actors/Inventory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Inventory.js","sourceRoot":"","sources":["../../src/actors/Inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAiCH,MAAM,OAAO,SAAS;IAIrB,YAAY,OAAO,GAAqB,EAAE;QAHlC,UAAK,GAAoB,EAAE,CAAC;QAInC,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,CAAC;IAED,IAAI,KAAK;QACR,OAAO,IAAI,CAAC,KAAK,CAAC;IACnB,CAAC;IAED,IAAI,WAAW;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IACvE,CAAC;IAEO,QAAQ,CAAC,IAAmB;QACnC,OAAO,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,IAAI,CAAC,CAAC,CAAC;IAC/E,CAAC;IAED,IAAI,CAAC,EAAU;QACd,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAC,IAAmB;QACtB,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS,IAAI,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC3F,OAAO,KAAK,CAAC;QACd,CAAC;QAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC;YACzE,IAAI,QAAQ,EAAE,CAAC;gBACd,QAAQ,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;gBACnC,OAAO,IAAI,CAAC;YACb,CAAC;QACF,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,0FAA0F;IAC1F,MAAM,CAAC,EAAU,EAAE,QAAiB;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QAC7D,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,OAAO;QAEzB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC/B,IAAI,CAAC,QAAQ,IAAI,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC;QAC3C,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC;YAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACrD,CAAC;CACD"}

package/dist/actors/ItemState.d.ts

@@ -0,0 +1,21 @@
+import type { InventoryItem } from './Inventory.ts';
+/**
+ * The three item-shaped states `Inventory` only had fields for, not behaviour: identification,
+ * an enchantment/upgrade level, and durability that wears down with use. Small, focused
+ * functions over a plain `InventoryItem` - the same size of primitive `skillCheck` already is -
+ * rather than a class, since none of the three need to remember anything beyond the item.
+ */
+/** reveals an item's real nature - a potion's true effect, a ring's curse - once identified */
+export declare function identify(item: InventoryItem): void;
+/** raises (or, given a negative delta, lowers) an item's enchantment/upgrade level */
+export declare function enchant(item: InventoryItem, delta: number): number;
+/**
+ * Wears an item down by `amount`. An item with no `maxDurability` set cannot wear out at all
+ * and this is a no-op - durability is opt-in per item, not a hidden default every item pays for.
+ *
+ * @returns true once the item's durability has reached zero and it should break
+ */
+export declare function damageItem(item: InventoryItem, amount: number): boolean;
+/** restores durability, capped at `maxDurability`; a no-op for an item with none set */
+export declare function repairItem(item: InventoryItem, amount: number): void;
+//# sourceMappingURL=ItemState.d.ts.map

package/dist/actors/ItemState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemState.d.ts","sourceRoot":"","sources":["../../src/actors/ItemState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD;;;;;GAKG;AAEH,+FAA+F;AAC/F,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,CAElD;AAED,sFAAsF;AACtF,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAKvE;AAED,wFAAwF;AACxF,wBAAgB,UAAU,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAGpE"}

package/dist/actors/ItemState.js

@@ -0,0 +1,34 @@
+/**
+ * The three item-shaped states `Inventory` only had fields for, not behaviour: identification,
+ * an enchantment/upgrade level, and durability that wears down with use. Small, focused
+ * functions over a plain `InventoryItem` - the same size of primitive `skillCheck` already is -
+ * rather than a class, since none of the three need to remember anything beyond the item.
+ */
+/** reveals an item's real nature - a potion's true effect, a ring's curse - once identified */
+export function identify(item) {
+    item.identified = true;
+}
+/** raises (or, given a negative delta, lowers) an item's enchantment/upgrade level */
+export function enchant(item, delta) {
+    item.level = (item.level ?? 0) + delta;
+    return item.level;
+}
+/**
+ * Wears an item down by `amount`. An item with no `maxDurability` set cannot wear out at all
+ * and this is a no-op - durability is opt-in per item, not a hidden default every item pays for.
+ *
+ * @returns true once the item's durability has reached zero and it should break
+ */
+export function damageItem(item, amount) {
+    if (item.maxDurability === undefined)
+        return false;
+    item.durability = Math.max(0, (item.durability ?? item.maxDurability) - amount);
+    return item.durability <= 0;
+}
+/** restores durability, capped at `maxDurability`; a no-op for an item with none set */
+export function repairItem(item, amount) {
+    if (item.maxDurability === undefined)
+        return;
+    item.durability = Math.min(item.maxDurability, (item.durability ?? item.maxDurability) + amount);
+}
+//# sourceMappingURL=ItemState.js.map

package/dist/actors/ItemState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ItemState.js","sourceRoot":"","sources":["../../src/actors/ItemState.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AAEH,+FAA+F;AAC/F,MAAM,UAAU,QAAQ,CAAC,IAAmB;IAC3C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;AACxB,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,OAAO,CAAC,IAAmB,EAAE,KAAa;IACzD,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;IACvC,OAAO,IAAI,CAAC,KAAK,CAAC;AACnB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,IAAmB,EAAE,MAAc;IAC7D,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAEnD,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,CAAC;IAChF,OAAO,IAAI,CAAC,UAAU,IAAI,CAAC,CAAC;AAC7B,CAAC;AAED,wFAAwF;AACxF,MAAM,UAAU,UAAU,CAAC,IAAmB,EAAE,MAAc;IAC7D,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS;QAAE,OAAO;IAC7C,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC,CAAC;AAClG,CAAC"}

package/dist/actors/Loot.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A weighted drop table for what a monster leaves behind - the same shape as
+ * `mwg/world`'s `EncounterTable`, deliberately: both are "roll whether anything happens at
+ * all, then weight-pick which," just naming an item instead of an encounter value. A corpse
+ * as a lootable world object needs no code of its own beyond this - it is an `Inventory`
+ * placed at the monster's last position, exactly like any other dropped item already is.
+ */
+export interface LootEntry {
+    id: string;
+    weight: number;
+    /** how many of `id` this entry grants; defaults to 1 */
+    quantity?: number;
+}
+export interface LootTable {
+    entries: readonly LootEntry[];
+    /** probability that this table drops anything at all, 0 to 1; defaults to 1 (always) */
+    chance?: number;
+}
+/** @returns what dropped, or null when the roll misses or the table is empty */
+export declare function rollLoot(table: LootTable): {
+    id: string;
+    quantity: number;
+} | null;
+//# sourceMappingURL=Loot.d.ts.map

package/dist/actors/Loot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loot.d.ts","sourceRoot":"","sources":["../../src/actors/Loot.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,SAAS;IACzB,OAAO,EAAE,SAAS,SAAS,EAAE,CAAC;IAE9B,wFAAwF;IACxF,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CASlF"}

package/dist/actors/Loot.js

@@ -0,0 +1,14 @@
+import * as Random from '../core/Random.js';
+/** @returns what dropped, or null when the roll misses or the table is empty */
+export function rollLoot(table) {
+    if (table.entries.length === 0)
+        return null;
+    if (!Random.chance(table.chance ?? 1))
+        return null;
+    const index = Random.weighted(table.entries.map((entry) => entry.weight));
+    if (index === -1)
+        return null;
+    const entry = table.entries[index];
+    return { id: entry.id, quantity: entry.quantity ?? 1 };
+}
+//# sourceMappingURL=Loot.js.map

package/dist/actors/Loot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Loot.js","sourceRoot":"","sources":["../../src/actors/Loot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAuB5C,gFAAgF;AAChF,MAAM,UAAU,QAAQ,CAAC,KAAgB;IACxC,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAEnD,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1E,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO,IAAI,CAAC;IAE9B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IACnC,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;AACxD,CAAC"}

package/dist/actors/Progression.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Levels, experience, and the growth curve between them.
+ *
+ * The curve is a small interface rather than a formula, so it is entirely replaceable: a
+ * game that wants Pokémon-style fast/medium/slow curves, or a flat curve with no cap, or one
+ * read from a spreadsheet, supplies its own `GrowthCurve` and everything else here still
+ * works unchanged.
+ */
+export interface GrowthCurve {
+    /** total experience needed to *reach* this level; level 1 should be 0 */
+    experienceFor(level: number): number;
+    /** the highest level the curve defines; levelling stops here */
+    maxLevel: number;
+}
+/** a curve reaching `maxLevel` at roughly `base * (level - 1) ^ power` total experience */
+export declare function powerCurve(base: number, power: number, maxLevel: number): GrowthCurve;
+export declare class Progression {
+    private curve;
+    level: number;
+    experience: number;
+    constructor(curve: GrowthCurve, start?: {
+        level?: number;
+        experience?: number;
+    });
+    /** experience still needed for the next level; null once the curve's cap is reached */
+    get experienceToNext(): number | null;
+    /** @returns how many levels were gained, 0 if none - a single large gain may span several */
+    addExperience(amount: number): number;
+}
+//# sourceMappingURL=Progression.d.ts.map

package/dist/actors/Progression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Progression.d.ts","sourceRoot":"","sources":["../../src/actors/Progression.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,WAAW;IAC3B,yEAAyE;IACzE,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IAErC,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,2FAA2F;AAC3F,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAKrF;AAED,qBAAa,WAAW;IACvB,OAAO,CAAC,KAAK,CAAc;IAE3B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,KAAK,EAAE,WAAW,EAAE,KAAK,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAO,EAIlF;IAED,uFAAuF;IACvF,IAAI,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAGpC;IAED,6FAA6F;IAC7F,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASpC;CACD"}

package/dist/actors/Progression.js

@@ -0,0 +1,39 @@
+/**
+ * Levels, experience, and the growth curve between them.
+ *
+ * The curve is a small interface rather than a formula, so it is entirely replaceable: a
+ * game that wants Pokémon-style fast/medium/slow curves, or a flat curve with no cap, or one
+ * read from a spreadsheet, supplies its own `GrowthCurve` and everything else here still
+ * works unchanged.
+ */
+/** a curve reaching `maxLevel` at roughly `base * (level - 1) ^ power` total experience */
+export function powerCurve(base, power, maxLevel) {
+    return {
+        maxLevel,
+        experienceFor: (level) => (level <= 1 ? 0 : Math.round(base * Math.pow(level - 1, power))),
+    };
+}
+export class Progression {
+    constructor(curve, start = {}) {
+        this.curve = curve;
+        this.level = start.level ?? 1;
+        this.experience = start.experience ?? this.curve.experienceFor(this.level);
+    }
+    /** experience still needed for the next level; null once the curve's cap is reached */
+    get experienceToNext() {
+        if (this.level >= this.curve.maxLevel)
+            return null;
+        return this.curve.experienceFor(this.level + 1) - this.experience;
+    }
+    /** @returns how many levels were gained, 0 if none - a single large gain may span several */
+    addExperience(amount) {
+        this.experience += amount;
+        let gained = 0;
+        while (this.level < this.curve.maxLevel && this.experience >= this.curve.experienceFor(this.level + 1)) {
+            this.level++;
+            gained++;
+        }
+        return gained;
+    }
+}
+//# sourceMappingURL=Progression.js.map

package/dist/actors/Progression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Progression.js","sourceRoot":"","sources":["../../src/actors/Progression.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,2FAA2F;AAC3F,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,KAAa,EAAE,QAAgB;IACvE,OAAO;QACN,QAAQ;QACR,aAAa,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;KAC1F,CAAC;AACH,CAAC;AAED,MAAM,OAAO,WAAW;IAMvB,YAAY,KAAkB,EAAE,KAAK,GAA4C,EAAE;QAClF,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5E,CAAC;IAED,uFAAuF;IACvF,IAAI,gBAAgB;QACnB,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ;YAAE,OAAO,IAAI,CAAC;QACnD,OAAO,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC;IACnE,CAAC;IAED,6FAA6F;IAC7F,aAAa,CAAC,MAAc;QAC3B,IAAI,CAAC,UAAU,IAAI,MAAM,CAAC;QAE1B,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC;YACxG,IAAI,CAAC,KAAK,EAAE,CAAC;YACb,MAAM,EAAE,CAAC;QACV,CAAC;QACD,OAAO,MAAM,CAAC;IACf,CAAC;CACD"}

package/dist/actors/Resource.d.ts

@@ -0,0 +1,23 @@
+import type { StatBlock } from './StatBlock.ts';
+/**
+ * One spendable cost: `amount` of the `stat` pool, the way a spell costs mana.
+ *
+ * Costs operate on the stat's *base* value - the stored pool - not its modified
+ * total: a buff that raises maximum mana changes the ceiling, not what is left
+ * to spend. Restoring the pool is just `stats.setBase`; only spending needed a
+ * primitive of its own.
+ */
+export interface ResourceCost {
+    stat: string;
+    amount: number;
+}
+/** True when every cost in `cost` is currently affordable, without spending anything. */
+export declare function canAfford(stats: StatBlock, cost: ResourceCost | readonly ResourceCost[]): boolean;
+/**
+ * Spends every cost in `cost` at once, the way `craft` resolves a recipe.
+ *
+ * All or nothing: when any one cost is unaffordable nothing is deducted and
+ * this returns false. A zero cost is always affordable and deducts nothing.
+ */
+export declare function spend(stats: StatBlock, cost: ResourceCost | readonly ResourceCost[]): boolean;
+//# sourceMappingURL=Resource.d.ts.map

package/dist/actors/Resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.d.ts","sourceRoot":"","sources":["../../src/actors/Resource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CACf;AAYD,yFAAyF;AACzF,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,GAAG,OAAO,CAEjG;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,GAAG,OAAO,CAK7F"}

package/dist/actors/Resource.js

@@ -0,0 +1,28 @@
+function all(cost) {
+    const list = Array.isArray(cost) ? cost : [cost];
+    for (const c of list) {
+        if (!Number.isFinite(c.amount) || c.amount < 0) {
+            throw new Error(`a resource cost must be a non-negative number, "${c.stat}" costs ${c.amount}`);
+        }
+    }
+    return list;
+}
+/** True when every cost in `cost` is currently affordable, without spending anything. */
+export function canAfford(stats, cost) {
+    return all(cost).every((c) => stats.base(c.stat) >= c.amount);
+}
+/**
+ * Spends every cost in `cost` at once, the way `craft` resolves a recipe.
+ *
+ * All or nothing: when any one cost is unaffordable nothing is deducted and
+ * this returns false. A zero cost is always affordable and deducts nothing.
+ */
+export function spend(stats, cost) {
+    const list = all(cost);
+    if (!list.every((c) => stats.base(c.stat) >= c.amount))
+        return false;
+    for (const c of list)
+        stats.setBase(c.stat, stats.base(c.stat) - c.amount);
+    return true;
+}
+//# sourceMappingURL=Resource.js.map

package/dist/actors/Resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Resource.js","sourceRoot":"","sources":["../../src/actors/Resource.ts"],"names":[],"mappings":"AAeA,SAAS,GAAG,CAAC,IAA4C;IACxD,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACjD,KAAK,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;QACjG,CAAC;IACF,CAAC;IACD,OAAO,IAAI,CAAC;AACb,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,SAAS,CAAC,KAAgB,EAAE,IAA4C;IACvF,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,KAAK,CAAC,KAAgB,EAAE,IAA4C;IACnF,MAAM,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACvB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrE,KAAK,MAAM,CAAC,IAAI,IAAI;QAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;IAC3E,OAAO,IAAI,CAAC;AACb,CAAC"}