@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/battle/BattleAI.d.ts

@@ -1,40 +0,0 @@
-import type { TypeMatrix } from './TypeMatrix.ts';
-/**
- * An opposing trainer's move and switch decisions, built on `TypeMatrix` - the one piece of
- * genuinely shared knowledge any two battlers agree on - the same way `decideMonsterAI` is
- * built on `FieldOfView`/`Pathfinder` rather than reimplementing sight or movement. Neither
- * function judges anything beyond type matchups; a game's own damage formula, status
- * conditions, and move priority are free to override the choice this suggests, the same way
- * a game is free to ignore `decideMonsterAI`'s step and hand-roll a boss's own behaviour.
- */
-/**
- * Picks the move whose type is most effective against `opponentTypes`, ties keeping the
- * first candidate; `null` for an empty list.
- *
- * @example
- * ```ts
- * import { chooseMove, chooseSwitch, TypeMatrix } from '@datamoc/mw_games/battle';
- *
- * const matrix = new TypeMatrix();
- * matrix.set('fire', 'grass', 2);
- *
- * const moves = [{ type: 'fire' }, { type: 'normal' }];
- * const best = chooseMove(moves, matrix, ['grass']); // the fire move
- *
- * const bench = [{ types: ['water'] }, { types: ['grass'] }];
- * const swapTo = chooseSwitch(['grass'], bench, matrix, ['fire']); // index of the water one
- * ```
- */
-export declare function chooseMove<M extends {
-    type: string;
-}>(moves: readonly M[], matrix: TypeMatrix, opponentTypes: readonly string[], score?: (move: M, opponentTypes: readonly string[]) => number): M | null;
-/**
- * Whether a bench member defends better against `opponentTypes` than whatever is active now.
- *
- * @returns the index into `bench` of the best defensive improvement, or `null` when nothing
- * on the bench is a clear upgrade over staying in
- */
-export declare function chooseSwitch(activeTypes: readonly string[], bench: readonly {
-    types: readonly string[];
-}[], matrix: TypeMatrix, opponentTypes: readonly string[]): number | null;
-//# sourceMappingURL=BattleAI.d.ts.map

package/dist/battle/BattleAI.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BattleAI.d.ts","sourceRoot":"","sources":["../../src/battle/BattleAI.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACpD,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,MAAM,EAAE,EAChC,KAAK,GAAE,CAAC,IAAI,EAAE,CAAC,EAAE,aAAa,EAAE,SAAS,MAAM,EAAE,KAAK,MACf,GACrC,CAAC,GAAG,IAAI,CAeV;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC3B,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,KAAK,EAAE,SAAS;IAAE,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EAAE,EAC9C,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,SAAS,MAAM,EAAE,GAC9B,MAAM,GAAG,IAAI,CAaf"}

package/dist/battle/BattleAI.js

@@ -1,63 +0,0 @@
-/**
- * An opposing trainer's move and switch decisions, built on `TypeMatrix` - the one piece of
- * genuinely shared knowledge any two battlers agree on - the same way `decideMonsterAI` is
- * built on `FieldOfView`/`Pathfinder` rather than reimplementing sight or movement. Neither
- * function judges anything beyond type matchups; a game's own damage formula, status
- * conditions, and move priority are free to override the choice this suggests, the same way
- * a game is free to ignore `decideMonsterAI`'s step and hand-roll a boss's own behaviour.
- */
-/**
- * Picks the move whose type is most effective against `opponentTypes`, ties keeping the
- * first candidate; `null` for an empty list.
- *
- * @example
- * ```ts
- * import { chooseMove, chooseSwitch, TypeMatrix } from '@datamoc/mw_games/battle';
- *
- * const matrix = new TypeMatrix();
- * matrix.set('fire', 'grass', 2);
- *
- * const moves = [{ type: 'fire' }, { type: 'normal' }];
- * const best = chooseMove(moves, matrix, ['grass']); // the fire move
- *
- * const bench = [{ types: ['water'] }, { types: ['grass'] }];
- * const swapTo = chooseSwitch(['grass'], bench, matrix, ['fire']); // index of the water one
- * ```
- */
-export function chooseMove(moves, matrix, opponentTypes, score = (move, types) => matrix.multiplierFor(move.type, types)) {
-    if (moves.length === 0)
-        return null;
-    let best = moves[0];
-    let bestScore = score(best, opponentTypes);
-    for (const move of moves.slice(1)) {
-        const candidateScore = score(move, opponentTypes);
-        if (candidateScore > bestScore) {
-            bestScore = candidateScore;
-            best = move;
-        }
-    }
-    return best;
-}
-/**
- * Whether a bench member defends better against `opponentTypes` than whatever is active now.
- *
- * @returns the index into `bench` of the best defensive improvement, or `null` when nothing
- * on the bench is a clear upgrade over staying in
- */
-export function chooseSwitch(activeTypes, bench, matrix, opponentTypes) {
-    let bestIndex = null;
-    let bestThreat = worstIncoming(activeTypes, matrix, opponentTypes);
-    bench.forEach((candidate, index) => {
-        const threat = worstIncoming(candidate.types, matrix, opponentTypes);
-        if (threat < bestThreat) {
-            bestThreat = threat;
-            bestIndex = index;
-        }
-    });
-    return bestIndex;
-}
-/** the most damaging multiplier any of `attackingTypes` lands against `defendingTypes` */
-function worstIncoming(defendingTypes, matrix, attackingTypes) {
-    return Math.max(...attackingTypes.map((type) => matrix.multiplierFor(type, defendingTypes)));
-}
-//# sourceMappingURL=BattleAI.js.map

package/dist/battle/BattleAI.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BattleAI.js","sourceRoot":"","sources":["../../src/battle/BattleAI.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,UAAU,CACzB,KAAmB,EACnB,MAAkB,EAClB,aAAgC,EAChC,KAAK,GAA0D,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAC9E,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC;IAEvC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEpC,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACpB,IAAI,SAAS,GAAG,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;IAE3C,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;QACnC,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC;QAClD,IAAI,cAAc,GAAG,SAAS,EAAE,CAAC;YAChC,SAAS,GAAG,cAAc,CAAC;YAC3B,IAAI,GAAG,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,IAAI,CAAC;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC3B,WAA8B,EAC9B,KAA8C,EAC9C,MAAkB,EAClB,aAAgC;IAEhC,IAAI,SAAS,GAAkB,IAAI,CAAC;IACpC,IAAI,UAAU,GAAG,aAAa,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;IAEnE,KAAK,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE;QAClC,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;QACrE,IAAI,MAAM,GAAG,UAAU,EAAE,CAAC;YACzB,UAAU,GAAG,MAAM,CAAC;YACpB,SAAS,GAAG,KAAK,CAAC;QACnB,CAAC;IACF,CAAC,CAAC,CAAC;IAEH,OAAO,SAAS,CAAC;AAClB,CAAC;AAED,0FAA0F;AAC1F,SAAS,aAAa,CACrB,cAAiC,EACjC,MAAkB,EAClB,cAAiC;IAEjC,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;AAC9F,CAAC"}

package/dist/battle/BattleStats.d.ts

@@ -1,45 +0,0 @@
-/**
- * A per-run battle statistics breakdown by category and unit type - recruits, recalls,
- * advances, kills, deaths, damage dealt, damage taken - the shape Wesnoth's own
- * statistics dialog shows and a bare `core.PlayerStats<T>` cannot give a game for free,
- * since `T` there is an opaque summary the game must already know how to combine. Here
- * the categories and the per-unit-type breakdown are the primitive: a game records one
- * event at a time as it happens and reads either a category's total or its breakdown by
- * unit type, then folds `toJSON()` into a `core.RunHistory` entry or a `core.PlayerStats`
- * total the way any other run summary would.
- *
- * @example
- * ```ts
- * import { BattleStats } from '@datamoc/mw_games/battle';
- *
- * const stats = new BattleStats();
- * stats.record('kills', 'orc-grunt');
- * stats.record('kills', 'orc-grunt');
- * stats.record('damageDealt', 'elvish-archer', 12);
- *
- * console.log(stats.total('kills')); // 2
- * console.log(stats.breakdown('kills')); // [{ unitType: 'orc-grunt', count: 2 }]
- * ```
- */
-export type BattleStatCategory = 'recruits' | 'recalls' | 'advances' | 'kills' | 'deaths' | 'damageDealt' | 'damageTaken';
-export declare class BattleStats {
-    private counts;
-    /** adds `amount` (default 1) to a category's count for one unit type */
-    record(category: BattleStatCategory, unitType: string, amount?: number): void;
-    /** one category's count for one unit type; 0 for a combination nothing has recorded yet */
-    forType(category: BattleStatCategory, unitType: string): number;
-    /** a category's total across every unit type */
-    total(category: BattleStatCategory): number;
-    /** every unit type a category has recorded, with its count - the rows a stats screen breaks a category into */
-    breakdown(category: BattleStatCategory): readonly {
-        unitType: string;
-        count: number;
-    }[];
-    toJSON(): {
-        counts: [BattleStatCategory, [string, number][]][];
-    };
-    static fromJSON(data: {
-        counts: [BattleStatCategory, [string, number][]][];
-    }): BattleStats;
-}
-//# sourceMappingURL=BattleStats.d.ts.map

package/dist/battle/BattleStats.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BattleStats.d.ts","sourceRoot":"","sources":["../../src/battle/BattleStats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,kBAAkB,GAC7B,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,GAAG,aAAa,CAAC;AAE1F,qBAAa,WAAW;IACvB,OAAO,CAAC,MAAM,CAAsD;IAEpE,wEAAwE;IACxE,MAAM,CAAC,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,SAAI,GAAG,IAAI,CAIvE;IAED,2FAA2F;IAC3F,OAAO,CAAC,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;IAED,gDAAgD;IAChD,KAAK,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAM1C;IAED,+GAA+G;IAC/G,SAAS,CAAC,QAAQ,EAAE,kBAAkB,GAAG,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAGtF;IAED,MAAM,IAAI;QAAE,MAAM,EAAE,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;KAAE,CAE/D;IAED,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,CAAC,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,EAAE,CAAA;KAAE,GAAG,WAAW,CAIzF;CACD"}

package/dist/battle/BattleStats.js

@@ -1,63 +0,0 @@
-/**
- * A per-run battle statistics breakdown by category and unit type - recruits, recalls,
- * advances, kills, deaths, damage dealt, damage taken - the shape Wesnoth's own
- * statistics dialog shows and a bare `core.PlayerStats<T>` cannot give a game for free,
- * since `T` there is an opaque summary the game must already know how to combine. Here
- * the categories and the per-unit-type breakdown are the primitive: a game records one
- * event at a time as it happens and reads either a category's total or its breakdown by
- * unit type, then folds `toJSON()` into a `core.RunHistory` entry or a `core.PlayerStats`
- * total the way any other run summary would.
- *
- * @example
- * ```ts
- * import { BattleStats } from '@datamoc/mw_games/battle';
- *
- * const stats = new BattleStats();
- * stats.record('kills', 'orc-grunt');
- * stats.record('kills', 'orc-grunt');
- * stats.record('damageDealt', 'elvish-archer', 12);
- *
- * console.log(stats.total('kills')); // 2
- * console.log(stats.breakdown('kills')); // [{ unitType: 'orc-grunt', count: 2 }]
- * ```
- */
-export class BattleStats {
-    constructor() {
-        this.counts = new Map();
-    }
-    /** adds `amount` (default 1) to a category's count for one unit type */
-    record(category, unitType, amount = 1) {
-        const byType = this.counts.get(category) ?? new Map();
-        byType.set(unitType, (byType.get(unitType) ?? 0) + amount);
-        this.counts.set(category, byType);
-    }
-    /** one category's count for one unit type; 0 for a combination nothing has recorded yet */
-    forType(category, unitType) {
-        return this.counts.get(category)?.get(unitType) ?? 0;
-    }
-    /** a category's total across every unit type */
-    total(category) {
-        const byType = this.counts.get(category);
-        if (!byType)
-            return 0;
-        let sum = 0;
-        for (const count of byType.values())
-            sum += count;
-        return sum;
-    }
-    /** every unit type a category has recorded, with its count - the rows a stats screen breaks a category into */
-    breakdown(category) {
-        const byType = this.counts.get(category);
-        return byType ? [...byType.entries()].map(([unitType, count]) => ({ unitType, count })) : [];
-    }
-    toJSON() {
-        return { counts: [...this.counts].map(([category, byType]) => [category, [...byType]]) };
-    }
-    static fromJSON(data) {
-        const stats = new BattleStats();
-        for (const [category, entries] of data.counts)
-            stats.counts.set(category, new Map(entries));
-        return stats;
-    }
-}
-//# sourceMappingURL=BattleStats.js.map

package/dist/battle/BattleStats.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"BattleStats.js","sourceRoot":"","sources":["../../src/battle/BattleStats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAKH,MAAM,OAAO,WAAW;IAAxB;QACS,WAAM,GAAG,IAAI,GAAG,EAA2C,CAAC;IAsCrE,CAAC;IApCA,wEAAwE;IACxE,MAAM,CAAC,QAA4B,EAAE,QAAgB,EAAE,MAAM,GAAG,CAAC;QAChE,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,GAAG,EAAkB,CAAC;QACtE,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IAED,2FAA2F;IAC3F,OAAO,CAAC,QAA4B,EAAE,QAAgB;QACrD,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED,gDAAgD;IAChD,KAAK,CAAC,QAA4B;QACjC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzC,IAAI,CAAC,MAAM;YAAE,OAAO,CAAC,CAAC;QACtB,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,KAAK,MAAM,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE;YAAE,GAAG,IAAI,KAAK,CAAC;QAClD,OAAO,GAAG,CAAC;IACZ,CAAC;IAED,+GAA+G;IAC/G,SAAS,CAAC,QAA4B;QACrC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC9F,CAAC;IAED,MAAM;QACL,OAAO,EAAE,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1F,CAAC;IAED,MAAM,CAAC,QAAQ,CAAC,IAA4D;QAC3E,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC;QAChC,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,IAAI,CAAC,MAAM;YAAE,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;QAC5F,OAAO,KAAK,CAAC;IACd,CAAC;CACD"}

package/dist/battle/Evolution.d.ts

@@ -1,34 +0,0 @@
-/**
- * Capture, experience, levelling and evolution as replaceable rules.
- *
- * Experience and levelling are `mwg/actors`' `Progression`, unchanged - a creature is not a
- * different shape from a character. Capture has no shape here at all: it is entirely a
- * game's own formula (a ball's catch rate, a chance based on remaining HP, whatever), so
- * `mwg` supplies nothing for it beyond not getting in the way. Evolution is the one piece
- * worth a shared shape, since "check an ordered list of conditions" is the same problem
- * `mwg/rpg`'s event pages already solve.
- */
-export interface EvolutionRule<S> {
-    at: (level: number) => boolean;
-    into: S;
-}
-/**
- * The last rule whose condition holds at this level, or null when none does - the same
- * "ordered low to high, most-specific-that-matches wins" convention `mwg/rpg`'s event pages
- * use, so a chain authored `[16 -> adult, 32 -> elder]` reaches "elder" at level 40 rather
- * than getting stuck on the first threshold it ever crossed.
- *
- * @example
- * ```ts
- * import { checkEvolution, type EvolutionRule } from '@datamoc/mw_games/battle';
- *
- * const rules: EvolutionRule<string>[] = [
- *   { at: (level) => level >= 16, into: 'adult-form' },
- *   { at: (level) => level >= 32, into: 'elder-form' },
- * ];
- *
- * const evolvedInto = checkEvolution(rules, 40); // 'elder-form'
- * ```
- */
-export declare function checkEvolution<S>(rules: readonly EvolutionRule<S>[], level: number): S | null;
-//# sourceMappingURL=Evolution.d.ts.map

package/dist/battle/Evolution.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evolution.d.ts","sourceRoot":"","sources":["../../src/battle/Evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC/B,IAAI,EAAE,CAAC,CAAC;CACR;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,aAAa,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,CAM7F"}

package/dist/battle/Evolution.js

@@ -1,37 +0,0 @@
-/**
- * Capture, experience, levelling and evolution as replaceable rules.
- *
- * Experience and levelling are `mwg/actors`' `Progression`, unchanged - a creature is not a
- * different shape from a character. Capture has no shape here at all: it is entirely a
- * game's own formula (a ball's catch rate, a chance based on remaining HP, whatever), so
- * `mwg` supplies nothing for it beyond not getting in the way. Evolution is the one piece
- * worth a shared shape, since "check an ordered list of conditions" is the same problem
- * `mwg/rpg`'s event pages already solve.
- */
-/**
- * The last rule whose condition holds at this level, or null when none does - the same
- * "ordered low to high, most-specific-that-matches wins" convention `mwg/rpg`'s event pages
- * use, so a chain authored `[16 -> adult, 32 -> elder]` reaches "elder" at level 40 rather
- * than getting stuck on the first threshold it ever crossed.
- *
- * @example
- * ```ts
- * import { checkEvolution, type EvolutionRule } from '@datamoc/mw_games/battle';
- *
- * const rules: EvolutionRule<string>[] = [
- *   { at: (level) => level >= 16, into: 'adult-form' },
- *   { at: (level) => level >= 32, into: 'elder-form' },
- * ];
- *
- * const evolvedInto = checkEvolution(rules, 40); // 'elder-form'
- * ```
- */
-export function checkEvolution(rules, level) {
-    let match = null;
-    for (const rule of rules) {
-        if (rule.at(level))
-            match = rule.into;
-    }
-    return match;
-}
-//# sourceMappingURL=Evolution.js.map

package/dist/battle/Evolution.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Evolution.js","sourceRoot":"","sources":["../../src/battle/Evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,cAAc,CAAI,KAAkC,EAAE,KAAa;IAClF,IAAI,KAAK,GAAa,IAAI,CAAC;IAC3B,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QAC1B,IAAI,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YAAE,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;IACvC,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/battle/Field.d.ts

@@ -1,36 +0,0 @@
-/**
- * Named conditions the battle itself carries - weather, terrain, a screen like Reflect -
- * rather than any one creature's own `StatBlock`. Every modifier-shaped thing `mwg/actors`
- * has (equipment, buffs, status effects) is scoped to one creature; this is the one place a
- * condition can apply to everyone without a game copying it onto every combatant's own
- * stat block by hand. Deliberately just a named, optionally-timed flag set - it does
- * nothing on its own, the same way `mwg` supplies no move-damage formula: a game reads
- * `field.has('rain')` itself wherever a formula needs to know.
- *
- * @example
- * ```ts
- * import { Field } from '@datamoc/mw_games/battle';
- *
- * const field = new Field();
- * field.set({ id: 'rain', duration: 5 });
- *
- * if (field.has('rain')) console.log('water moves are boosted');
- * field.advance(); // one round passes; duration counts down, expiring at 0
- * ```
- */
-export interface FieldCondition {
-    id: string;
-    /** rounds remaining; omit for indefinite, cleared only by an explicit `clear` */
-    duration?: number;
-}
-export declare class Field {
-    private conditions;
-    set(condition: FieldCondition): void;
-    has(id: string): boolean;
-    get(id: string): FieldCondition | undefined;
-    clear(id: string): void;
-    get active(): readonly FieldCondition[];
-    /** ticks every timed condition down by `rounds`, clearing any that just ran out */
-    advance(rounds?: number): void;
-}
-//# sourceMappingURL=Field.d.ts.map

package/dist/battle/Field.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../src/battle/Field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,cAAc;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,iFAAiF;IACjF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,KAAK;IACjB,OAAO,CAAC,UAAU,CAAqC;IAEvD,GAAG,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI,CAEnC;IAED,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEvB;IAED,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,cAAc,GAAG,SAAS,CAE1C;IAED,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEtB;IAED,IAAI,MAAM,IAAI,SAAS,cAAc,EAAE,CAEtC;IAED,mFAAmF;IACnF,OAAO,CAAC,MAAM,SAAI,GAAG,IAAI,CAOxB;CACD"}

package/dist/battle/Field.js

@@ -1,31 +0,0 @@
-export class Field {
-    constructor() {
-        this.conditions = new Map();
-    }
-    set(condition) {
-        this.conditions.set(condition.id, { ...condition });
-    }
-    has(id) {
-        return this.conditions.has(id);
-    }
-    get(id) {
-        return this.conditions.get(id);
-    }
-    clear(id) {
-        this.conditions.delete(id);
-    }
-    get active() {
-        return [...this.conditions.values()];
-    }
-    /** ticks every timed condition down by `rounds`, clearing any that just ran out */
-    advance(rounds = 1) {
-        for (const [id, condition] of this.conditions) {
-            if (condition.duration === undefined)
-                continue;
-            condition.duration -= rounds;
-            if (condition.duration <= 0)
-                this.conditions.delete(id);
-        }
-    }
-}
-//# sourceMappingURL=Field.js.map

package/dist/battle/Field.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Field.js","sourceRoot":"","sources":["../../src/battle/Field.ts"],"names":[],"mappings":"AA0BA,MAAM,OAAO,KAAK;IAAlB;QACS,eAAU,GAAG,IAAI,GAAG,EAA0B,CAAC;IA+BxD,CAAC;IA7BA,GAAG,CAAC,SAAyB;QAC5B,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,SAAS,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,GAAG,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,GAAG,CAAC,EAAU;QACb,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IAED,KAAK,CAAC,EAAU;QACf,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IAED,IAAI,MAAM;QACT,OAAO,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,CAAC;IACtC,CAAC;IAED,mFAAmF;IACnF,OAAO,CAAC,MAAM,GAAG,CAAC;QACjB,KAAK,MAAM,CAAC,EAAE,EAAE,SAAS,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAC/C,IAAI,SAAS,CAAC,QAAQ,KAAK,SAAS;gBAAE,SAAS;YAE/C,SAAS,CAAC,QAAQ,IAAI,MAAM,CAAC;YAC7B,IAAI,SAAS,CAAC,QAAQ,IAAI,CAAC;gBAAE,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACzD,CAAC;IACF,CAAC;CACD"}

package/dist/battle/Hooks.d.ts

@@ -1,39 +0,0 @@
-import { HookRegistry } from '../core/Hooks.ts';
-/**
- * A battle-scoped place for passive effects to run code, not just push a number - the seam
- * `mwg/actors`' `StatBlock` modifiers and `applyStatusEffect` do not cover, since both are
- * numeric-only. An ability reacting to "this creature switched in," a held item reacting to
- * "this creature was hit," or a sleep/paralysis status answering "can this creature act this
- * turn" are all the same shape: register a handler for a named event, and a game's battle
- * loop calls it at the right moment.
- *
- * `mwg` names no events of its own beyond the strings a game passes - `'switchIn'`, `'hit'`,
- * `'turnStart'`, whatever a game's battle loop actually fires. A "can this creature act"
- * check is a plain convention on top of this, not special-cased: a handler mutates a shared
- * `context` object (`{ skip: false }`, say) the same way any other side effect would, and
- * the battle loop reads it back after `emit` returns.
- *
- * The registry itself is `core.HookRegistry`, shared with `roguelike.CombatHooks`. What is
- * battle-specific is only the shape of what a handler receives: the creature the event is
- * about, plus that optional shared context.
- *
- * @example
- * ```ts
- * import { BattleHooks } from '@datamoc/mw_games/battle';
- *
- * const hooks = new BattleHooks<{ name: string }>();
- * const paralysis = {};
- *
- * hooks.on('turnStart', (creature, context) => {
- *   if ((context as { skip: boolean }).skip === undefined) return;
- *   (context as { skip: boolean }).skip = true; // this creature cannot act this turn
- * }, paralysis);
- *
- * const context = { skip: false };
- * hooks.emit('turnStart', { name: 'hero' }, context);
- * ```
- */
-export declare class BattleHooks<C> extends HookRegistry<[creature: C, context?: unknown]> {
-}
-export type { Hook as BattleHook } from '../core/Hooks.ts';
-//# sourceMappingURL=Hooks.d.ts.map

package/dist/battle/Hooks.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hooks.d.ts","sourceRoot":"","sources":["../../src/battle/Hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,WAAW,CAAC,CAAC,CAAE,SAAQ,YAAY,CAAC,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;CAAG;AAErF,YAAY,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/battle/Hooks.js

@@ -1,38 +0,0 @@
-import { HookRegistry } from '../core/Hooks.js';
-/**
- * A battle-scoped place for passive effects to run code, not just push a number - the seam
- * `mwg/actors`' `StatBlock` modifiers and `applyStatusEffect` do not cover, since both are
- * numeric-only. An ability reacting to "this creature switched in," a held item reacting to
- * "this creature was hit," or a sleep/paralysis status answering "can this creature act this
- * turn" are all the same shape: register a handler for a named event, and a game's battle
- * loop calls it at the right moment.
- *
- * `mwg` names no events of its own beyond the strings a game passes - `'switchIn'`, `'hit'`,
- * `'turnStart'`, whatever a game's battle loop actually fires. A "can this creature act"
- * check is a plain convention on top of this, not special-cased: a handler mutates a shared
- * `context` object (`{ skip: false }`, say) the same way any other side effect would, and
- * the battle loop reads it back after `emit` returns.
- *
- * The registry itself is `core.HookRegistry`, shared with `roguelike.CombatHooks`. What is
- * battle-specific is only the shape of what a handler receives: the creature the event is
- * about, plus that optional shared context.
- *
- * @example
- * ```ts
- * import { BattleHooks } from '@datamoc/mw_games/battle';
- *
- * const hooks = new BattleHooks<{ name: string }>();
- * const paralysis = {};
- *
- * hooks.on('turnStart', (creature, context) => {
- *   if ((context as { skip: boolean }).skip === undefined) return;
- *   (context as { skip: boolean }).skip = true; // this creature cannot act this turn
- * }, paralysis);
- *
- * const context = { skip: false };
- * hooks.emit('turnStart', { name: 'hero' }, context);
- * ```
- */
-export class BattleHooks extends HookRegistry {
-}
-//# sourceMappingURL=Hooks.js.map

package/dist/battle/Hooks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hooks.js","sourceRoot":"","sources":["../../src/battle/Hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,OAAO,WAAe,SAAQ,YAA8C;CAAG"}

package/dist/battle/Move.d.ts

@@ -1,45 +0,0 @@
-/**
- * A move, as data: what it costs, what it targets, and its effects - whatever those are.
- * `mwg` does not interpret `effects`; a game's own battle loop reads it and decides what
- * happens, the same way `mwg/actors`' `Modifier` carries a stat and a number without the
- * framework knowing what "poisoned" means.
- */
-export interface Move<TEffect = unknown> {
-    id: string;
-    type: string;
-    /** energy, PP, an action point cost - whatever the game's resource is */
-    cost?: number;
-    /** a game-defined target shape: 'self', 'single-enemy', 'all-allies', anything else */
-    target: string;
-    effects?: TEffect;
-}
-export interface BattleAction<C = unknown> {
-    actor: C;
-    speed: number;
-    /** higher acts first regardless of speed; ties fall back to speed */
-    priority?: number;
-}
-/**
- * Turn order by speed, with move priority overriding it - one round's worth of ordering,
- * not a persistent queue. `mwg/roguelike`'s `Scheduler` already covers continuous
- * energy-cost time for a dungeon; a battle round picks everyone's action first and then
- * needs only this, a single stable sort.
- *
- * @example
- * ```ts
- * import { battleOrder, type BattleAction } from '@datamoc/mw_games/battle';
- *
- * const actions: BattleAction<string>[] = [
- *   { actor: 'hero', speed: 12 },
- *   { actor: 'wolf', speed: 18 },
- *   { actor: 'hero-item', speed: 12, priority: 1 }, // items go first regardless of speed
- * ];
- *
- * const order = battleOrder(actions).map((a) => a.actor); // ['hero-item', 'wolf', 'hero']
- * ```
- */
-export declare function battleOrder<A extends {
-    speed: number;
-    priority?: number;
-}>(actions: readonly A[]): A[];
-//# sourceMappingURL=Move.d.ts.map

package/dist/battle/Move.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Move.d.ts","sourceRoot":"","sources":["../../src/battle/Move.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,WAAW,IAAI,CAAC,OAAO,GAAG,OAAO;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IAEb,yEAAyE;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,uFAAuF;IACvF,MAAM,EAAE,MAAM,CAAC;IAEf,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,GAAG,OAAO;IACxC,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IAEd,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAEtG"}

package/dist/battle/Move.js

@@ -1,23 +0,0 @@
-/**
- * Turn order by speed, with move priority overriding it - one round's worth of ordering,
- * not a persistent queue. `mwg/roguelike`'s `Scheduler` already covers continuous
- * energy-cost time for a dungeon; a battle round picks everyone's action first and then
- * needs only this, a single stable sort.
- *
- * @example
- * ```ts
- * import { battleOrder, type BattleAction } from '@datamoc/mw_games/battle';
- *
- * const actions: BattleAction<string>[] = [
- *   { actor: 'hero', speed: 12 },
- *   { actor: 'wolf', speed: 18 },
- *   { actor: 'hero-item', speed: 12, priority: 1 }, // items go first regardless of speed
- * ];
- *
- * const order = battleOrder(actions).map((a) => a.actor); // ['hero-item', 'wolf', 'hero']
- * ```
- */
-export function battleOrder(actions) {
-    return [...actions].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0) || b.speed - a.speed);
-}
-//# sourceMappingURL=Move.js.map

package/dist/battle/Move.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Move.js","sourceRoot":"","sources":["../../src/battle/Move.ts"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,WAAW,CAAiD,OAAqB;IAChG,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC;AAChG,CAAC"}

package/dist/battle/Party.d.ts

@@ -1,32 +0,0 @@
-/**
- * A roster with a limited active lineup and unlimited off-party storage - a box, a PC,
- * whatever a game calls it. Active slots can hold a gap (a fainted, withdrawn, or simply
- * empty slot); storage is just an overflow list in the order creatures were added to it.
- *
- * @example
- * ```ts
- * import { Party, Creature, type Species } from '@datamoc/mw_games/battle';
- *
- * const species: Species = { id: 'fireling', types: ['fire'], baseStats: { attack: 10 } };
- * const party = new Party<Creature>(3); // 3 active slots
- *
- * party.add(new Creature({ species })); // fills an active slot, then overflows to storage
- * console.log(party.members.length, party.boxed.length);
- * ```
- */
-export declare class Party<C> {
-    private active;
-    private storage;
-    constructor(activeSize: number);
-    get members(): readonly (C | null)[];
-    get boxed(): readonly C[];
-    /** the first empty active slot, or storage when the lineup is full */
-    add(creature: C): void;
-    /** moves an active member to storage, leaving its slot empty */
-    store(index: number): void;
-    /** brings a boxed creature into a specific active slot, swapping out whatever was there */
-    withdraw(storageIndex: number, activeSlot: number): void;
-    /** every active, non-empty member */
-    get activeMembers(): C[];
-}
-//# sourceMappingURL=Party.d.ts.map

package/dist/battle/Party.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Party.d.ts","sourceRoot":"","sources":["../../src/battle/Party.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,KAAK,CAAC,CAAC;IACnB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,OAAO,CAAW;IAE1B,YAAY,UAAU,EAAE,MAAM,EAE7B;IAED,IAAI,OAAO,IAAI,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAEnC;IAED,IAAI,KAAK,IAAI,SAAS,CAAC,EAAE,CAExB;IAED,sEAAsE;IACtE,GAAG,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,CAIrB;IAED,gEAAgE;IAChE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAMzB;IAED,2FAA2F;IAC3F,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CASvD;IAED,qCAAqC;IACrC,IAAI,aAAa,IAAI,CAAC,EAAE,CAEvB;CACD"}