@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/two-d/render/RpgmAutotile.d.ts

@@ -1,324 +0,0 @@
-/** One of RPG Maker MV's four autotile atlas families. */
-export type RpgmAutotileSlot = 0 | 1 | 2 | 3;
-/** A source quadrant in the RPG Maker autotile atlas, in source pixels. */
-export interface RpgmAutotileQuadrant {
-    sourceX: number;
-    sourceY: number;
-    destinationX: number;
-    destinationY: number;
-}
-/** The four source quadrants that make up one 48 by 48 RPG Maker autotile. */
-export interface RpgmAutotileFrame {
-    tileId: number;
-    slot: RpgmAutotileSlot;
-    shape: number;
-    destinationX: number;
-    destinationY: number;
-    quadrants: readonly [RpgmAutotileQuadrant, RpgmAutotileQuadrant, RpgmAutotileQuadrant, RpgmAutotileQuadrant];
-}
-/** Four atlas-cell offsets, in 24px source cells, for one autotile shape. */
-export type RpgmAutotileShape = readonly [
-    readonly [number, number],
-    readonly [number, number],
-    readonly [number, number],
-    readonly [number, number]
-];
-export type RpgmAutotileShapeTable = readonly RpgmAutotileShape[];
-/**
- * Describes how RPG Maker MV composes one autotile from four 24px atlas quadrants.
- *
- * The returned geometry is renderer-neutral: a Pixi, canvas, or native renderer can draw
- * each source rectangle into its destination rectangle without this module knowing about it.
- * `tileId` is the output atlas index used by RPG Maker's 16-column generated atlas, while
- * `slot` selects the source atlas family and `shape` indexes the caller's four-quadrant table.
- *
- * @example
- * ```ts
- * import { rpgmAutotileFrame } from '@datamoc/mw_games/two-d/render';
- *
- * const shapeTable = Array.from({ length: 48 }, () => [[0, 0], [1, 0], [0, 1], [1, 1]] as const);
- * const frame = rpgmAutotileFrame(7, 0, 3, shapeTable);
- * console.log(frame.quadrants[0].sourceX); // source pixel x coordinate
- * ```
- */
-export declare function rpgmAutotileFrame(tileId: number, slot: RpgmAutotileSlot, shape: number, table: RpgmAutotileShapeTable): RpgmAutotileFrame;
-/**
- * Caches RPG Maker autotile frame descriptions for one fixed shape table.
- *
- * @example
- * ```ts
- * import { RpgmAutotileAtlas, type RpgmAutotileShapeTable } from '@datamoc/mw_games/two-d/render';
- *
- * declare const shapeTable: RpgmAutotileShapeTable;
- * const atlas = new RpgmAutotileAtlas(shapeTable);
- * const frame = atlas.get(7, 0, 3);
- * console.log(frame.quadrants.length); // 4
- * ```
- */
-export declare class RpgmAutotileAtlas {
-    private readonly cache;
-    private readonly table;
-    constructor(table: RpgmAutotileShapeTable);
-    get(tileId: number, slot: RpgmAutotileSlot, shape: number): RpgmAutotileFrame;
-    clear(): void;
-}
-/**
- * The first MV tile id of each autotile family (A1-A4): slot 0 covers
- * 2048-2815, slot 1 covers 2816-4351, slot 2 covers 4352-5887 and slot 3
- * covers 5888-8191. Measured against real A-sheets rather than assumed.
- */
-export declare const RPGM_AUTOTILE_SLOT_BASES: readonly [2048, 2816, 4352, 5888];
-/**
- * How many MV tile ids each family holds: 16, 32, 32 and 48 kinds of
- * 48 shapes each. A sheet holding fewer cells than its slot needs is a
- * truncated custom sheet, not a different layout.
- */
-export declare const RPGM_AUTOTILE_SLOT_COUNTS: readonly [768, 1536, 1536, 2304];
-/**
- * Which MV autotile family a raw map tile id belongs to, or null when the id
- * is not an autotile at all (an `EMPTY` cell, a static B-E tile, an A5 tile).
- *
- * @example
- * ```ts
- * import {
- * 	rpgmAutotileSlot,
- * 	RPGM_AUTOTILE_SLOT_BASES,
- * 	RPGM_AUTOTILE_SLOT_COUNTS,
- * } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(rpgmAutotileSlot(2048)); // 0 - the first A1 tile
- * console.log(rpgmAutotileSlot(3000)); // 1 - inside the A2 range
- * console.log(rpgmAutotileSlot(42)); // null - a static tile, not an autotile
- * console.log(rpgmAutotileSlot(-1)); // null - EMPTY reads as blank, never as a slot
- * console.log(RPGM_AUTOTILE_SLOT_BASES[0]); // 2048 - where slot 0 starts
- * console.log(RPGM_AUTOTILE_SLOT_COUNTS[0]); // 768 - 16 kinds times 48 shapes
- * ```
- */
-export declare function rpgmAutotileSlot(tile: number): RpgmAutotileSlot | null;
-/**
- * The standard MV floor-autotile shape table (48 shapes), for slots 0-1:
- * which four atlas quadrants each baked shape assembles, in 24px source
- * cells. Entries are `[x, y]` offsets, row-major `[topLeft, topRight,
- * bottomLeft, bottomRight]`, exactly the shape numbering MV bakes into map
- * tile ids (`shape = (tile - base) % 48`).
- *
- * Functional interop data, the same category as `BLOB_SHAPES`: every game
- * reading MV maps needs these numbers, so they live here once rather than
- * pasted into every port.
- *
- * @example
- * ```ts
- * import { RPGM_FLOOR_AUTOTILE_TABLE, RPGM_WALL_AUTOTILE_TABLE } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(RPGM_FLOOR_AUTOTILE_TABLE.length); // 48 - one entry per baked shape
- * console.log(RPGM_WALL_AUTOTILE_TABLE.length); // 16 - walls cycle every 16 shapes
- * console.log(RPGM_FLOOR_AUTOTILE_TABLE[47]); // [[0,0],[1,0],[0,1],[1,1]] - the full tile
- * ```
- */
-export declare const RPGM_FLOOR_AUTOTILE_TABLE: RpgmAutotileShapeTable;
-/**
- * The standard MV wall-autotile shape table (16 shapes), for slots 2-3.
- * Wall shapes cycle every 16 (`table[shape % 16]`), so a wall family holds
- * three full cycles where a floor family holds one run of 48.
- */
-export declare const RPGM_WALL_AUTOTILE_TABLE: RpgmAutotileShapeTable;
-/** one XP autotile pattern: four 16px mini-block indices, row-major `[topLeft, topRight, bottomLeft, bottomRight]` */
-export type XpAutotilePattern = readonly [number, number, number, number];
-/**
- * The standard XP autotile pattern table (48 patterns). An XP autotile image
- * is a 96 by 128 template: a 6-column grid of 16px mini-blocks, and each
- * baked pattern assembles four of them. `tile % 48` selects the pattern;
- * `tile / 48` (floored) selects which of the map's autotile images.
- *
- * Miniblock entries are 0-based here (block `n` sits at `(n % 6) * 16`,
- * `(n / 6) * 16`). Learned from real XP autotile images and map data rather
- * than assumed: the 6 by 8 mini-grid fits the measured 96 by 128 template
- * exactly, and the neighbor table below reproduces baked map patterns.
- *
- * @example
- * ```ts
- * import { XP_AUTOTILE_PATTERNS, XP_NEIGHBORS_TO_PATTERN } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(XP_AUTOTILE_PATTERNS.length); // 48 - one entry per baked pattern
- * console.log(XP_AUTOTILE_PATTERNS[0]); // [26,27,32,33] - the filled interior tile
- * console.log(XP_NEIGHBORS_TO_PATTERN.length); // 256 - one entry per 8-neighbour mask
- * console.log(XP_NEIGHBORS_TO_PATTERN[255]); // 0 - surrounded on all sides is the interior
- * ```
- */
-export declare const XP_AUTOTILE_PATTERNS: readonly XpAutotilePattern[];
-/**
- * Which XP pattern an 8-neighbourhood of same-autotile cells bakes to. Index
- * with a bit mask - north `0x01`, northeast `0x02`, east `0x04`, southeast
- * `0x08`, south `0x10`, southwest `0x20`, west `0x40`, northwest `0x80` - for
- * games computing patterns procedurally instead of reading baked map data.
- */
-export declare const XP_NEIGHBORS_TO_PATTERN: readonly number[];
-/** an XP map cell decoded into its autotile image and baked pattern */
-export interface XpAutotileRef {
-    /** which autotile image, 0-7 (`tile / 48` floored) */
-    index: number;
-    /** which pattern in that image, 0-47 (`tile % 48`) */
-    pattern: number;
-}
-/**
- * Decodes a raw XP map cell into its autotile image and pattern, or null
- * when the cell holds no autotile reference: `EMPTY`, a static tileset tile
- * (384 and up), or anything outside the 1-383 autotile range.
- *
- * @example
- * ```ts
- * import { xpAutotileRef } from '@datamoc/mw_games/two-d/render';
- *
- * console.log(xpAutotileRef(97)); // { index: 2, pattern: 1 } - second image, second pattern
- * console.log(xpAutotileRef(0)); // null - EMPTY is blank, never an autotile
- * console.log(xpAutotileRef(384)); // null - the first static tileset tile
- * ```
- */
-export declare function xpAutotileRef(tile: number): XpAutotileRef | null;
-/**
- * Which XP pattern a cell's 8-neighbourhood bakes to, for maps computed
- * procedurally rather than read from baked data. `sameTerrain` is asked once
- * per direction, with `(dx, dy)` offsets (`(0, -1)` is north); off the map is
- * the caller's to answer (false reads as a border, the edge cell's own value
- * clamps like the editor).
- *
- * @example
- * ```ts
- * import { xpAutotilePattern } from '@datamoc/mw_games/two-d/render';
- *
- * const filled = new Set(['0,0', '1,0', '0,1', '1,1', '-1,0', '0,-1', '2,1', '1,2']);
- * console.log(xpAutotilePattern((dx, dy) => filled.has(`${dx},${dy}`))); // 0 - the interior
- * console.log(xpAutotilePattern(() => false)); // 46 - isolated on all sides
- * ```
- */
-export declare function xpAutotilePattern(sameTerrain: (dx: number, dy: number) => boolean): number;
-/**
- * One drawn piece of an autotile cell: where to sample the source sheet and
- * where the piece lands on the map tile, the destination in fractions of one
- * tile (quadrant halves at `0`/`0.5` with size `0.5`, or the whole tile at
- * `0` with size `1` for single-tile strips).
- */
-export interface AutotileCellPart {
-    sourceX: number;
-    sourceY: number;
-    sourceWidth: number;
-    sourceHeight: number;
-    destX: number;
-    destY: number;
-    destWidth: number;
-    destHeight: number;
-}
-/**
- * An autotile source fully described: everything `autotileCellParts` needs
- * except the sheet texture itself (which lives renderer-side, in the layer).
- * `TileMap.addAutotileLayer` resolves a user-facing `AutotileSet` into one
- * of these and validates it once with `assertAutotileLayout`, so per-cell
- * resolution never re-checks the table.
- */
-export type AutotileLayout = {
-    format: 'rpgm-mv';
-    slot: RpgmAutotileSlot;
-    table: RpgmAutotileShapeTable;
-    /**
-     * Picks the shape table per autotile kind (the A4 sheet mixes floor and wall
-     * rows); when set it overrides `table` for every cell.
-     */
-    tableFor?: (kind: number) => RpgmAutotileShapeTable;
-    /**
-     * Slot 1 only: a cell holds the A2 table tile standing above it, and draws just that
-     * tile's front-edge strip (two 24 by 12 pieces along the cell's top), not a tile.
-     */
-    tableEdge?: boolean;
-    /** kind runs that advance together; a cell whose kind is in no run ignores the frame */
-    cycles: ReadonlyArray<ReadonlyArray<number>>;
-} | {
-    format: 'rpgm-xp';
-    /** which autotile image, 0-7 */
-    index: number;
-    /** animation stripes in the image; frame wraps around this count */
-    frames: number;
-    /** a 32px-tall single-tile strip: one whole-tile piece per frame, patterns ignored */
-    single: boolean;
-};
-/**
- * Checks a resolved autotile layout once, up front. Throws naming the first
- * problem: a bad slot, an empty shape table, an empty animation cycle, a
- * cycle kind outside its slot's kinds, a bad XP index, or a frame count
- * below one.
- *
- * @example
- * ```ts
- * import {
- * 	assertAutotileLayout,
- * 	RPGM_FLOOR_AUTOTILE_TABLE,
- * } from '@datamoc/mw_games/two-d/render';
- *
- * assertAutotileLayout({ format: 'rpgm-mv', slot: 0, table: RPGM_FLOOR_AUTOTILE_TABLE, cycles: [[0, 1, 2]] });
- * assertAutotileLayout({ format: 'rpgm-xp', index: 2, frames: 1, single: false });
- * ```
- */
-export declare function assertAutotileLayout(layout: AutotileLayout): void;
-/**
- * Resolves one autotile cell to its drawn pieces: four quadrant halves for a
- * template cell, one whole-tile piece for an XP single-tile strip, or null
- * for a blank cell (`tile <= 0` reads as blank; `EMPTY` is -1).
- *
- * The layout is assumed valid (`assertAutotileLayout`); only the cell and
- * frame are checked here. `tile` must be an integer the layout claims - an
- * MV id in the layout's slot range, an XP id in `index * 48` to
- * `index * 48 + 47` - and `frame` an integer at or above zero, wrapping
- * around the animation cycles (MV) or frame stripes (XP).
- *
- * @example
- * ```ts
- * import {
- * 	autotileCellParts,
- * 	RPGM_FLOOR_AUTOTILE_TABLE,
- * } from '@datamoc/mw_games/two-d/render';
- *
- * const parts = autotileCellParts(
- * 	{ format: 'rpgm-mv', slot: 0, table: RPGM_FLOOR_AUTOTILE_TABLE, cycles: [] },
- * 	2048, 0,
- * );
- * console.log(parts?.length); // 4 - one piece per quadrant
- * console.log(parts?.[0].sourceWidth); // 24 - MV quadrant halves
- * console.log(autotileCellParts(
- * 	{ format: 'rpgm-xp', index: 2, frames: 1, single: false },
- * 	97, 0,
- * )?.[0].sourceWidth); // 16 - XP quadrant halves
- * ```
- */
-export declare function autotileCellParts(layout: AutotileLayout, tile: number, frame: number): AutotileCellPart[] | null;
-/** what `rpgmTableEdgeCells` needs from an MV map and its tileset */
-export interface RpgmTableEdgeMap {
-    width: number;
-    height: number;
-    /** map layer 0 (row-major, one tile id per cell), whose A3/A4 tiles suppress an edge */
-    ground: ArrayLike<number>;
-    /** map layer 1, where tables are placed */
-    objects: ArrayLike<number>;
-    /** the tileset's passage flags, indexed by tile id (an array or a sparse record) */
-    flags: {
-        readonly [tile: number]: number | undefined;
-    };
-}
-/**
- * The cells that get a table's front-edge strip, in the engine's own rule
- * (`Tilemap._paintTiles`): a cell whose layer-1 neighbour above is an A2 table
- * tile, while its own layer-1 tile is not a table, and whose layer-0 tile is not an
- * A3/A4 wall. Each such cell holds the table tile above it (a raw MV id), every
- * other cell 0, ready for an `addAutotileLayer` set with `tableEdge: true`.
- *
- * @example
- * ```ts
- * import { rpgmTableEdgeCells } from '@datamoc/mw_games/two-d/render';
- *
- * const table = 2816 + 48 * 0 + 47; // an A2 kind with the table flag
- * const flags = { [table]: 0x80 };
- * const cells = rpgmTableEdgeCells({ width: 1, height: 2, ground: [0, 0], objects: [table, 0], flags });
- * console.log(cells[1]); // the table tile above cell 1
- * console.log(cells[0]); // 0 - nothing above the top row
- * ```
- */
-export declare function rpgmTableEdgeCells(map: RpgmTableEdgeMap): Int32Array;
-//# sourceMappingURL=RpgmAutotile.d.ts.map

package/dist/two-d/render/RpgmAutotile.d.ts.map

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