@datamoc/mw_games 0.1.1

package/dist/assets/index.d.ts

@@ -0,0 +1,37 @@
+import { Texture } from 'pixi.js';
+/**
+ * Where a game's assets come from.
+ *
+ * In a built game, `tools/compile-resources` has already turned every asset into a `data:`
+ * URI inside a script that runs before the game does. `resolve` then hands Pixi that URI
+ * instead of a path, which is what lets the page work from `file://` — see the tool for
+ * why plain files next to the page do not.
+ *
+ * During development there is no compiled bundle, so paths are used as they are and the
+ * dev server serves them. Game code says `load('tiles.png')` either way.
+ */
+declare global {
+    interface Window {
+        __MWG_ASSETS__?: Record<string, string>;
+    }
+}
+/** points dev-mode lookups at the folder assets are served from */
+export declare function setBase(path: string): void;
+/** true when running against a compiled bundle rather than a dev server */
+export declare function isCompiled(): boolean;
+export declare function paths(): string[];
+export declare function has(path: string): boolean;
+/** an asset path resolved to something the browser can actually load */
+export declare function resolve(path: string): string;
+/**
+ * Loads assets by path, giving each one an alias equal to its path.
+ *
+ * Load everything a scene needs before creating it; afterwards `texture()` is synchronous,
+ * so game code never has to await in the middle of building a scene.
+ */
+export declare function load(paths: string[]): Promise<void>;
+/** a loaded texture, by the same path it was loaded with */
+export declare function texture(path: string): Texture;
+/** a loaded asset of any other kind, such as parsed JSON */
+export declare function get<T>(path: string): T;
+//# sourceMappingURL=index.d.ts.map

package/dist/assets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/assets/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,OAAO,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;;;;;GAUG;AAEH,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,MAAM;QACf,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACxC;CACD;AAKD,mEAAmE;AACnE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE1C;AAMD,2EAA2E;AAC3E,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED,wBAAgB,KAAK,IAAI,MAAM,EAAE,CAEhC;AAED,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGzC;AAED,wEAAwE;AACxE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW5C;AAED;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzD;AAED,4DAA4D;AAC5D,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAK7C;AAED,4DAA4D;AAC5D,wBAAgB,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAKtC"}

package/dist/assets/index.js

@@ -0,0 +1,62 @@
+import { Assets, Texture } from 'pixi.js';
+/** the base for dev-mode paths, when assets are served rather than compiled in */
+let base = '';
+/** points dev-mode lookups at the folder assets are served from */
+export function setBase(path) {
+    base = path.endsWith('/') || path === '' ? path : path + '/';
+}
+function compiled() {
+    return typeof window === 'undefined' ? undefined : window.__MWG_ASSETS__;
+}
+/** true when running against a compiled bundle rather than a dev server */
+export function isCompiled() {
+    return compiled() !== undefined;
+}
+export function paths() {
+    return Object.keys(compiled() ?? {});
+}
+export function has(path) {
+    const map = compiled();
+    return map ? path in map : true;
+}
+/** an asset path resolved to something the browser can actually load */
+export function resolve(path) {
+    const map = compiled();
+    if (!map)
+        return base + path;
+    const found = map[path];
+    if (found === undefined) {
+        throw new Error(`asset "${path}" is not in this build - check it is under the folder passed to compile-resources`);
+    }
+    return found;
+}
+/**
+ * Loads assets by path, giving each one an alias equal to its path.
+ *
+ * Load everything a scene needs before creating it; afterwards `texture()` is synchronous,
+ * so game code never has to await in the middle of building a scene.
+ */
+export async function load(paths) {
+    const pending = paths.filter((path) => !Assets.cache.has(path));
+    if (pending.length === 0)
+        return;
+    for (const path of pending) {
+        Assets.add({ alias: path, src: resolve(path) });
+    }
+    await Assets.load(pending);
+}
+/** a loaded texture, by the same path it was loaded with */
+export function texture(path) {
+    if (!Assets.cache.has(path)) {
+        throw new Error(`texture "${path}" has not been loaded - pass it to load() first`);
+    }
+    return Assets.get(path);
+}
+/** a loaded asset of any other kind, such as parsed JSON */
+export function get(path) {
+    if (!Assets.cache.has(path)) {
+        throw new Error(`asset "${path}" has not been loaded - pass it to load() first`);
+    }
+    return Assets.get(path);
+}
+//# sourceMappingURL=index.js.map

package/dist/assets/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/assets/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAoB1C,kFAAkF;AAClF,IAAI,IAAI,GAAG,EAAE,CAAC;AAEd,mEAAmE;AACnE,MAAM,UAAU,OAAO,CAAC,IAAY;IACnC,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC;AAC9D,CAAC;AAED,SAAS,QAAQ;IAChB,OAAO,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,cAAc,CAAC;AAC1E,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,UAAU;IACzB,OAAO,QAAQ,EAAE,KAAK,SAAS,CAAC;AACjC,CAAC;AAED,MAAM,UAAU,KAAK;IACpB,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,GAAG,CAAC,IAAY;IAC/B,MAAM,GAAG,GAAG,QAAQ,EAAE,CAAC;IACvB,OAAO,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC;AACjC,CAAC;AAED,wEAAwE;AACxE,MAAM,UAAU,OAAO,CAAC,IAAY;IACnC,MAAM,GAAG,GAAG,QAAQ,EAAE,CAAC;IACvB,IAAI,CAAC,GAAG;QAAE,OAAO,IAAI,GAAG,IAAI,CAAC;IAE7B,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CACd,UAAU,IAAI,mFAAmF,CACjG,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,IAAI,CAAC,KAAe;IACzC,MAAM,OAAO,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;IAChE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO;IAEjC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACjD,CAAC;IACD,MAAM,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;AAC5B,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,OAAO,CAAC,IAAY;IACnC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,YAAY,IAAI,iDAAiD,CAAC,CAAC;IACpF,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,CAAU,IAAI,CAAC,CAAC;AAClC,CAAC;AAED,4DAA4D;AAC5D,MAAM,UAAU,GAAG,CAAI,IAAY;IAClC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,UAAU,IAAI,iDAAiD,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,MAAM,CAAC,GAAG,CAAI,IAAI,CAAC,CAAC;AAC5B,CAAC"}

package/dist/audio/Music.d.ts

@@ -0,0 +1,22 @@
+import { type Playable } from './Playable.ts';
+export interface MusicOptions {
+    volume?: number;
+    create?: (path: string) => Playable;
+}
+/**
+ * Background music with crossfade: switching tracks fades the old one out and the new one
+ * in over the same span, rather than cutting straight from one to the other. Like
+ * `AnimatedSprite`, nothing advances on its own - call `update(dt)` from the scene.
+ */
+export declare class Music {
+    private current;
+    private fades;
+    private create;
+    volume: number;
+    constructor(options?: MusicOptions);
+    /** @param fadeDuration seconds; 0 switches immediately with no crossfade */
+    play(path: string, fadeDuration?: number): void;
+    stop(fadeDuration?: number): void;
+    update(dt: number): void;
+}
+//# sourceMappingURL=Music.d.ts.map

package/dist/audio/Music.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Music.d.ts","sourceRoot":"","sources":["../../src/audio/Music.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAW3D,MAAM,WAAW,YAAY;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;CACpC;AAED;;;;GAIG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,MAAM,CAA6B;IAC3C,MAAM,EAAE,MAAM,CAAC;IAEf,YAAY,OAAO,GAAE,YAAiB,EAGrC;IAED,4EAA4E;IAC5E,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,SAAI,GAAG,IAAI,CA4BzC;IAED,IAAI,CAAC,YAAY,SAAI,GAAG,IAAI,CAU3B;IAED,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAevB;CACD"}

package/dist/audio/Music.js

@@ -0,0 +1,67 @@
+import { createAudio } from './Playable.js';
+/**
+ * Background music with crossfade: switching tracks fades the old one out and the new one
+ * in over the same span, rather than cutting straight from one to the other. Like
+ * `AnimatedSprite`, nothing advances on its own - call `update(dt)` from the scene.
+ */
+export class Music {
+    constructor(options = {}) {
+        this.current = null;
+        this.fades = [];
+        this.volume = options.volume ?? 1;
+        this.create = options.create ?? createAudio;
+    }
+    /** @param fadeDuration seconds; 0 switches immediately with no crossfade */
+    play(path, fadeDuration = 1) {
+        const incoming = this.create(path);
+        incoming.loop = true;
+        const previous = this.current;
+        this.current = incoming;
+        if (fadeDuration <= 0) {
+            incoming.volume = this.volume;
+            void incoming.play();
+            previous?.pause();
+            return;
+        }
+        incoming.volume = 0;
+        void incoming.play();
+        this.fades.push({ audio: incoming, elapsed: 0, duration: fadeDuration, from: 0, to: this.volume, stopAtEnd: false });
+        if (previous) {
+            this.fades.push({
+                audio: previous,
+                elapsed: 0,
+                duration: fadeDuration,
+                from: previous.volume,
+                to: 0,
+                stopAtEnd: true,
+            });
+        }
+    }
+    stop(fadeDuration = 1) {
+        const audio = this.current;
+        if (!audio)
+            return;
+        this.current = null;
+        if (fadeDuration <= 0) {
+            audio.pause();
+            return;
+        }
+        this.fades.push({ audio, elapsed: 0, duration: fadeDuration, from: audio.volume, to: 0, stopAtEnd: true });
+    }
+    update(dt) {
+        //iterate a copy: a fade finishing may not touch the list, but this stays safe if one day it does
+        for (const fade of [...this.fades]) {
+            fade.elapsed += dt;
+            const t = Math.min(1, fade.elapsed / fade.duration);
+            fade.audio.volume = fade.from + (fade.to - fade.from) * t;
+            if (t >= 1) {
+                this.fades.splice(this.fades.indexOf(fade), 1);
+                if (fade.stopAtEnd) {
+                    fade.audio.pause();
+                    fade.audio.currentTime = 0;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=Music.js.map

package/dist/audio/Music.js.map

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

package/dist/audio/Playable.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The surface `mwg/audio` needs from a playing sound - exactly what `HTMLAudioElement`
+ * already provides, named here so a test (or a game with its own audio backend) can supply
+ * a fake without a real `Audio` element existing, which nothing outside a browser can
+ * create.
+ */
+export interface Playable {
+    play(): void | Promise<void>;
+    pause(): void;
+    currentTime: number;
+    volume: number;
+    loop: boolean;
+}
+/** the real thing: an `HTMLAudioElement` pointed at a resolved asset path */
+export declare function createAudio(path: string): Playable;
+//# sourceMappingURL=Playable.d.ts.map

package/dist/audio/Playable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Playable.d.ts","sourceRoot":"","sources":["../../src/audio/Playable.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,QAAQ;IACxB,IAAI,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,KAAK,IAAI,IAAI,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACd;AAED,6EAA6E;AAC7E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAElD"}

package/dist/audio/Playable.js

@@ -0,0 +1,6 @@
+import * as Resources from '../assets/index.js';
+/** the real thing: an `HTMLAudioElement` pointed at a resolved asset path */
+export function createAudio(path) {
+    return new Audio(Resources.resolve(path));
+}
+//# sourceMappingURL=Playable.js.map

package/dist/audio/Playable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Playable.js","sourceRoot":"","sources":["../../src/audio/Playable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,oBAAoB,CAAC;AAgBhD,6EAA6E;AAC7E,MAAM,UAAU,WAAW,CAAC,IAAY;IACvC,OAAO,IAAI,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;AAC3C,CAAC"}

package/dist/audio/Sound.d.ts

@@ -0,0 +1,23 @@
+import { type Playable } from './Playable.ts';
+export interface SoundOptions {
+    /** overlapping instances before the oldest is reused; a footstep needs more than a shout */
+    poolSize?: number;
+    volume?: number;
+    /** creates one playable instance for the resolved path; defaults to a real `Audio` element */
+    create?: (path: string) => Playable;
+}
+/**
+ * A sound effect, pooled so the same clip can overlap itself. A dozen arrows landing in the
+ * same second must not cut each other off, which a single `<audio>` element would - the
+ * next play just steals the oldest of the pool, round-robin, rather than restarting the one
+ * already mid-sound.
+ */
+export declare class Sound {
+    private pool;
+    private next;
+    volume: number;
+    constructor(path: string, options?: SoundOptions);
+    play(): void;
+    stopAll(): void;
+}
+//# sourceMappingURL=Sound.d.ts.map

package/dist/audio/Sound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sound.d.ts","sourceRoot":"","sources":["../../src/audio/Sound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE3D,MAAM,WAAW,YAAY;IAC5B,4FAA4F;IAC5F,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,8FAA8F;IAC9F,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;CACpC;AAED;;;;;GAKG;AACH,qBAAa,KAAK;IACjB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,IAAI,CAAK;IACjB,MAAM,EAAE,MAAM,CAAC;IAEf,YAAY,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,EAKnD;IAED,IAAI,IAAI,IAAI,CAOX;IAED,OAAO,IAAI,IAAI,CAKd;CACD"}

package/dist/audio/Sound.js

@@ -0,0 +1,30 @@
+import { createAudio } from './Playable.js';
+/**
+ * A sound effect, pooled so the same clip can overlap itself. A dozen arrows landing in the
+ * same second must not cut each other off, which a single `<audio>` element would - the
+ * next play just steals the oldest of the pool, round-robin, rather than restarting the one
+ * already mid-sound.
+ */
+export class Sound {
+    constructor(path, options = {}) {
+        this.next = 0;
+        const size = Math.max(1, options.poolSize ?? 4);
+        const create = options.create ?? createAudio;
+        this.volume = options.volume ?? 1;
+        this.pool = Array.from({ length: size }, () => create(path));
+    }
+    play() {
+        const audio = this.pool[this.next];
+        this.next = (this.next + 1) % this.pool.length;
+        audio.volume = this.volume;
+        audio.currentTime = 0;
+        void audio.play();
+    }
+    stopAll() {
+        for (const audio of this.pool) {
+            audio.pause();
+            audio.currentTime = 0;
+        }
+    }
+}
+//# sourceMappingURL=Sound.js.map

package/dist/audio/Sound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sound.js","sourceRoot":"","sources":["../../src/audio/Sound.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAiB,MAAM,eAAe,CAAC;AAW3D;;;;;GAKG;AACH,MAAM,OAAO,KAAK;IAKjB,YAAY,IAAY,EAAE,OAAO,GAAiB,EAAE;QAH5C,SAAI,GAAG,CAAC,CAAC;QAIhB,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,WAAW,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9D,CAAC;IAED,IAAI;QACH,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;QAE/C,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;QACtB,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;IACnB,CAAC;IAED,OAAO;QACN,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC/B,KAAK,CAAC,KAAK,EAAE,CAAC;YACd,KAAK,CAAC,WAAW,GAAG,CAAC,CAAC;QACvB,CAAC;IACF,CAAC;CACD"}

package/dist/audio/index.d.ts

@@ -0,0 +1,7 @@
+export { Sound } from './Sound.ts';
+export type { SoundOptions } from './Sound.ts';
+export { Music } from './Music.ts';
+export type { MusicOptions } from './Music.ts';
+export { createAudio } from './Playable.ts';
+export type { Playable } from './Playable.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/audio/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/audio/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,YAAY,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/audio/index.js

@@ -0,0 +1,4 @@
+export { Sound } from './Sound.js';
+export { Music } from './Music.js';
+export { createAudio } from './Playable.js';
+//# sourceMappingURL=index.js.map

package/dist/audio/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/audio/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/battle/BattleAI.d.ts

@@ -0,0 +1,24 @@
+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 */
+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

@@ -0,0 +1 @@
+{"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;+CAC+C;AAC/C,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

@@ -0,0 +1,47 @@
+/**
+ * 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 */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"BattleAI.js","sourceRoot":"","sources":["../../src/battle/BattleAI.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH;+CAC+C;AAC/C,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,CAAC,cAAiC,EAAE,MAAkB,EAAE,cAAiC;IAC9G,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/Evolution.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+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

@@ -0,0 +1 @@
+{"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;;;;;GAKG;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

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"Evolution.js","sourceRoot":"","sources":["../../src/battle/Evolution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH;;;;;GAKG;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

@@ -0,0 +1,25 @@
+/**
+ * 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.
+ */
+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 one round, clearing any that just ran out */
+    advance(): void;
+}
+//# sourceMappingURL=Field.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Field.d.ts","sourceRoot":"","sources":["../../src/battle/Field.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;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,oFAAoF;IACpF,OAAO,IAAI,IAAI,CAOd;CACD"}

package/dist/battle/Field.js

@@ -0,0 +1,31 @@
+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 one round, clearing any that just ran out */
+    advance() {
+        for (const [id, condition] of this.conditions) {
+            if (condition.duration === undefined)
+                continue;
+            condition.duration -= 1;
+            if (condition.duration <= 0)
+                this.conditions.delete(id);
+        }
+    }
+}
+//# sourceMappingURL=Field.js.map

package/dist/battle/Field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Field.js","sourceRoot":"","sources":["../../src/battle/Field.ts"],"names":[],"mappings":"AAeA,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,oFAAoF;IACpF,OAAO;QACN,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,CAAC,CAAC;YACxB,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

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+export interface BattleHook<C> {
+    event: string;
+    handler: (creature: C, context?: unknown) => void;
+    /** whatever registered this hook - an ability, a held item - for bulk removal via `offSource` */
+    source?: unknown;
+}
+export declare class BattleHooks<C> {
+    private hooks;
+    on(event: string, handler: (creature: C, context?: unknown) => void, source?: unknown): void;
+    /** removes every hook registered with this `source` - a fainted creature's ability leaving */
+    offSource(source: unknown): void;
+    /** runs every handler registered for `event`, in registration order */
+    emit(event: string, creature: C, context?: unknown): void;
+}
+//# sourceMappingURL=Hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Hooks.d.ts","sourceRoot":"","sources":["../../src/battle/Hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,UAAU,CAAC,CAAC;IAC5B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,iGAAiG;IACjG,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,qBAAa,WAAW,CAAC,CAAC;IACzB,OAAO,CAAC,KAAK,CAAuB;IAEpC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,CAE3F;IAED,8FAA8F;IAC9F,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAE/B;IAED,uEAAuE;IACvE,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAIxD;CACD"}

package/dist/battle/Hooks.js

@@ -0,0 +1,20 @@
+export class BattleHooks {
+    constructor() {
+        this.hooks = [];
+    }
+    on(event, handler, source) {
+        this.hooks.push({ event, handler, source });
+    }
+    /** removes every hook registered with this `source` - a fainted creature's ability leaving */
+    offSource(source) {
+        this.hooks = this.hooks.filter((hook) => hook.source !== source);
+    }
+    /** runs every handler registered for `event`, in registration order */
+    emit(event, creature, context) {
+        for (const hook of this.hooks) {
+            if (hook.event === event)
+                hook.handler(creature, context);
+        }
+    }
+}
+//# sourceMappingURL=Hooks.js.map

package/dist/battle/Hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hooks.js","sourceRoot":"","sources":["../../src/battle/Hooks.ts"],"names":[],"mappings":"AAqBA,MAAM,OAAO,WAAW;IAAxB;QACS,UAAK,GAAoB,EAAE,CAAC;IAiBrC,CAAC;IAfA,EAAE,CAAC,KAAa,EAAE,OAAiD,EAAE,MAAgB;QACpF,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED,8FAA8F;IAC9F,SAAS,CAAC,MAAe;QACxB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;IAClE,CAAC;IAED,uEAAuE;IACvE,IAAI,CAAC,KAAa,EAAE,QAAW,EAAE,OAAiB;QACjD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK;gBAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC3D,CAAC;IACF,CAAC;CACD"}

package/dist/battle/Move.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+export declare function battleOrder<A extends {
+    speed: number;
+    priority?: number;
+}>(actions: readonly A[]): A[];
+//# sourceMappingURL=Move.d.ts.map