@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/core/Grid.d.ts

@@ -1,179 +0,0 @@
-/**
- * Bounded-grid indexing: the row-major cell arithmetic and bounds check that every tile, board
- * and hex module ends up writing for itself.
- *
- * Free functions rather than a `Grid` class, deliberately. Every caller already holds a width
- * and height (a level, a board, a skirmish state), and several sit in loops hot enough that
- * allocating a wrapper per call would be the wrong trade. `mwg/roguelike`'s `Level` keeps its
- * own `index`/`inside`/`x`/`y` as one-line forwards to these, so its public shape is unchanged.
- *
- * Out-of-bounds policy is not part of this module either: `cellIndex` does the arithmetic and
- * nothing else, so a loop that has already proved its coordinates pays nothing, while a module
- * that wants to fail loudly (`board/Classics` throws) or to report `-1`
- * (`board/FogOfWar` does) keeps that decision in its own method. `cellInside` is the shared
- * check for callers that have not already proved it.
- *
- * @example
- * ```ts
- * import { cellInside, cellIndex, cellX, cellY, cellKey, cellFromKey } from '@datamoc/mw_games/core';
- * import { NEIGHBOURS4, NEIGHBOURS8, CIRCLE8, euclidean } from '@datamoc/mw_games/core';
- *
- * // a 4x3 board, row-major: y * width + x
- * cellInside(4, 3, 3, 2);        // true, the far corner
- * cellInside(4, 3, 4, 0);        // false, one past the right edge
- * cellIndex(4, 2, 1);            // 6, the cell's slot in a flat array
- * cellX(4, 6);                   // 2, back from that index
- * cellY(4, 6);                   // 1
- *
- * const seen = new Set([cellKey(2, 1)]);   // '2,1', for a Map or a Set
- * cellFromKey('2,1');                      // { x: 2, y: 1 }
- *
- * NEIGHBOURS8.length; // 8, the surrounding cells in row-major order
- * CIRCLE8[0];         // [0, -1], the same ring clockwise from north
- * NEIGHBOURS4.length; // 4, north/east/south/west
- * euclidean({ x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-/**
- * True when `(x, y)` is inside a `width` x `height` grid.
- *
- * Both edges are inclusive of `0` and exclusive of `width`/`height`, so a cell exists if and
- * only if `0 <= x < width` and `0 <= y < height`.
- */
-export declare function cellInside(width: number, height: number, x: number, y: number): boolean;
-/**
- * The row-major index of `(x, y)`: its position in a flat `width * height` array.
- *
- * Deliberately unchecked. Call `cellInside` when the coordinates are not already known to be
- * valid; an out-of-range `x` otherwise lands on a neighbouring row rather than failing, and a
- * negative one on the row before it.
- */
-export declare function cellIndex(width: number, x: number, y: number): number;
-/** The `x` coordinate of a row-major `index` (`cellIndex`'s inverse). */
-export declare function cellX(width: number, index: number): number;
-/** The `y` coordinate of a row-major `index` (`cellIndex`'s inverse). */
-export declare function cellY(width: number, index: number): number;
-/**
- * A stable string key naming one cell, for `Map`/`Set` membership.
- *
- * `'x,y'` is the spelling consumers reach for anyway (the Wesnoth port keys its own `Map`s by
- * hand with it); taking it from the framework means a key written by one system is understood
- * by the next, which a pair of numbers in a string is otherwise not guaranteed to be. Negative
- * coordinates are included, since a grid view that scrolls can hand one out.
- */
-export declare function cellKey(x: number, y: number): string;
-/** The cell a `cellKey` names, or `null` when `key` is not one this module produced. */
-export declare function cellFromKey(key: string): {
-    x: number;
-    y: number;
-} | null;
-/**
- * The four axial neighbours of a cell: north, east, south, west, in that order.
- *
- * One frozen table shared by every square-grid algorithm, so a flood fill and a
- * diffusion field visit neighbours in the same sequence without each keeping its
- * own copy: `roguelike`'s `neighbourOffsets(4)` returns this same table.
- */
-export declare const NEIGHBOURS4: ReadonlyArray<readonly [number, number]>;
-/**
- * The eight cells surrounding a cell, in row-major (reading) order, centre skipped.
- *
- * The same eight cells `CIRCLE8` carries, only the visit order differs: reading order
- * suits first-found-wins scans, the ring suits directional work like knockback cursors.
- */
-export declare const NEIGHBOURS8: ReadonlyArray<readonly [number, number]>;
-/**
- * The eight cells surrounding a cell as a clockwise ring starting north.
- *
- * The same sequence `roguelike`'s `neighbourOffsets(8)` has always returned, now shared
- * from here instead of copied there.
- */
-export declare const CIRCLE8: ReadonlyArray<readonly [number, number]>;
-/**
- * Euclidean ruler distance between two cells.
- *
- * The counterpart to `roguelike`'s `chebyshevDistance`, which charges a diagonal the
- * same as a step: use this one when the true straight-line distance matters (blast
- * falloff, census radius) and that one for roguelike range and movement.
- *
- * @example
- * ```ts
- * import { euclidean } from '@datamoc/mw_games/core';
- *
- * euclidean({ x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-export declare function euclidean(a: {
-    readonly x: number;
-    readonly y: number;
-}, b: {
-    readonly x: number;
-    readonly y: number;
-}): number;
-/**
- * Chebyshev ruler distance between two cells: the king-move count, a diagonal costing one step.
- *
- * The counterpart to `euclidean` above for grid movement and range, where a diagonal is a
- * single step rather than 1.41 cells; `roguelike`
- * `chebyshevDistance` is this same arithmetic through its own `Step` type.
- *
- * @example
- * ```ts
- * import { chebyshev } from '@datamoc/mw_games/core';
- *
- * chebyshev({ x: 0, y: 0 }, { x: 3, y: 4 }); // 4
- * ```
- */
-export declare function chebyshev(a: {
-    readonly x: number;
-    readonly y: number;
-}, b: {
-    readonly x: number;
-    readonly y: number;
-}): number;
-/**
- * Manhattan ruler distance between two cells: the orthogonal-step count, no diagonals.
- *
- * The counterpart to `euclidean` and `chebyshev` for four-way movement and range, where
- * every step is axis-aligned.
- *
- * @example
- * ```ts
- * import { manhattan } from '@datamoc/mw_games/core';
- *
- * manhattan({ x: 0, y: 0 }, { x: 3, y: 4 }); // 7
- * ```
- */
-export declare function manhattan(a: {
-    readonly x: number;
-    readonly y: number;
-}, b: {
-    readonly x: number;
-    readonly y: number;
-}): number;
-/**
- * The ruler a rule measures with, chosen by name where the choice itself is data: a
- * movement rule walks `chebyshev`, a blast falls off with `euclidean`, a four-way maze
- * counts `manhattan`.
- */
-export type DistanceMetric = 'euclidean' | 'manhattan' | 'chebyshev';
-/**
- * Measures `a` to `b` with the named ruler, so a rule authored as data (a table row, a
- * authored profile) can pick its geometry without importing each ruler by name.
- *
- * @example
- * ```ts
- * import { distance } from '@datamoc/mw_games/core';
- *
- * distance('chebyshev', { x: 0, y: 0 }, { x: 3, y: 4 }); // 4
- * distance('euclidean', { x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-export declare function distance(metric: DistanceMetric, a: {
-    readonly x: number;
-    readonly y: number;
-}, b: {
-    readonly x: number;
-    readonly y: number;
-}): number;
-//# sourceMappingURL=Grid.d.ts.map

package/dist/core/Grid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Grid.d.ts","sourceRoot":"","sources":["../../src/core/Grid.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEvF;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,yEAAyE;AACzE,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIxE;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAKhE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAShE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAS5D,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACxB,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7C,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,MAAM,CAER;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACxB,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7C,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,MAAM,CAER;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CACxB,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7C,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,MAAM,CAER;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACvB,MAAM,EAAE,cAAc,EACtB,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7C,CAAC,EAAE;IAAE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,MAAM,CAWR"}

package/dist/core/Grid.js

@@ -1,201 +0,0 @@
-/**
- * Bounded-grid indexing: the row-major cell arithmetic and bounds check that every tile, board
- * and hex module ends up writing for itself.
- *
- * Free functions rather than a `Grid` class, deliberately. Every caller already holds a width
- * and height (a level, a board, a skirmish state), and several sit in loops hot enough that
- * allocating a wrapper per call would be the wrong trade. `mwg/roguelike`'s `Level` keeps its
- * own `index`/`inside`/`x`/`y` as one-line forwards to these, so its public shape is unchanged.
- *
- * Out-of-bounds policy is not part of this module either: `cellIndex` does the arithmetic and
- * nothing else, so a loop that has already proved its coordinates pays nothing, while a module
- * that wants to fail loudly (`board/Classics` throws) or to report `-1`
- * (`board/FogOfWar` does) keeps that decision in its own method. `cellInside` is the shared
- * check for callers that have not already proved it.
- *
- * @example
- * ```ts
- * import { cellInside, cellIndex, cellX, cellY, cellKey, cellFromKey } from '@datamoc/mw_games/core';
- * import { NEIGHBOURS4, NEIGHBOURS8, CIRCLE8, euclidean } from '@datamoc/mw_games/core';
- *
- * // a 4x3 board, row-major: y * width + x
- * cellInside(4, 3, 3, 2);        // true, the far corner
- * cellInside(4, 3, 4, 0);        // false, one past the right edge
- * cellIndex(4, 2, 1);            // 6, the cell's slot in a flat array
- * cellX(4, 6);                   // 2, back from that index
- * cellY(4, 6);                   // 1
- *
- * const seen = new Set([cellKey(2, 1)]);   // '2,1', for a Map or a Set
- * cellFromKey('2,1');                      // { x: 2, y: 1 }
- *
- * NEIGHBOURS8.length; // 8, the surrounding cells in row-major order
- * CIRCLE8[0];         // [0, -1], the same ring clockwise from north
- * NEIGHBOURS4.length; // 4, north/east/south/west
- * euclidean({ x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-/**
- * True when `(x, y)` is inside a `width` x `height` grid.
- *
- * Both edges are inclusive of `0` and exclusive of `width`/`height`, so a cell exists if and
- * only if `0 <= x < width` and `0 <= y < height`.
- */
-export function cellInside(width, height, x, y) {
-    return x >= 0 && y >= 0 && x < width && y < height;
-}
-/**
- * The row-major index of `(x, y)`: its position in a flat `width * height` array.
- *
- * Deliberately unchecked. Call `cellInside` when the coordinates are not already known to be
- * valid; an out-of-range `x` otherwise lands on a neighbouring row rather than failing, and a
- * negative one on the row before it.
- */
-export function cellIndex(width, x, y) {
-    return y * width + x;
-}
-/** The `x` coordinate of a row-major `index` (`cellIndex`'s inverse). */
-export function cellX(width, index) {
-    return index % width;
-}
-/** The `y` coordinate of a row-major `index` (`cellIndex`'s inverse). */
-export function cellY(width, index) {
-    return Math.floor(index / width);
-}
-/**
- * A stable string key naming one cell, for `Map`/`Set` membership.
- *
- * `'x,y'` is the spelling consumers reach for anyway (the Wesnoth port keys its own `Map`s by
- * hand with it); taking it from the framework means a key written by one system is understood
- * by the next, which a pair of numbers in a string is otherwise not guaranteed to be. Negative
- * coordinates are included, since a grid view that scrolls can hand one out.
- */
-export function cellKey(x, y) {
-    return `${x},${y}`;
-}
-/** The cell a `cellKey` names, or `null` when `key` is not one this module produced. */
-export function cellFromKey(key) {
-    const match = /^(-?\d+),(-?\d+)$/.exec(key);
-    if (!match)
-        return null;
-    return { x: Number(match[1]), y: Number(match[2]) };
-}
-/**
- * The four axial neighbours of a cell: north, east, south, west, in that order.
- *
- * One frozen table shared by every square-grid algorithm, so a flood fill and a
- * diffusion field visit neighbours in the same sequence without each keeping its
- * own copy: `roguelike`'s `neighbourOffsets(4)` returns this same table.
- */
-export const NEIGHBOURS4 = [
-    [0, -1],
-    [1, 0],
-    [0, 1],
-    [-1, 0],
-];
-/**
- * The eight cells surrounding a cell, in row-major (reading) order, centre skipped.
- *
- * The same eight cells `CIRCLE8` carries, only the visit order differs: reading order
- * suits first-found-wins scans, the ring suits directional work like knockback cursors.
- */
-export const NEIGHBOURS8 = [
-    [-1, -1],
-    [0, -1],
-    [1, -1],
-    [-1, 0],
-    [1, 0],
-    [-1, 1],
-    [0, 1],
-    [1, 1],
-];
-/**
- * The eight cells surrounding a cell as a clockwise ring starting north.
- *
- * The same sequence `roguelike`'s `neighbourOffsets(8)` has always returned, now shared
- * from here instead of copied there.
- */
-export const CIRCLE8 = [
-    [0, -1],
-    [1, -1],
-    [1, 0],
-    [1, 1],
-    [0, 1],
-    [-1, 1],
-    [-1, 0],
-    [-1, -1],
-];
-/**
- * Euclidean ruler distance between two cells.
- *
- * The counterpart to `roguelike`'s `chebyshevDistance`, which charges a diagonal the
- * same as a step: use this one when the true straight-line distance matters (blast
- * falloff, census radius) and that one for roguelike range and movement.
- *
- * @example
- * ```ts
- * import { euclidean } from '@datamoc/mw_games/core';
- *
- * euclidean({ x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-export function euclidean(a, b) {
-    return Math.hypot(a.x - b.x, a.y - b.y);
-}
-/**
- * Chebyshev ruler distance between two cells: the king-move count, a diagonal costing one step.
- *
- * The counterpart to `euclidean` above for grid movement and range, where a diagonal is a
- * single step rather than 1.41 cells; `roguelike`
- * `chebyshevDistance` is this same arithmetic through its own `Step` type.
- *
- * @example
- * ```ts
- * import { chebyshev } from '@datamoc/mw_games/core';
- *
- * chebyshev({ x: 0, y: 0 }, { x: 3, y: 4 }); // 4
- * ```
- */
-export function chebyshev(a, b) {
-    return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
-}
-/**
- * Manhattan ruler distance between two cells: the orthogonal-step count, no diagonals.
- *
- * The counterpart to `euclidean` and `chebyshev` for four-way movement and range, where
- * every step is axis-aligned.
- *
- * @example
- * ```ts
- * import { manhattan } from '@datamoc/mw_games/core';
- *
- * manhattan({ x: 0, y: 0 }, { x: 3, y: 4 }); // 7
- * ```
- */
-export function manhattan(a, b) {
-    return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
-}
-/**
- * Measures `a` to `b` with the named ruler, so a rule authored as data (a table row, a
- * authored profile) can pick its geometry without importing each ruler by name.
- *
- * @example
- * ```ts
- * import { distance } from '@datamoc/mw_games/core';
- *
- * distance('chebyshev', { x: 0, y: 0 }, { x: 3, y: 4 }); // 4
- * distance('euclidean', { x: 0, y: 0 }, { x: 3, y: 4 }); // 5
- * ```
- */
-export function distance(metric, a, b) {
-    switch (metric) {
-        case 'euclidean':
-            return euclidean(a, b);
-        case 'manhattan':
-            return manhattan(a, b);
-        case 'chebyshev':
-            return chebyshev(a, b);
-        default:
-            throw new RangeError(`unknown distance metric: ${metric}`);
-    }
-}
-//# sourceMappingURL=Grid.js.map

package/dist/core/Grid.js.map

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

package/dist/core/Handles.d.ts

@@ -1,42 +0,0 @@
-/**
- * Numeric leases for values a plain-data command cannot carry.
- *
- * A simulation command must survive `structuredClone`, so anything live (a
- * callback, an externally-owned RNG stream, a world-query closure) travels as
- * a numeric id resolved inside the rule. This is the one-line container for
- * that recipe: `put` a value, carry the id in the command, `get` it in the
- * rule, and `drop` it when done. `with` scopes the lease so the `drop` runs
- * even when the rule throws.
- *
- * @example
- * ```ts
- * import { createHandles } from '@datamoc/mw_games/core';
- *
- * const handles = createHandles<() => number>();
- * const result = handles.with(() => 7, (id) => {
- *   const fn = handles.get(id);
- *   return fn();
- * });
- * console.log(result); // 7
- * ```
- */
-export interface Handles<T> {
-    /** the number of values currently leased */
-    readonly size: number;
-    /** stores `value` and returns its numeric lease id */
-    put(value: T): number;
-    /** resolves a leased id; throws when the id is unknown or was dropped */
-    get(id: number): T;
-    /** ends a lease; unknown ids are ignored */
-    drop(id: number): void;
-    /** ends every lease */
-    clear(): void;
-    /**
-     * Leases `value` for `body`, dropping the id afterwards even when `body`
-     * throws. The id is only valid inside `body`.
-     */
-    with<R>(value: T, body: (id: number) => R): R;
-}
-/** Creates an empty numeric-lease table; ids start at 1 and are never reused. */
-export declare function createHandles<T>(): Handles<T>;
-//# sourceMappingURL=Handles.d.ts.map

package/dist/core/Handles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Handles.d.ts","sourceRoot":"","sources":["../../src/core/Handles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,OAAO,CAAC,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC;IACtB,yEAAyE;IACzE,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,CAAC,CAAC;IACnB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,uBAAuB;IACvB,KAAK,IAAI,IAAI,CAAC;IACd;;;OAGG;IACH,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,CAAC;CAC9C;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAiC7C"}

package/dist/core/Handles.js

@@ -1,38 +0,0 @@
-/** Creates an empty numeric-lease table; ids start at 1 and are never reused. */
-export function createHandles() {
-    let next = 1;
-    const values = new Map();
-    return {
-        get size() {
-            return values.size;
-        },
-        put(value) {
-            const id = next++;
-            values.set(id, value);
-            return id;
-        },
-        get(id) {
-            const value = values.get(id);
-            if (value === undefined)
-                throw new Error(`unknown handle ${id}`);
-            return value;
-        },
-        drop(id) {
-            values.delete(id);
-        },
-        clear() {
-            values.clear();
-        },
-        with(value, body) {
-            const id = next++;
-            values.set(id, value);
-            try {
-                return body(id);
-            }
-            finally {
-                values.delete(id);
-            }
-        },
-    };
-}
-//# sourceMappingURL=Handles.js.map

package/dist/core/Handles.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Handles.js","sourceRoot":"","sources":["../../src/core/Handles.ts"],"names":[],"mappings":"AAwCA,iFAAiF;AACjF,MAAM,UAAU,aAAa;IAC5B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,MAAM,MAAM,GAAG,IAAI,GAAG,EAAa,CAAC;IACpC,OAAO;QACN,IAAI,IAAI;YACP,OAAO,MAAM,CAAC,IAAI,CAAC;QACpB,CAAC;QACD,GAAG,CAAC,KAAQ;YACX,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC;YAClB,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;YACtB,OAAO,EAAE,CAAC;QACX,CAAC;QACD,GAAG,CAAC,EAAU;YACb,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YAC7B,IAAI,KAAK,KAAK,SAAS;gBAAE,MAAM,IAAI,KAAK,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAC;YACjE,OAAO,KAAK,CAAC;QACd,CAAC;QACD,IAAI,CAAC,EAAU;YACd,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACnB,CAAC;QACD,KAAK;YACJ,MAAM,CAAC,KAAK,EAAE,CAAC;QAChB,CAAC;QACD,IAAI,CAAI,KAAQ,EAAE,IAAuB;YACxC,MAAM,EAAE,GAAG,IAAI,EAAE,CAAC;YAClB,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;YACtB,IAAI,CAAC;gBACJ,OAAO,IAAI,CAAC,EAAE,CAAC,CAAC;YACjB,CAAC;oBAAS,CAAC;gBACV,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACnB,CAAC;QACF,CAAC;KACD,CAAC;AACH,CAAC"}

package/dist/core/Hex.d.ts

@@ -1,79 +0,0 @@
-/**
- * Flat-top hexagon geometry, addressed the same way a square grid is: `x` the column, `y`
- * the row, both integers - which is what lets `mwg/roguelike`'s `Level` (grid logic) and
- * `mwg/render`'s `TileMap` (pixel positions) each reuse it without depending on the other.
- * It lives in `mwg/core` for exactly that reason: neither of those two modules is allowed
- * to depend on the other, and this needs to sit below both.
- *
- * Internally this converts to and from cube coordinates (`x + y + z = 0`) for every
- * calculation, because the six neighbour directions are then a fixed, orientation-agnostic
- * list rather than a column-parity-dependent table someone has to get right twice. The
- * offset "odd-q" scheme below - odd columns pushed half a row down - is what makes that
- * cube math round-trip back to integers; nothing about it is rot.js's, which is deliberate
- * (see the roadmap: rot.js's own hex `Path` topology is doubled-width coordinates built for
- * *pointy-top* hexagons, and does not match this orientation).
- *
- * @example
- * ```ts
- * import { hexNeighbors, hexDistance, hexLine, hexRange, hexToPixel, pixelToHex } from '@datamoc/mw_games/core';
- *
- * const start = { x: 2, y: 2 };
- * const neighbours = hexNeighbors(start.x, start.y); // the 6 adjacent cells
- * const cellsAway = hexDistance(start, { x: 4, y: 1 });
- * const path = hexLine(start, { x: 4, y: 1 }); // every cell the line crosses
- * const nearby = hexRange(start, 2); // every cell within 2 hexes
- *
- * const pixel = hexToPixel(start.x, start.y, 32, 28); // tile width/height in pixels
- * const backToHex = pixelToHex(pixel.x, pixel.y, 32, 28); // round-trips to { x: 2, y: 2 }
- * ```
- */
-export interface HexCoord {
-    x: number;
-    y: number;
-}
-/** the six cells sharing an edge with `(x, y)` */
-export declare function hexNeighbors(x: number, y: number): HexCoord[];
-/** the number of hex steps between two cells */
-export declare function hexDistance(a: HexCoord, b: HexCoord): number;
-/**
- * Every cell a straight line crosses from `a` to `b`, both included - the hex-grid analogue
- * of `mwg/roguelike`'s `traceLine`, and what a simple (non-shadowcast) hex field of view is
- * built from: walk the line to a candidate cell and see whether anything on it is opaque.
- */
-export declare function hexLine(a: HexCoord, b: HexCoord): HexCoord[];
-/** every cell within `radius` hex steps of `center`, `center` itself included */
-export declare function hexRange(center: HexCoord, radius: number): HexCoord[];
-/** which way the tiles point: flat-top (columns) or pointy-top (rows) */
-export type HexOrientation = 'flat-top' | 'pointy-top';
-/** which columns (flat-top) or rows (pointy-top) are pushed half a step down or right */
-export type HexOffset = 'odd' | 'even';
-/**
- * How a grid of hexes is laid out on a screen. Both fields default to what this module has always
- * done - flat-top tiles, odd columns pushed half a row down - so a caller that says nothing gets
- * the layout it already had, and a Wesnoth-style map is `{ orientation: 'pointy-top', offset: 'odd' }`.
- */
-export interface HexShape {
-    readonly orientation?: HexOrientation;
-    readonly offset?: HexOffset;
-}
-/**
- * The pixel position of a hex cell's centre.
- *
- * `tileWidth`/`tileHeight` are the tile as drawn, so a flat-top hex is `0.75` of its width between
- * columns and its full height between rows; a pointy-top one is the transpose of that.
- */
-export declare function hexToPixel(x: number, y: number, tileWidth: number, tileHeight: number, shape?: HexShape): {
-    x: number;
-    y: number;
-};
-/**
- * The hex cell under a pixel position - the inverse of `hexToPixel`.
- *
- * The answer is the nearest cell centre, searched over the cells around the one the pixel looks
- * like it is in, and that is deliberate: a hexagonal tiling has no ties, the containing cell *is* the
- * nearest centre, and a search needs no second set of formulas to stay the inverse of the four
- * orientation-and-offset combinations above. A closed-form inverse would be four more chances to be
- * subtly wrong at a hex's edge, where a click has to land somewhere sensible.
- */
-export declare function pixelToHex(px: number, py: number, tileWidth: number, tileHeight: number, shape?: HexShape): HexCoord;
-//# sourceMappingURL=Hex.d.ts.map

package/dist/core/Hex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Hex.d.ts","sourceRoot":"","sources":["../../src/core/Hex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,MAAM,WAAW,QAAQ;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AA+BD,kDAAkD;AAClD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,QAAQ,EAAE,CAG7D;AAED,gDAAgD;AAChD,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,CAI5D;AAoBD;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAsB5D;AAED,iFAAiF;AACjF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAG,QAAQ,EAAE,CAYrE;AAED,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,YAAY,CAAC;AAEvD,yFAAyF;AACzF,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,WAAW,CAAC,EAAE,cAAc,CAAC;IACtC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC5B;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,GAAE,QAAa,GAClB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAc1B;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACzB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,KAAK,GAAE,QAAa,GAClB,QAAQ,CAuBV"}