@datamoc/mw_games 0.15.0 → 0.17.0

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

@@ -107,4 +107,760 @@ export class RpgmAutotileAtlas {
         this.cache.clear();
     }
 }
+/**
+ * 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 const RPGM_AUTOTILE_SLOT_BASES = [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 const RPGM_AUTOTILE_SLOT_COUNTS = [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 function rpgmAutotileSlot(tile) {
+    if (!Number.isInteger(tile))
+        return null;
+    for (let slot = 0; slot < 4; slot++) {
+        if (tile >= RPGM_AUTOTILE_SLOT_BASES[slot] &&
+            tile < RPGM_AUTOTILE_SLOT_BASES[slot] + RPGM_AUTOTILE_SLOT_COUNTS[slot]) {
+            return slot;
+        }
+    }
+    return 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 const RPGM_FLOOR_AUTOTILE_TABLE = [
+    [
+        [2, 4],
+        [1, 4],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [2, 0],
+        [1, 4],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [2, 4],
+        [3, 0],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [2, 4],
+        [1, 4],
+        [2, 3],
+        [3, 1],
+    ],
+    [
+        [2, 0],
+        [1, 4],
+        [2, 3],
+        [3, 1],
+    ],
+    [
+        [2, 4],
+        [3, 0],
+        [2, 3],
+        [3, 1],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 3],
+        [3, 1],
+    ],
+    [
+        [2, 4],
+        [1, 4],
+        [2, 1],
+        [1, 3],
+    ],
+    [
+        [2, 0],
+        [1, 4],
+        [2, 1],
+        [1, 3],
+    ],
+    [
+        [2, 4],
+        [3, 0],
+        [2, 1],
+        [1, 3],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 1],
+        [1, 3],
+    ],
+    [
+        [2, 4],
+        [1, 4],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [2, 0],
+        [1, 4],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [2, 4],
+        [3, 0],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [0, 4],
+        [1, 4],
+        [0, 3],
+        [1, 3],
+    ],
+    [
+        [0, 4],
+        [3, 0],
+        [0, 3],
+        [1, 3],
+    ],
+    [
+        [0, 4],
+        [1, 4],
+        [0, 3],
+        [3, 1],
+    ],
+    [
+        [0, 4],
+        [3, 0],
+        [0, 3],
+        [3, 1],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 3],
+        [3, 1],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 1],
+        [1, 3],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [2, 4],
+        [3, 4],
+        [2, 3],
+        [3, 3],
+    ],
+    [
+        [2, 4],
+        [3, 4],
+        [2, 1],
+        [3, 3],
+    ],
+    [
+        [2, 0],
+        [3, 4],
+        [2, 3],
+        [3, 3],
+    ],
+    [
+        [2, 0],
+        [3, 4],
+        [2, 1],
+        [3, 3],
+    ],
+    [
+        [2, 4],
+        [1, 4],
+        [2, 5],
+        [1, 5],
+    ],
+    [
+        [2, 0],
+        [1, 4],
+        [2, 5],
+        [1, 5],
+    ],
+    [
+        [2, 4],
+        [3, 0],
+        [2, 5],
+        [1, 5],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 5],
+        [1, 5],
+    ],
+    [
+        [0, 4],
+        [3, 4],
+        [0, 3],
+        [3, 3],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 5],
+        [1, 5],
+    ],
+    [
+        [0, 2],
+        [1, 2],
+        [0, 3],
+        [1, 3],
+    ],
+    [
+        [0, 2],
+        [1, 2],
+        [0, 3],
+        [3, 1],
+    ],
+    [
+        [2, 2],
+        [3, 2],
+        [2, 3],
+        [3, 3],
+    ],
+    [
+        [2, 2],
+        [3, 2],
+        [2, 1],
+        [3, 3],
+    ],
+    [
+        [2, 4],
+        [3, 4],
+        [2, 5],
+        [3, 5],
+    ],
+    [
+        [2, 0],
+        [3, 4],
+        [2, 5],
+        [3, 5],
+    ],
+    [
+        [0, 4],
+        [1, 4],
+        [0, 5],
+        [1, 5],
+    ],
+    [
+        [0, 4],
+        [3, 0],
+        [0, 5],
+        [1, 5],
+    ],
+    [
+        [0, 2],
+        [3, 2],
+        [0, 3],
+        [3, 3],
+    ],
+    [
+        [0, 2],
+        [1, 2],
+        [0, 5],
+        [1, 5],
+    ],
+    [
+        [0, 4],
+        [3, 4],
+        [0, 5],
+        [3, 5],
+    ],
+    [
+        [2, 2],
+        [3, 2],
+        [2, 5],
+        [3, 5],
+    ],
+    [
+        [0, 2],
+        [3, 2],
+        [0, 3],
+        [3, 5],
+    ],
+    [
+        [0, 0],
+        [1, 0],
+        [0, 1],
+        [1, 1],
+    ],
+];
+/**
+ * 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 const RPGM_WALL_AUTOTILE_TABLE = [
+    [
+        [2, 2],
+        [1, 2],
+        [2, 1],
+        [1, 1],
+    ],
+    [
+        [0, 2],
+        [1, 2],
+        [0, 1],
+        [1, 1],
+    ],
+    [
+        [2, 0],
+        [1, 0],
+        [2, 1],
+        [1, 1],
+    ],
+    [
+        [0, 0],
+        [1, 0],
+        [0, 1],
+        [1, 1],
+    ],
+    [
+        [2, 2],
+        [3, 2],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [0, 2],
+        [3, 2],
+        [0, 1],
+        [3, 1],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 1],
+        [3, 1],
+    ],
+    [
+        [0, 0],
+        [3, 0],
+        [0, 1],
+        [3, 1],
+    ],
+    [
+        [2, 2],
+        [1, 2],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [0, 2],
+        [1, 2],
+        [0, 3],
+        [1, 3],
+    ],
+    [
+        [2, 0],
+        [1, 0],
+        [2, 3],
+        [1, 3],
+    ],
+    [
+        [0, 0],
+        [1, 0],
+        [0, 3],
+        [1, 3],
+    ],
+    [
+        [2, 2],
+        [3, 2],
+        [2, 3],
+        [3, 3],
+    ],
+    [
+        [0, 2],
+        [3, 2],
+        [0, 3],
+        [3, 3],
+    ],
+    [
+        [2, 0],
+        [3, 0],
+        [2, 3],
+        [3, 3],
+    ],
+    [
+        [0, 0],
+        [3, 0],
+        [0, 3],
+        [3, 3],
+    ],
+];
+/**
+ * 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 const XP_AUTOTILE_PATTERNS = [
+    [26, 27, 32, 33],
+    [4, 27, 32, 33],
+    [26, 5, 32, 33],
+    [4, 5, 32, 33],
+    [26, 27, 32, 11],
+    [4, 27, 32, 11],
+    [26, 5, 32, 11],
+    [4, 5, 32, 11],
+    [26, 27, 10, 33],
+    [4, 27, 10, 33],
+    [26, 5, 10, 33],
+    [4, 5, 10, 33],
+    [26, 27, 10, 11],
+    [4, 27, 10, 11],
+    [26, 5, 10, 11],
+    [4, 5, 10, 11],
+    [24, 25, 30, 31],
+    [24, 5, 30, 31],
+    [24, 25, 30, 11],
+    [24, 5, 30, 11],
+    [14, 15, 20, 21],
+    [14, 15, 20, 11],
+    [14, 15, 10, 21],
+    [14, 15, 10, 11],
+    [28, 29, 34, 35],
+    [28, 29, 10, 35],
+    [4, 29, 34, 35],
+    [4, 29, 10, 35],
+    [38, 39, 44, 45],
+    [4, 39, 44, 45],
+    [38, 5, 44, 45],
+    [4, 5, 44, 45],
+    [24, 29, 30, 35],
+    [14, 15, 44, 45],
+    [12, 13, 18, 19],
+    [12, 13, 18, 11],
+    [16, 17, 22, 23],
+    [16, 17, 10, 23],
+    [40, 41, 46, 47],
+    [4, 41, 46, 47],
+    [36, 37, 42, 43],
+    [36, 5, 42, 43],
+    [12, 17, 18, 23],
+    [12, 13, 42, 43],
+    [36, 41, 42, 47],
+    [16, 17, 46, 47],
+    [12, 17, 42, 47],
+    [0, 1, 6, 7],
+];
+/**
+ * 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 const XP_NEIGHBORS_TO_PATTERN = [
+    46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40, 42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34,
+    17, 34, 16, 46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40, 42, 32, 42, 32, 35, 19, 35, 18, 42, 32,
+    42, 32, 34, 17, 34, 16, 45, 39, 45, 39, 33, 31, 33, 29, 45, 39, 45, 39, 33, 31, 33, 29, 37, 27, 37, 27, 23, 15, 23,
+    13, 37, 27, 37, 27, 22, 11, 22, 9, 45, 39, 45, 39, 33, 31, 33, 29, 45, 39, 45, 39, 33, 31, 33, 29, 36, 26, 36, 26,
+    21, 7, 21, 5, 36, 26, 36, 26, 20, 3, 20, 1, 46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43, 40, 42, 32,
+    42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16, 46, 44, 46, 44, 43, 41, 43, 40, 46, 44, 46, 44, 43, 41, 43,
+    40, 42, 32, 42, 32, 35, 19, 35, 18, 42, 32, 42, 32, 34, 17, 34, 16, 45, 38, 45, 38, 33, 30, 33, 28, 45, 38, 45, 38,
+    33, 30, 33, 28, 37, 25, 37, 25, 23, 14, 23, 12, 37, 25, 37, 25, 22, 10, 22, 8, 45, 38, 45, 38, 33, 30, 33, 28, 45,
+    38, 45, 38, 33, 30, 33, 28, 36, 24, 36, 24, 21, 6, 21, 4, 36, 24, 36, 24, 20, 2, 20, 0,
+];
+/**
+ * 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 function xpAutotileRef(tile) {
+    if (!Number.isInteger(tile) || tile <= 0 || tile >= 384)
+        return null;
+    return { index: Math.floor(tile / 48), pattern: tile % 48 };
+}
+/**
+ * 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 function xpAutotilePattern(sameTerrain) {
+    let mask = 0;
+    if (sameTerrain(0, -1))
+        mask |= 0x01;
+    if (sameTerrain(1, -1))
+        mask |= 0x02;
+    if (sameTerrain(1, 0))
+        mask |= 0x04;
+    if (sameTerrain(1, 1))
+        mask |= 0x08;
+    if (sameTerrain(0, 1))
+        mask |= 0x10;
+    if (sameTerrain(-1, 1))
+        mask |= 0x20;
+    if (sameTerrain(-1, 0))
+        mask |= 0x40;
+    if (sameTerrain(-1, -1))
+        mask |= 0x80;
+    return XP_NEIGHBORS_TO_PATTERN[mask];
+}
+/** the atlas kinds each MV family holds, for validating animation cycles */
+const RPGM_AUTOTILE_KIND_COUNTS = [16, 32, 32, 48];
+/**
+ * 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 function assertAutotileLayout(layout) {
+    if (layout.format === 'rpgm-mv') {
+        assertSlot(layout.slot);
+        validateShapeTable(layout.table);
+        const kinds = RPGM_AUTOTILE_KIND_COUNTS[layout.slot];
+        const firstKind = SLOT_BASE_KINDS[layout.slot];
+        for (const cycle of layout.cycles) {
+            if (cycle.length === 0)
+                throw new Error('an autotile animation cycle needs at least one kind');
+            for (const kind of cycle) {
+                if (!Number.isInteger(kind) || kind < firstKind || kind >= firstKind + kinds) {
+                    throw new Error(`animation cycle kind ${kind} is outside slot ${layout.slot}'s kinds ${firstKind}-${firstKind + kinds - 1}`);
+                }
+            }
+        }
+        return;
+    }
+    if (!Number.isInteger(layout.index) || layout.index < 0 || layout.index > 7) {
+        throw new Error(`an XP autotile index must be 0-7, got ${layout.index}`);
+    }
+    if (!Number.isInteger(layout.frames) || layout.frames < 1) {
+        throw new Error(`an XP autotile frame count must be at least 1, got ${layout.frames}`);
+    }
+}
+/** source pixels of one MV quadrant piece: the format's fixed 24px halves */
+const RPGM_QUADRANT_SIZE = 24;
+/** source pixels of one XP quadrant piece: the format's fixed 16px halves */
+const XP_QUADRANT_SIZE = 16;
+/** columns of 16px mini-blocks in an XP template image */
+const XP_TEMPLATE_COLUMNS = 6;
+/** width of one XP animation stripe, in source pixels */
+const XP_FRAME_WIDTH = 96;
+/** size of one XP single-tile frame, in source pixels */
+const XP_SINGLE_TILE_SIZE = 32;
+/**
+ * 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 function autotileCellParts(layout, tile, frame) {
+    if (tile <= 0)
+        return null;
+    if (!Number.isInteger(frame) || frame < 0) {
+        throw new Error(`an autotile animation frame must be an integer at or above zero, got ${frame}`);
+    }
+    if (layout.format === 'rpgm-mv')
+        return rpgmCellParts(layout, tile, frame);
+    return xpCellParts(layout, tile, frame);
+}
+function rpgmCellParts(layout, tile, frame) {
+    const base = RPGM_AUTOTILE_SLOT_BASES[layout.slot];
+    const count = RPGM_AUTOTILE_SLOT_COUNTS[layout.slot];
+    if (!Number.isInteger(tile) || tile < base || tile >= base + count) {
+        throw new Error(`tile ${tile} is outside slot ${layout.slot}'s ids ${base}-${base + count - 1}`);
+    }
+    const offset = tile - base;
+    //shorter tables cycle the same way the player's own indexing does
+    //(`table[shape % table.length]` over `shape = offset % 48`)
+    const shape = (offset % 48) % layout.table.length;
+    let kind = SLOT_BASE_KINDS[layout.slot] + Math.floor(offset / 48);
+    for (const cycle of layout.cycles) {
+        const at = cycle.indexOf(kind);
+        if (at >= 0) {
+            kind = cycle[(at + frame) % cycle.length];
+            break;
+        }
+    }
+    //rpgmAutotileFrame's tileId is the base-relative offset, so a remapped
+    //kind keeps the cell's shape and only swaps the kind block
+    const described = rpgmAutotileFrame((kind - SLOT_BASE_KINDS[layout.slot]) * 48 + (offset % 48), layout.slot, shape, layout.table);
+    return described.quadrants.map((quadrant, index) => ({
+        sourceX: quadrant.sourceX,
+        sourceY: quadrant.sourceY,
+        sourceWidth: RPGM_QUADRANT_SIZE,
+        sourceHeight: RPGM_QUADRANT_SIZE,
+        destX: (index % 2) / 2,
+        destY: Math.floor(index / 2) / 2,
+        destWidth: 1 / 2,
+        destHeight: 1 / 2,
+    }));
+}
+function xpCellParts(layout, tile, frame) {
+    if (!Number.isInteger(tile) || tile < layout.index * 48 || tile >= layout.index * 48 + 48 || tile <= 0) {
+        throw new Error(`tile ${tile} is outside XP autotile ${layout.index}'s ids ${layout.index * 48}-${layout.index * 48 + 47}`);
+    }
+    if (layout.single) {
+        const stripe = (frame % layout.frames) * XP_SINGLE_TILE_SIZE;
+        return [
+            {
+                sourceX: stripe,
+                sourceY: 0,
+                sourceWidth: XP_SINGLE_TILE_SIZE,
+                sourceHeight: XP_SINGLE_TILE_SIZE,
+                destX: 0,
+                destY: 0,
+                destWidth: 1,
+                destHeight: 1,
+            },
+        ];
+    }
+    const pattern = XP_AUTOTILE_PATTERNS[tile % 48];
+    const stripe = (frame % layout.frames) * XP_FRAME_WIDTH;
+    return pattern.map((block, index) => ({
+        sourceX: (block % XP_TEMPLATE_COLUMNS) * XP_QUADRANT_SIZE + stripe,
+        sourceY: Math.floor(block / XP_TEMPLATE_COLUMNS) * XP_QUADRANT_SIZE,
+        sourceWidth: XP_QUADRANT_SIZE,
+        sourceHeight: XP_QUADRANT_SIZE,
+        destX: (index % 2) / 2,
+        destY: Math.floor(index / 2) / 2,
+        destWidth: 1 / 2,
+        destHeight: 1 / 2,
+    }));
+}
 //# sourceMappingURL=RpgmAutotile.js.map