1681-engine 0.0.0-stage → 0.5.8

package/dist/save/SaveStore.js

@@ -0,0 +1,103 @@
+import { checksum as u } from "./checksum.js";
+import { MemoryBackend as f } from "./MemoryBackend.js";
+import { migrateSave as k, MigrationError as m } from "./migrateSave.js";
+import { WebStorageBackend as l } from "./WebStorageBackend.js";
+const a = ".bak";
+class S {
+  version;
+  backend;
+  prefix;
+  migrations;
+  backup;
+  now;
+  queues = /* @__PURE__ */ new Map();
+  constructor(e) {
+    if (!Number.isInteger(e.version) || e.version < 1) throw new Error("SaveStore: version must be a whole number from 1");
+    this.version = e.version, this.backend = e.backend ?? w(), this.prefix = e.prefix ?? "save:", this.migrations = e.migrations ?? {}, this.backup = e.backup ?? !0, this.now = e.now ?? Date.now;
+  }
+  /** Writes `data` to `slot` at the current version. Rejects when the backend does (a full disk, a quota). */
+  save(e, n, r = null) {
+    return this.queued(e, async () => {
+      const t = this.key(e), i = JSON.stringify(n);
+      if (i === void 0) throw new Error(`SaveStore: data for "${e}" is not JSON`);
+      const s = { slot: e, version: this.version, savedAt: this.now(), meta: r }, d = { format: "lantern-save", version: s.version, savedAt: s.savedAt, meta: r, checksum: u(i), data: n };
+      if (this.backup) {
+        const c = await this.backend.read(t);
+        c !== null && v(c) && await this.backend.write(t + a, c);
+      }
+      return await this.backend.write(t, JSON.stringify(d)), s;
+    });
+  }
+  /** Reads `slot`, brought to the current version. Never throws for a bad slot: the result says what went wrong. */
+  load(e) {
+    return this.queued(e, async () => {
+      const n = this.key(e), r = await this.open(e, await this.backend.read(n), !1);
+      if (r.ok || !this.backup || r.reason !== "corrupt") return r;
+      const t = await this.open(e, await this.backend.read(n + a), !0);
+      return t.ok ? t : r;
+    });
+  }
+  /** Removes a slot and its backup. */
+  delete(e) {
+    return this.queued(e, async () => {
+      const n = this.key(e);
+      await this.backend.remove(n), await this.backend.remove(n + a);
+    });
+  }
+  /** Every slot that reads, newest first, without migrating its data. A damaged slot is left out. */
+  async list() {
+    const e = await this.backend.keys(this.prefix), n = [];
+    for (const r of e) {
+      if (r.endsWith(a)) continue;
+      const t = await this.backend.read(r), i = t === null ? null : h(t);
+      i && v(t) && n.push({ slot: r.slice(this.prefix.length), version: i.version, savedAt: i.savedAt, meta: i.meta });
+    }
+    return n.sort((r, t) => t.savedAt - r.savedAt);
+  }
+  async open(e, n, r) {
+    if (n === null) return { ok: !1, slot: e, reason: r ? "corrupt" : "missing" };
+    const t = h(n);
+    if (!t || u(JSON.stringify(t.data)) !== t.checksum) return { ok: !1, slot: e, reason: "corrupt" };
+    try {
+      const i = k(t.data, t.version, this.version, this.migrations), s = { slot: e, version: t.version, savedAt: t.savedAt, meta: t.meta };
+      return { ok: !0, data: i, info: s, migrated: t.version !== this.version, fromBackup: r };
+    } catch (i) {
+      if (i instanceof m) return { ok: !1, slot: e, reason: i.reason, error: i };
+      throw i;
+    }
+  }
+  key(e) {
+    if (!e || e.endsWith(a)) throw new Error(`SaveStore: "${e}" is not a usable slot name`);
+    return this.prefix + e;
+  }
+  queued(e, n) {
+    const r = (this.queues.get(e) ?? Promise.resolve()).then(n), t = r.catch(() => {
+    });
+    return this.queues.set(e, t), t.then(() => {
+      this.queues.get(e) === t && this.queues.delete(e);
+    }), r;
+  }
+}
+function h(o) {
+  try {
+    const e = JSON.parse(o);
+    return !e || e.format !== "lantern-save" || typeof e.version != "number" || typeof e.checksum != "string" || !("data" in e) ? null : e;
+  } catch {
+    return null;
+  }
+}
+function v(o) {
+  const e = h(o);
+  return e !== null && u(JSON.stringify(e.data)) === e.checksum;
+}
+function w() {
+  try {
+    if (typeof globalThis.localStorage < "u") return new l(globalThis.localStorage);
+  } catch {
+  }
+  return new f();
+}
+export {
+  S as SaveStore
+};
+//# sourceMappingURL=SaveStore.js.map

package/dist/save/SaveStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaveStore.js","sources":["../../src/save/SaveStore.ts"],"sourcesContent":["import { checksum } from './checksum';\nimport { MemoryBackend } from './MemoryBackend';\nimport { MigrationError, migrateSave, type Migrations } from './migrateSave';\nimport type { SaveBackend } from './SaveBackend';\nimport { WebStorageBackend } from './WebStorageBackend';\n\nexport interface SaveStoreOptions {\n  /** The schema version this build writes; older saves go through `migrations` on load. */\n  version: number;\n  /** `migrations[n]` turns data of version n into version n + 1. */\n  migrations?: Migrations;\n  /** Where slots are kept (default `localStorage`, or memory where there is none). */\n  backend?: SaveBackend;\n  /** Prepended to every slot's key, so two games (or a game and its tools) on one origin never share slots. */\n  prefix?: string;\n  /** Keep the slot's previous good save beside it and fall back to it when the slot is corrupt (default true). */\n  backup?: boolean;\n  /** Wall clock for `savedAt` (default `Date.now`). */\n  now?: () => number;\n}\n\n/** What a slot holds besides the game's data: shown on a load screen without loading the save. */\nexport interface SaveInfo {\n  slot: string;\n  version: number;\n  savedAt: number;\n  /** Whatever small summary the game passed to `save` (level reached, play time, a title). */\n  meta: unknown;\n}\n\nexport type LoadFailure = 'missing' | 'corrupt' | 'too-new' | 'no-migration' | 'migration-failed';\n\nexport type LoadResult<T> =\n  | { ok: true; data: T; info: SaveInfo; migrated: boolean; fromBackup: boolean }\n  | { ok: false; slot: string; reason: LoadFailure; error?: unknown };\n\n/**\n * The stored form. `format` marks it as ours; `checksum` covers the JSON of `data`.\n *\n * The tag is `'lantern-save'`, from the engine's old name (Lantern Engine), and stays that on purpose: every save a\n * player already has carries it, and a save read under another tag is refused as corrupt. Changing it would lose them.\n */\ninterface Envelope {\n  format: 'lantern-save';\n  version: number;\n  savedAt: number;\n  meta: unknown;\n  checksum: string;\n  data: unknown;\n}\n\nconst BACKUP = '.bak';\n\n/**\n * Named save slots with a schema version, migrations from older versions, a checksum to catch a damaged slot, and a\n * backup of the previous save to fall back to. Data must be JSON-safe (plain objects, arrays, strings, finite\n * numbers, booleans, null).\n *\n * ```ts\n * const saves = new SaveStore({ version: 3, migrations: { 1: addInventory, 2: renameGold } });\n * await saves.save('slot1', state, { level: 4 });\n * const r = await saves.load<GameState>('slot1');\n * if (r.ok) start(r.data); else if (r.reason !== 'missing') warn(r.reason);\n * ```\n *\n * Writes to one slot are queued in order, so an autosave and a manual save never land the wrong way round.\n */\nexport class SaveStore {\n  readonly version: number;\n  private readonly backend: SaveBackend;\n  private readonly prefix: string;\n  private readonly migrations: Migrations;\n  private readonly backup: boolean;\n  private readonly now: () => number;\n  private readonly queues = new Map<string, Promise<unknown>>();\n\n  constructor(options: SaveStoreOptions) {\n    if (!Number.isInteger(options.version) || options.version < 1) throw new Error('SaveStore: version must be a whole number from 1');\n    this.version = options.version;\n    this.backend = options.backend ?? defaultBackend();\n    this.prefix = options.prefix ?? 'save:';\n    this.migrations = options.migrations ?? {};\n    this.backup = options.backup ?? true;\n    this.now = options.now ?? Date.now;\n  }\n\n  /** Writes `data` to `slot` at the current version. Rejects when the backend does (a full disk, a quota). */\n  save(slot: string, data: unknown, meta: unknown = null): Promise<SaveInfo> {\n    return this.queued(slot, async () => {\n      const key = this.key(slot);\n      const json = JSON.stringify(data);\n      if (json === undefined) throw new Error(`SaveStore: data for \"${slot}\" is not JSON`);\n      const info: SaveInfo = { slot, version: this.version, savedAt: this.now(), meta };\n      const envelope: Envelope = { format: 'lantern-save', version: info.version, savedAt: info.savedAt, meta, checksum: checksum(json), data };\n      if (this.backup) {\n        // only a save that still reads is worth keeping: a damaged one would overwrite the good backup\n        const previous = await this.backend.read(key);\n        if (previous !== null && verify(previous)) await this.backend.write(key + BACKUP, previous);\n      }\n      await this.backend.write(key, JSON.stringify(envelope));\n      return info;\n    });\n  }\n\n  /** Reads `slot`, brought to the current version. Never throws for a bad slot: the result says what went wrong. */\n  load<T>(slot: string): Promise<LoadResult<T>> {\n    return this.queued(slot, async () => {\n      const key = this.key(slot);\n      const main = await this.open<T>(slot, await this.backend.read(key), false);\n      if (main.ok || !this.backup || main.reason !== 'corrupt') return main;\n      const backup = await this.open<T>(slot, await this.backend.read(key + BACKUP), true);\n      return backup.ok ? backup : main;\n    });\n  }\n\n  /** Removes a slot and its backup. */\n  delete(slot: string): Promise<void> {\n    return this.queued(slot, async () => {\n      const key = this.key(slot);\n      await this.backend.remove(key);\n      await this.backend.remove(key + BACKUP);\n    });\n  }\n\n  /** Every slot that reads, newest first, without migrating its data. A damaged slot is left out. */\n  async list(): Promise<SaveInfo[]> {\n    const keys = await this.backend.keys(this.prefix);\n    const out: SaveInfo[] = [];\n    for (const key of keys) {\n      if (key.endsWith(BACKUP)) continue;\n      const raw = await this.backend.read(key);\n      const env = raw === null ? null : parse(raw);\n      if (env && verify(raw!)) out.push({ slot: key.slice(this.prefix.length), version: env.version, savedAt: env.savedAt, meta: env.meta });\n    }\n    return out.sort((a, b) => b.savedAt - a.savedAt);\n  }\n\n  private async open<T>(slot: string, raw: string | null, fromBackup: boolean): Promise<LoadResult<T>> {\n    if (raw === null) return { ok: false, slot, reason: fromBackup ? 'corrupt' : 'missing' };\n    const env = parse(raw);\n    if (!env || checksum(JSON.stringify(env.data)) !== env.checksum) return { ok: false, slot, reason: 'corrupt' };\n    try {\n      const data = migrateSave(env.data, env.version, this.version, this.migrations) as T;\n      const info: SaveInfo = { slot, version: env.version, savedAt: env.savedAt, meta: env.meta };\n      return { ok: true, data, info, migrated: env.version !== this.version, fromBackup };\n    } catch (err) {\n      if (err instanceof MigrationError) return { ok: false, slot, reason: err.reason, error: err };\n      throw err;\n    }\n  }\n\n  private key(slot: string): string {\n    if (!slot || slot.endsWith(BACKUP)) throw new Error(`SaveStore: \"${slot}\" is not a usable slot name`);\n    return this.prefix + slot;\n  }\n\n  private queued<R>(slot: string, job: () => Promise<R>): Promise<R> {\n    const run = (this.queues.get(slot) ?? Promise.resolve()).then(job);\n    const tail = run.catch(() => undefined);\n    this.queues.set(slot, tail);\n    // forget the chain once it is idle, or a game with many slots keeps a promise per slot for good\n    void tail.then(() => {\n      if (this.queues.get(slot) === tail) this.queues.delete(slot);\n    });\n    return run;\n  }\n}\n\nfunction parse(raw: string): Envelope | null {\n  try {\n    const v = JSON.parse(raw) as Partial<Envelope> | null;\n    if (!v || v.format !== 'lantern-save' || typeof v.version !== 'number' || typeof v.checksum !== 'string' || !('data' in v)) return null;\n    return v as Envelope;\n  } catch {\n    return null;\n  }\n}\n\nfunction verify(raw: string): boolean {\n  const env = parse(raw);\n  return env !== null && checksum(JSON.stringify(env.data)) === env.checksum;\n}\n\nfunction defaultBackend(): SaveBackend {\n  try {\n    if (typeof globalThis.localStorage !== 'undefined') return new WebStorageBackend(globalThis.localStorage);\n  } catch {\n    // a sandboxed frame throws on merely reading localStorage\n  }\n  return new MemoryBackend();\n}\n"],"names":["BACKUP","SaveStore","options","defaultBackend","slot","data","meta","key","json","info","envelope","checksum","previous","verify","main","backup","keys","out","raw","env","parse","a","b","fromBackup","migrateSave","err","MigrationError","job","run","tail","v","WebStorageBackend","MemoryBackend"],"mappings":"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"}

package/dist/save/WebStorageBackend.js

@@ -0,0 +1,27 @@
+class a {
+  constructor(e = globalThis.localStorage) {
+    if (this.storage = e, !e) throw new Error("WebStorageBackend: no Web Storage here; pass one or use another backend");
+  }
+  storage;
+  async read(e) {
+    return this.storage.getItem(e);
+  }
+  async write(e, t) {
+    this.storage.setItem(e, t);
+  }
+  async remove(e) {
+    this.storage.removeItem(e);
+  }
+  async keys(e) {
+    const t = [];
+    for (let r = 0; r < this.storage.length; r++) {
+      const s = this.storage.key(r);
+      s !== null && s.startsWith(e) && t.push(s);
+    }
+    return t;
+  }
+}
+export {
+  a as WebStorageBackend
+};
+//# sourceMappingURL=WebStorageBackend.js.map

package/dist/save/WebStorageBackend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebStorageBackend.js","sources":["../../src/save/WebStorageBackend.ts"],"sourcesContent":["import type { SaveBackend } from './SaveBackend';\n\n/**\n * Slots in a Web Storage area, `localStorage` by default. Small and synchronous, so keep saves to a few hundred KB:\n * browsers allow about 5 MB a site, and a write over that throws (reported to the caller of `save`).\n */\nexport class WebStorageBackend implements SaveBackend {\n  constructor(private readonly storage: Storage = globalThis.localStorage) {\n    if (!storage) throw new Error('WebStorageBackend: no Web Storage here; pass one or use another backend');\n  }\n\n  async read(key: string): Promise<string | null> {\n    return this.storage.getItem(key);\n  }\n\n  async write(key: string, value: string): Promise<void> {\n    this.storage.setItem(key, value);\n  }\n\n  async remove(key: string): Promise<void> {\n    this.storage.removeItem(key);\n  }\n\n  async keys(prefix: string): Promise<string[]> {\n    const out: string[] = [];\n    for (let i = 0; i < this.storage.length; i++) {\n      const k = this.storage.key(i);\n      if (k !== null && k.startsWith(prefix)) out.push(k);\n    }\n    return out;\n  }\n}\n"],"names":["WebStorageBackend","storage","key","value","prefix","out","i","k"],"mappings":"AAMO,MAAMA,EAAyC;AAAA,EACpD,YAA6BC,IAAmB,WAAW,cAAc;AACvE,QAD2B,KAAA,UAAAA,GACvB,CAACA,EAAS,OAAM,IAAI,MAAM,yEAAyE;AAAA,EACzG;AAAA,EAF6B;AAAA,EAI7B,MAAM,KAAKC,GAAqC;AAC9C,WAAO,KAAK,QAAQ,QAAQA,CAAG;AAAA,EACjC;AAAA,EAEA,MAAM,MAAMA,GAAaC,GAA8B;AACrD,SAAK,QAAQ,QAAQD,GAAKC,CAAK;AAAA,EACjC;AAAA,EAEA,MAAM,OAAOD,GAA4B;AACvC,SAAK,QAAQ,WAAWA,CAAG;AAAA,EAC7B;AAAA,EAEA,MAAM,KAAKE,GAAmC;AAC5C,UAAMC,IAAgB,CAAA;AACtB,aAASC,IAAI,GAAGA,IAAI,KAAK,QAAQ,QAAQA,KAAK;AAC5C,YAAMC,IAAI,KAAK,QAAQ,IAAID,CAAC;AAC5B,MAAIC,MAAM,QAAQA,EAAE,WAAWH,CAAM,KAAGC,EAAI,KAAKE,CAAC;AAAA,IACpD;AACA,WAAOF;AAAA,EACT;AACF;"}

package/dist/save/checksum.js

@@ -0,0 +1,10 @@
+function h(e) {
+  let t = 2166136261;
+  for (let r = 0; r < e.length; r++)
+    t ^= e.charCodeAt(r), t = Math.imul(t, 16777619);
+  return (t >>> 0).toString(16).padStart(8, "0");
+}
+export {
+  h as checksum
+};
+//# sourceMappingURL=checksum.js.map

package/dist/save/checksum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checksum.js","sources":["../../src/save/checksum.ts"],"sourcesContent":["/**\n * FNV-1a over the UTF-16 code units of `text`, as 8 hex digits. Not a defence against tampering (anyone can\n * recompute it); it catches a slot cut short by a full disk, a crash mid-write or a hand edit gone wrong, which is\n * what a save needs to tell before it loads half a world.\n */\nexport function checksum(text: string): string {\n  let h = 0x811c9dc5;\n  for (let i = 0; i < text.length; i++) {\n    h ^= text.charCodeAt(i);\n    h = Math.imul(h, 0x01000193);\n  }\n  return (h >>> 0).toString(16).padStart(8, '0');\n}\n"],"names":["checksum","text","h","i"],"mappings":"AAKO,SAASA,EAASC,GAAsB;AAC7C,MAAIC,IAAI;AACR,WAASC,IAAI,GAAGA,IAAIF,EAAK,QAAQE;AAC/B,IAAAD,KAAKD,EAAK,WAAWE,CAAC,GACtBD,IAAI,KAAK,KAAKA,GAAG,QAAU;AAE7B,UAAQA,MAAM,GAAG,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;AAC/C;"}

package/dist/save/migrateSave.js

@@ -0,0 +1,27 @@
+class o extends Error {
+  constructor(r, i, t, n) {
+    super(r, n), this.reason = i, this.fromVersion = t, this.name = "MigrationError";
+  }
+  reason;
+  fromVersion;
+}
+function v(s, r, i, t) {
+  if (!Number.isInteger(r) || r > i)
+    throw new o(`save version ${r} is newer than this build reads (${i})`, "too-new", r);
+  let n = s;
+  for (let e = r; e < i; e++) {
+    const a = t[e];
+    if (!a) throw new o(`no migration from save version ${e} to ${e + 1}`, "no-migration", r);
+    try {
+      n = a(n);
+    } catch (h) {
+      throw new o(`migration from save version ${e} failed`, "migration-failed", r, { cause: h });
+    }
+  }
+  return n;
+}
+export {
+  o as MigrationError,
+  v as migrateSave
+};
+//# sourceMappingURL=migrateSave.js.map

package/dist/save/migrateSave.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrateSave.js","sources":["../../src/save/migrateSave.ts"],"sourcesContent":["/** Steps that bring saved data forward one schema version each: `migrations[n]` turns version n into n + 1. */\nexport type Migrations = Readonly<Record<number, (data: unknown) => unknown>>;\n\n/** Why data could not be brought to the current version. */\nexport class MigrationError extends Error {\n  constructor(\n    message: string,\n    readonly reason: 'too-new' | 'no-migration' | 'migration-failed',\n    readonly fromVersion: number,\n    options?: { cause?: unknown },\n  ) {\n    super(message, options);\n    this.name = 'MigrationError';\n  }\n}\n\n/**\n * Runs the chain from `from` up to `to`, one step at a time, so a save three versions old goes through every step\n * written since rather than needing a direct path from each old version. Data newer than the game (a save from a\n * later build, then a downgrade) is refused rather than read wrong.\n */\nexport function migrateSave(data: unknown, from: number, to: number, migrations: Migrations): unknown {\n  if (!Number.isInteger(from) || from > to) {\n    throw new MigrationError(`save version ${from} is newer than this build reads (${to})`, 'too-new', from);\n  }\n  let value = data;\n  for (let v = from; v < to; v++) {\n    const step = migrations[v];\n    if (!step) throw new MigrationError(`no migration from save version ${v} to ${v + 1}`, 'no-migration', from);\n    try {\n      value = step(value);\n    } catch (err) {\n      throw new MigrationError(`migration from save version ${v} failed`, 'migration-failed', from, { cause: err });\n    }\n  }\n  return value;\n}\n"],"names":["MigrationError","message","reason","fromVersion","options","migrateSave","data","from","to","migrations","value","v","step","err"],"mappings":"AAIO,MAAMA,UAAuB,MAAM;AAAA,EACxC,YACEC,GACSC,GACAC,GACTC,GACA;AACA,UAAMH,GAASG,CAAO,GAJb,KAAA,SAAAF,GACA,KAAA,cAAAC,GAIT,KAAK,OAAO;AAAA,EACd;AAAA,EANW;AAAA,EACA;AAMb;AAOO,SAASE,EAAYC,GAAeC,GAAcC,GAAYC,GAAiC;AACpG,MAAI,CAAC,OAAO,UAAUF,CAAI,KAAKA,IAAOC;AACpC,UAAM,IAAIR,EAAe,gBAAgBO,CAAI,oCAAoCC,CAAE,KAAK,WAAWD,CAAI;AAEzG,MAAIG,IAAQJ;AACZ,WAASK,IAAIJ,GAAMI,IAAIH,GAAIG,KAAK;AAC9B,UAAMC,IAAOH,EAAWE,CAAC;AACzB,QAAI,CAACC,EAAM,OAAM,IAAIZ,EAAe,kCAAkCW,CAAC,OAAOA,IAAI,CAAC,IAAI,gBAAgBJ,CAAI;AAC3G,QAAI;AACF,MAAAG,IAAQE,EAAKF,CAAK;AAAA,IACpB,SAASG,GAAK;AACZ,YAAM,IAAIb,EAAe,+BAA+BW,CAAC,WAAW,oBAAoBJ,GAAM,EAAE,OAAOM,EAAA,CAAK;AAAA,IAC9G;AAAA,EACF;AACA,SAAOH;AACT;"}

package/dist/settings.js

@@ -0,0 +1,27 @@
+const r = {
+  reducedFx: !1,
+  batterySaver: !1,
+  combatLights: !0,
+  sfxVolume: 0.8,
+  musicVolume: 0.6
+};
+let t = { ...r };
+const s = /* @__PURE__ */ new Set(), o = {
+  getState() {
+    return t;
+  },
+  set(e) {
+    t = { ...t, ...e };
+    for (const n of [...s]) n(t);
+  },
+  subscribe(e) {
+    return s.add(e), () => s.delete(e);
+  },
+  reset() {
+    o.set(r);
+  }
+};
+export {
+  o as engineSettings
+};
+//# sourceMappingURL=settings.js.map

package/dist/settings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.js","sources":["../src/settings.ts"],"sourcesContent":["/**\n * The few player settings the engine itself reads. A game keeps its own settings store and mirrors these fields\n * into this one (`engineSettings.set`) whenever they change; the engine never reads the game's store.\n */\nexport interface EngineSettings {\n  /** Fewer particles and lighter effects. */\n  reducedFx: boolean;\n  /** Turns off everything that only costs battery: transient lights, heavy particles. */\n  batterySaver: boolean;\n  /** Short-lived lights a fight throws into the dark (`pixel/lights.ts`). */\n  combatLights: boolean;\n  /** 0–1, the combat sounds' volume (`audio/SoundEngine.ts`). */\n  sfxVolume: number;\n  /** 0–1, the music's volume. */\n  musicVolume: number;\n}\n\nexport type SettingsListener = (s: EngineSettings) => void;\n\nconst DEFAULTS: EngineSettings = {\n  reducedFx: false,\n  batterySaver: false,\n  combatLights: true,\n  sfxVolume: 0.8,\n  musicVolume: 0.6,\n};\n\nlet state: EngineSettings = { ...DEFAULTS };\nconst listeners = new Set<SettingsListener>();\n\n/** Same shape as the zustand stores the game used (`getState`, `subscribe`), so moved code reads it unchanged. */\nexport const engineSettings = {\n  getState(): EngineSettings {\n    return state;\n  },\n  set(patch: Partial<EngineSettings>): void {\n    state = { ...state, ...patch };\n    for (const l of [...listeners]) l(state);\n  },\n  subscribe(listener: SettingsListener): () => void {\n    listeners.add(listener);\n    return () => listeners.delete(listener);\n  },\n  reset(): void {\n    engineSettings.set(DEFAULTS);\n  },\n};\n"],"names":["DEFAULTS","state","listeners","engineSettings","patch","l","listener"],"mappings":"AAmBA,MAAMA,IAA2B;AAAA,EAC/B,WAAW;AAAA,EACX,cAAc;AAAA,EACd,cAAc;AAAA,EACd,WAAW;AAAA,EACX,aAAa;AACf;AAEA,IAAIC,IAAwB,EAAE,GAAGD,EAAA;AACjC,MAAME,wBAAgB,IAAA,GAGTC,IAAiB;AAAA,EAC5B,WAA2B;AACzB,WAAOF;AAAA,EACT;AAAA,EACA,IAAIG,GAAsC;AACxC,IAAAH,IAAQ,EAAE,GAAGA,GAAO,GAAGG,EAAA;AACvB,eAAWC,KAAK,CAAC,GAAGH,CAAS,KAAKD,CAAK;AAAA,EACzC;AAAA,EACA,UAAUK,GAAwC;AAChD,WAAAJ,EAAU,IAAII,CAAQ,GACf,MAAMJ,EAAU,OAAOI,CAAQ;AAAA,EACxC;AAAA,EACA,QAAc;AACZ,IAAAH,EAAe,IAAIH,CAAQ;AAAA,EAC7B;AACF;"}

package/dist/tilemap/TilemapView.js

@@ -0,0 +1,69 @@
+import { Container as M, Sprite as P } from "pixi.js";
+import { tileAt as F, tileRect as H, FLIP_D as V, FLIP_H as $, FLIP_V as L } from "./tiled.js";
+let S = 0;
+class T {
+  constructor(s, i, e = {}) {
+    this.stage = s, this.map = i;
+    const p = e.textureFor ?? ((t) => t.name), r = Math.max(1, e.chunkTiles ?? 32), m = e.baseDepth ?? -1e6, w = e.layers ? new Set(e.layers) : null, c = i.layers.filter((t) => t.kind === "tiles" && (w ? w.has(t.name) : t.visible)), f = e.parent ?? s.world;
+    c.forEach((t, y) => {
+      const x = typeof t.properties.depth == "number" ? t.properties.depth : m + y, l = new M();
+      l.zIndex = x, l.alpha = t.opacity, l.position.set(t.offsetX, t.offsetY), this.layers.set(t.name, l), f.addChild(l);
+      for (let n = 0; n < i.height; n += r)
+        for (let a = 0; a < i.width; a += r) {
+          const o = Math.min(r, i.width - a), d = Math.min(r, i.height - n);
+          this.paintChunk(t, l, a, n, o, d, p);
+        }
+    });
+  }
+  stage;
+  map;
+  /** One container per drawn tile layer, by name, each at its own depth among the bodies. */
+  layers = /* @__PURE__ */ new Map();
+  chunks = [];
+  id = S++;
+  /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */
+  update(s = 32) {
+    const i = this.stage.cameras.main.worldView;
+    for (const e of this.chunks)
+      e.sprite.visible = e.x < i.right + s && e.x + e.w > i.x - s && e.y < i.bottom + s && e.y + e.h > i.y - s;
+  }
+  /** World size of the map in px. */
+  get widthPx() {
+    return this.map.width * this.map.tileWidth;
+  }
+  get heightPx() {
+    return this.map.height * this.map.tileHeight;
+  }
+  destroy() {
+    for (const s of this.chunks) this.stage.textures.remove(s.key);
+    this.chunks.length = 0;
+    for (const s of this.layers.values()) s.destroy({ children: !0 });
+    this.layers.clear();
+  }
+  paintChunk(s, i, e, p, r, m, w) {
+    const { map: c } = this, f = c.tileWidth, t = c.tileHeight;
+    let y = !1;
+    const x = `tilemap:${this.id}:${s.name}:${e},${p}`, n = Math.max(t, ...c.tilesets.map((u) => u.tileHeight)) - t, a = this.stage.textures.createCanvas(x, r * f, m * t + n), o = a.context;
+    o.imageSmoothingEnabled = !1;
+    for (let u = 0; u < m; u++)
+      for (let k = 0; k < r; k++) {
+        const v = s.data[(p + u) * c.width + (e + k)], g = F(c, v);
+        if (!g) continue;
+        const b = this.stage.textures.exists(w(g.tileset)) ? this.stage.textures.get(w(g.tileset)).source.resource : null;
+        if (!b) continue;
+        const h = H(g.tileset, g.local), C = k * f, I = n + (u + 1) * t - h.h;
+        o.save(), o.translate(C + h.w / 2, I + h.h / 2), v & V && o.transform(0, 1, 1, 0, 0, 0), o.scale(v & $ ? -1 : 1, v & L ? -1 : 1), o.drawImage(b, h.x, h.y, h.w, h.h, -h.w / 2, -h.h / 2, h.w, h.h), o.restore(), y = !0;
+      }
+    if (!y) {
+      this.stage.textures.remove(x);
+      return;
+    }
+    a.refresh();
+    const d = new P(a.whole);
+    d.position.set(e * f, p * t - n), i.addChild(d), this.chunks.push({ sprite: d, x: d.x + s.offsetX, y: d.y + s.offsetY, w: r * f, h: m * t + n, key: x });
+  }
+}
+export {
+  T as TilemapView
+};
+//# sourceMappingURL=TilemapView.js.map

package/dist/tilemap/TilemapView.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TilemapView.js","sources":["../../src/tilemap/TilemapView.ts"],"sourcesContent":["import { Container, Sprite } from 'pixi.js';\nimport type { Stage } from '../core/Stage';\nimport { FLIP_D, FLIP_H, FLIP_V, tileAt, tileRect, type TileLayer, type TileMap, type Tileset } from './tiled';\n\nexport interface TilemapViewOptions {\n  /** The texture key holding a tileset's image (loaded with `AssetLoader.image`, or painted). Default: `tileset.name`. */\n  textureFor?: (tileset: Tileset) => string;\n  /** Tiles per chunk side (default 32): each chunk is painted once into a texture of its own. */\n  chunkTiles?: number;\n  /** Only these tile layers, by name; default every visible tile layer. */\n  layers?: string[];\n  /**\n   * Depth of the first layer in the world layer; each layer after it one higher. Bodies are usually drawn at their y,\n   * so the default keeps the map under every one of them. A layer with a numeric `depth` property is drawn there\n   * instead (a roof layer over the bodies: `depth` = 1e6).\n   */\n  baseDepth?: number;\n  /** Where the layers go (default the stage's world layer); a scene passes its `root` so they leave with it. */\n  parent?: Container;\n}\n\nlet nextView = 0;\n\n/**\n * Draws a Tiled map's tile layers. Each layer is cut into chunks painted once into textures; a frame only toggles\n * which chunks are in view (`update`), so a map of any size costs a handful of sprites a frame.\n *\n * Animated tiles are drawn on their first frame.\n */\nexport class TilemapView {\n  /** One container per drawn tile layer, by name, each at its own depth among the bodies. */\n  readonly layers = new Map<string, Container>();\n  private readonly chunks: { sprite: Sprite; x: number; y: number; w: number; h: number; key: string }[] = [];\n  private readonly id = nextView++;\n\n  constructor(\n    private readonly stage: Stage,\n    readonly map: TileMap,\n    options: TilemapViewOptions = {},\n  ) {\n    const textureFor = options.textureFor ?? ((ts: Tileset) => ts.name);\n    const chunk = Math.max(1, options.chunkTiles ?? 32);\n    const base = options.baseDepth ?? -1_000_000;\n    const wanted = options.layers ? new Set(options.layers) : null;\n    const layers = map.layers.filter((l): l is TileLayer => l.kind === 'tiles' && (wanted ? wanted.has(l.name) : l.visible));\n    const parent = options.parent ?? stage.world;\n    layers.forEach((layer, n) => {\n      const depth = typeof layer.properties.depth === 'number' ? layer.properties.depth : base + n;\n      const holder = new Container();\n      holder.zIndex = depth;\n      holder.alpha = layer.opacity;\n      holder.position.set(layer.offsetX, layer.offsetY);\n      this.layers.set(layer.name, holder);\n      parent.addChild(holder);\n      for (let cy = 0; cy < map.height; cy += chunk) {\n        for (let cx = 0; cx < map.width; cx += chunk) {\n          const cw = Math.min(chunk, map.width - cx);\n          const ch = Math.min(chunk, map.height - cy);\n          this.paintChunk(layer, holder, cx, cy, cw, ch, textureFor);\n        }\n      }\n    });\n  }\n\n  /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */\n  update(margin = 32): void {\n    const v = this.stage.cameras.main.worldView;\n    for (const c of this.chunks) {\n      c.sprite.visible = c.x < v.right + margin && c.x + c.w > v.x - margin && c.y < v.bottom + margin && c.y + c.h > v.y - margin;\n    }\n  }\n\n  /** World size of the map in px. */\n  get widthPx(): number {\n    return this.map.width * this.map.tileWidth;\n  }\n\n  get heightPx(): number {\n    return this.map.height * this.map.tileHeight;\n  }\n\n  destroy(): void {\n    for (const c of this.chunks) this.stage.textures.remove(c.key);\n    this.chunks.length = 0;\n    for (const c of this.layers.values()) c.destroy({ children: true });\n    this.layers.clear();\n  }\n\n  private paintChunk(layer: TileLayer, holder: Container, cx: number, cy: number, cw: number, ch: number, textureFor: (ts: Tileset) => string): void {\n    const { map } = this;\n    const tw = map.tileWidth;\n    const th = map.tileHeight;\n    let any = false;\n    const key = `tilemap:${this.id}:${layer.name}:${cx},${cy}`;\n    // tiles taller than the grid (trees on a 16 px grid) overhang the cell above, so the chunk has room for them\n    const tallest = Math.max(th, ...map.tilesets.map((t) => t.tileHeight));\n    const pad = tallest - th;\n    const tex = this.stage.textures.createCanvas(key, cw * tw, ch * th + pad);\n    const ctx = tex.context;\n    ctx.imageSmoothingEnabled = false;\n    for (let y = 0; y < ch; y++) {\n      for (let x = 0; x < cw; x++) {\n        const raw = layer.data[(cy + y) * map.width + (cx + x)]!;\n        const t = tileAt(map, raw);\n        if (!t) continue;\n        const src = this.stage.textures.exists(textureFor(t.tileset)) ? this.stage.textures.get(textureFor(t.tileset)).source.resource : null;\n        if (!src) continue;\n        const r = tileRect(t.tileset, t.local);\n        // a tile is drawn on its cell's bottom-left corner, as Tiled does\n        const dx = x * tw;\n        const dy = pad + (y + 1) * th - r.h;\n        ctx.save();\n        ctx.translate(dx + r.w / 2, dy + r.h / 2);\n        if (raw & FLIP_D) ctx.transform(0, 1, 1, 0, 0, 0);\n        ctx.scale(raw & FLIP_H ? -1 : 1, raw & FLIP_V ? -1 : 1);\n        ctx.drawImage(src as CanvasImageSource, r.x, r.y, r.w, r.h, -r.w / 2, -r.h / 2, r.w, r.h);\n        ctx.restore();\n        any = true;\n      }\n    }\n    if (!any) {\n      this.stage.textures.remove(key);\n      return;\n    }\n    tex.refresh();\n    const sprite = new Sprite(tex.whole);\n    sprite.position.set(cx * tw, cy * th - pad);\n    holder.addChild(sprite);\n    this.chunks.push({ sprite, x: sprite.x + layer.offsetX, y: sprite.y + layer.offsetY, w: cw * tw, h: ch * th + pad, key });\n  }\n}\n"],"names":["nextView","TilemapView","stage","map","options","textureFor","ts","chunk","base","wanted","layers","l","parent","layer","n","depth","holder","Container","cy","cx","cw","ch","margin","v","c","tw","th","any","key","pad","t","tex","ctx","y","x","raw","tileAt","src","r","tileRect","dx","dy","FLIP_D","FLIP_H","FLIP_V","sprite","Sprite"],"mappings":"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"}

package/dist/tilemap/collision.js

@@ -0,0 +1,25 @@
+import { createCollisionGrid as c } from "../net/movement.js";
+import { gidOf as h, tileAt as y } from "./tiled.js";
+function w(i, s = {}) {
+  if (i.tileWidth !== i.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${i.tileWidth}x${i.tileHeight}`);
+  const l = s.solid ?? (i.layers.some((e) => e.kind === "tiles" && e.name === "collision") ? "collision" : { property: "solid" }), o = i.width * i.height, r = new Uint8Array(o);
+  if (typeof l == "string") {
+    const e = i.layers.find((t) => t.kind === "tiles" && t.name === l);
+    if (!e || e.kind !== "tiles") throw new Error(`Tiled map: no tile layer named "${l}"`);
+    for (let t = 0; t < o; t++) h(e.data[t]) !== 0 && (r[t] = 1);
+  } else
+    for (const e of i.layers)
+      if (e.kind === "tiles")
+        for (let t = 0; t < o; t++) {
+          const n = y(i, e.data[t]);
+          n && n.tileset.tileProperties.get(n.local)?.[l.property] === !0 && (r[t] = 1);
+        }
+  let d = "";
+  for (let e = 0; e < o; e++) d += r[e] ? "1" : "0";
+  const { solid: g, ...f } = s;
+  return c(i.width, i.height, i.tileWidth, d, f);
+}
+export {
+  w as collisionFromTiled
+};
+//# sourceMappingURL=collision.js.map

package/dist/tilemap/collision.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.js","sources":["../../src/tilemap/collision.ts"],"sourcesContent":["import { createCollisionGrid, type CollisionGrid, type CollisionGridOptions } from '../net/movement';\nimport { gidOf, tileAt, type TileMap } from './tiled';\n\nexport interface TiledCollisionOptions extends Omit<CollisionGridOptions, 'ground'> {\n  /**\n   * What makes a cell solid:\n   * - a layer name: every non-empty cell of that tile layer is solid (a hidden \"collision\" layer is the usual way);\n   * - `{ property }`: a cell is solid when its tile has that custom property set to true, on any tile layer.\n   * Default: the layer named \"collision\" if there is one, else tiles with a `solid` property.\n   */\n  solid?: string | { property: string };\n}\n\n/** The `CollisionGrid` of a Tiled map, for `stepMover`; cells are the map's tiles. */\nexport function collisionFromTiled(map: TileMap, options: TiledCollisionOptions = {}): CollisionGrid {\n  if (map.tileWidth !== map.tileHeight) throw new Error(`Tiled map: collision needs square tiles, not ${map.tileWidth}x${map.tileHeight}`);\n  const rule = options.solid ?? (map.layers.some((l) => l.kind === 'tiles' && l.name === 'collision') ? 'collision' : { property: 'solid' });\n  const cells = map.width * map.height;\n  const solid = new Uint8Array(cells);\n  if (typeof rule === 'string') {\n    const layer = map.layers.find((l) => l.kind === 'tiles' && l.name === rule);\n    if (!layer || layer.kind !== 'tiles') throw new Error(`Tiled map: no tile layer named \"${rule}\"`);\n    for (let i = 0; i < cells; i++) if (gidOf(layer.data[i]!) !== 0) solid[i] = 1;\n  } else {\n    for (const layer of map.layers) {\n      if (layer.kind !== 'tiles') continue;\n      for (let i = 0; i < cells; i++) {\n        const t = tileAt(map, layer.data[i]!);\n        if (t && t.tileset.tileProperties.get(t.local)?.[rule.property] === true) solid[i] = 1;\n      }\n    }\n  }\n  let s = '';\n  for (let i = 0; i < cells; i++) s += solid[i] ? '1' : '0';\n  const { solid: _rule, ...gridOptions } = options;\n  return createCollisionGrid(map.width, map.height, map.tileWidth, s, gridOptions);\n}\n"],"names":["collisionFromTiled","map","options","rule","l","cells","solid","layer","i","gidOf","t","tileAt","s","_rule","gridOptions","createCollisionGrid"],"mappings":";;AAcO,SAASA,EAAmBC,GAAcC,IAAiC,IAAmB;AACnG,MAAID,EAAI,cAAcA,EAAI,WAAY,OAAM,IAAI,MAAM,gDAAgDA,EAAI,SAAS,IAAIA,EAAI,UAAU,EAAE;AACvI,QAAME,IAAOD,EAAQ,UAAUD,EAAI,OAAO,KAAK,CAACG,MAAMA,EAAE,SAAS,WAAWA,EAAE,SAAS,WAAW,IAAI,cAAc,EAAE,UAAU,YAC1HC,IAAQJ,EAAI,QAAQA,EAAI,QACxBK,IAAQ,IAAI,WAAWD,CAAK;AAClC,MAAI,OAAOF,KAAS,UAAU;AAC5B,UAAMI,IAAQN,EAAI,OAAO,KAAK,CAACG,MAAMA,EAAE,SAAS,WAAWA,EAAE,SAASD,CAAI;AAC1E,QAAI,CAACI,KAASA,EAAM,SAAS,eAAe,IAAI,MAAM,mCAAmCJ,CAAI,GAAG;AAChG,aAASK,IAAI,GAAGA,IAAIH,GAAOG,IAAK,CAAIC,EAAMF,EAAM,KAAKC,CAAC,CAAE,MAAM,MAAGF,EAAME,CAAC,IAAI;AAAA,EAC9E;AACE,eAAWD,KAASN,EAAI;AACtB,UAAIM,EAAM,SAAS;AACnB,iBAASC,IAAI,GAAGA,IAAIH,GAAOG,KAAK;AAC9B,gBAAME,IAAIC,EAAOV,GAAKM,EAAM,KAAKC,CAAC,CAAE;AACpC,UAAIE,KAAKA,EAAE,QAAQ,eAAe,IAAIA,EAAE,KAAK,IAAIP,EAAK,QAAQ,MAAM,OAAMG,EAAME,CAAC,IAAI;AAAA,QACvF;AAGJ,MAAII,IAAI;AACR,WAASJ,IAAI,GAAGA,IAAIH,GAAOG,IAAK,CAAAI,KAAKN,EAAME,CAAC,IAAI,MAAM;AACtD,QAAM,EAAE,OAAOK,GAAO,GAAGC,MAAgBZ;AACzC,SAAOa,EAAoBd,EAAI,OAAOA,EAAI,QAAQA,EAAI,WAAWW,GAAGE,CAAW;AACjF;"}

package/dist/tilemap/tiled.js

@@ -0,0 +1,138 @@
+const b = 2147483648, w = 1073741824, A = 536870912;
+const g = (e) => e & 536870911;
+function j(e, t) {
+  const i = g(t);
+  if (i === 0) return null;
+  let n = null;
+  for (const r of e.tilesets) r.firstGid <= i && (!n || r.firstGid > n.firstGid) && (n = r);
+  return !n || i - n.firstGid >= n.tileCount ? null : { tileset: n, local: i - n.firstGid };
+}
+function x(e, t) {
+  const i = t % e.columns, n = Math.floor(t / e.columns);
+  return { x: e.margin + i * (e.tileWidth + e.spacing), y: e.margin + n * (e.tileHeight + e.spacing), w: e.tileWidth, h: e.tileHeight };
+}
+function $(e, t) {
+  return e.layers.find((i) => i.name === t);
+}
+function N(e, t) {
+  const i = [];
+  for (const n of e.layers) if (n.kind === "objects")
+    for (const r of n.objects) (t === void 0 || r.type === t) && i.push(r);
+  return i;
+}
+class a extends Error {
+  constructor(t) {
+    super(`Tiled map: ${t}`);
+  }
+}
+function l(e) {
+  const t = {};
+  if (!Array.isArray(e)) return t;
+  for (const i of e) i && typeof i.name == "string" && ["string", "number", "boolean"].includes(typeof i.value) && (t[i.name] = i.value);
+  return t;
+}
+function o(e, t) {
+  if (typeof e != "number" || !Number.isFinite(e)) throw new a(`${t} must be a number`);
+  return e;
+}
+function d(e) {
+  if (typeof atob == "function") {
+    const t = atob(e.trim()), i = new Uint8Array(t.length);
+    for (let n = 0; n < t.length; n++) i[n] = t.charCodeAt(n);
+    return i;
+  }
+  return new Uint8Array(globalThis.Buffer.from(e, "base64"));
+}
+function h(e, t) {
+  if (e.compression) throw new a(`layer "${e.name}" is ${e.compression}-compressed; save it as CSV or uncompressed base64`);
+  let i;
+  if (e.encoding === "base64") {
+    const n = d(String(e.data));
+    if (n.length !== t * 4) throw new a(`layer "${e.name}" holds ${n.length / 4} cells, not ${t}`);
+    const r = new DataView(n.buffer, n.byteOffset, n.byteLength);
+    i = new Uint32Array(t);
+    for (let s = 0; s < t; s++) i[s] = r.getUint32(s * 4, !0);
+  } else {
+    if (!Array.isArray(e.data) || e.data.length !== t) throw new a(`layer "${e.name}" must hold ${t} cells`);
+    i = Uint32Array.from(e.data);
+  }
+  return i;
+}
+function m(e) {
+  const t = {
+    id: o(e.id, "object id"),
+    name: String(e.name ?? ""),
+    type: String(e.type ?? e.class ?? ""),
+    x: o(e.x, "object x"),
+    y: o(e.y, "object y"),
+    width: Number(e.width ?? 0),
+    height: Number(e.height ?? 0),
+    rotation: Number(e.rotation ?? 0),
+    point: e.point === !0,
+    ellipse: e.ellipse === !0,
+    properties: l(e.properties)
+  };
+  return typeof e.gid == "number" && (t.gid = e.gid), Array.isArray(e.polygon) && (t.polygon = e.polygon.map((i) => ({ x: o(i.x, "polygon x"), y: o(i.y, "polygon y") }))), t;
+}
+function u(e, t, i, n = { visible: !0, opacity: 1, x: 0, y: 0 }) {
+  if (Array.isArray(e))
+    for (const r of e) {
+      const s = n.visible && r.visible !== !1, c = n.opacity * (typeof r.opacity == "number" ? r.opacity : 1), f = n.x + Number(r.offsetx ?? 0), p = n.y + Number(r.offsety ?? 0);
+      r.type === "tilelayer" ? i.push({ kind: "tiles", name: String(r.name ?? ""), data: h(r, t.width * t.height), visible: s, opacity: c, offsetX: f, offsetY: p, properties: l(r.properties) }) : r.type === "objectgroup" ? i.push({ kind: "objects", name: String(r.name ?? ""), objects: (r.objects ?? []).map(m), visible: s, properties: l(r.properties) }) : r.type === "group" && u(r.layers, t, i, { visible: s, opacity: c, x: f, y: p });
+    }
+}
+function y(e) {
+  if (typeof e.source == "string") throw new a(`tileset "${e.source}" is external; embed it in the map (Map → Embed Tilesets)`);
+  if (typeof e.image != "string") throw new a(`tileset "${e.name}" is a collection of images; use a single-image tileset`);
+  const t = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+  for (const n of e.tiles ?? []) {
+    const r = o(n.id, "tile id");
+    n.properties && t.set(r, l(n.properties)), Array.isArray(n.animation) && i.set(r, n.animation.map((s) => ({ tileId: o(s.tileid, "animation tileid"), duration: o(s.duration, "animation duration") })));
+  }
+  return {
+    name: String(e.name ?? ""),
+    firstGid: o(e.firstgid, "tileset firstgid"),
+    image: e.image,
+    imageWidth: o(e.imagewidth, "tileset imagewidth"),
+    imageHeight: o(e.imageheight, "tileset imageheight"),
+    tileWidth: o(e.tilewidth, "tileset tilewidth"),
+    tileHeight: o(e.tileheight, "tileset tileheight"),
+    columns: o(e.columns, "tileset columns"),
+    tileCount: o(e.tilecount, "tileset tilecount"),
+    margin: Number(e.margin ?? 0),
+    spacing: Number(e.spacing ?? 0),
+    tileProperties: t,
+    animations: i,
+    properties: l(e.properties)
+  };
+}
+function S(e) {
+  const t = e;
+  if (!t || typeof t != "object") throw new a("not a JSON object");
+  if (t.infinite) throw new a("infinite maps are not supported; uncheck Map → Map Properties → Infinite");
+  if (t.orientation && t.orientation !== "orthogonal") throw new a(`${t.orientation} maps are not supported, only orthogonal`);
+  const i = o(t.width, "width"), n = o(t.height, "height"), r = [];
+  u(t.layers, { width: i, height: n }, r);
+  const s = {
+    width: i,
+    height: n,
+    tileWidth: o(t.tilewidth, "tilewidth"),
+    tileHeight: o(t.tileheight, "tileheight"),
+    layers: r,
+    tilesets: (t.tilesets ?? []).map(y),
+    properties: l(t.properties)
+  };
+  return typeof t.backgroundcolor == "string" && (s.backgroundColor = t.backgroundcolor), s;
+}
+export {
+  A as FLIP_D,
+  b as FLIP_H,
+  w as FLIP_V,
+  g as gidOf,
+  $ as layerByName,
+  N as objectsOf,
+  S as parseTiled,
+  j as tileAt,
+  x as tileRect
+};
+//# sourceMappingURL=tiled.js.map

package/dist/tilemap/tiled.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiled.js","sources":["../../src/tilemap/tiled.ts"],"sourcesContent":["/**\n * Maps made in Tiled (https://www.mapeditor.org), read from its JSON format (`.tmj`, or `.json`). Supported:\n * orthogonal, finite maps; tile layers as CSV arrays or uncompressed base64; object layers; group layers (flattened);\n * custom properties; flipped tiles. Not supported (refused with a message saying so): infinite maps, compressed layer\n * data, isometric and hexagonal maps, external `.tsj` tilesets (embed them: Map → Embed Tilesets).\n *\n * Pure: no Pixi, no DOM, so a server can read the same map for collision.\n */\n\n/** The three flags Tiled keeps in a gid's high bits; the rest is the tile id. */\nexport const FLIP_H = 0x80000000;\nexport const FLIP_V = 0x40000000;\nexport const FLIP_D = 0x20000000;\nconst GID_MASK = 0x1fffffff;\n\nexport type TiledPropertyValue = string | number | boolean;\nexport type Properties = Record<string, TiledPropertyValue>;\n\nexport interface TileLayer {\n  kind: 'tiles';\n  name: string;\n  /** Row-major gids (0 = empty), flip flags kept. Read the tile id with `gidOf`. */\n  data: Uint32Array;\n  visible: boolean;\n  opacity: number;\n  offsetX: number;\n  offsetY: number;\n  properties: Properties;\n}\n\nexport interface MapObject {\n  id: number;\n  name: string;\n  type: string;\n  x: number;\n  y: number;\n  width: number;\n  height: number;\n  rotation: number;\n  /** A tile object's gid, if it is one. */\n  gid?: number;\n  point: boolean;\n  ellipse: boolean;\n  polygon?: { x: number; y: number }[];\n  properties: Properties;\n}\n\nexport interface ObjectLayer {\n  kind: 'objects';\n  name: string;\n  objects: MapObject[];\n  visible: boolean;\n  properties: Properties;\n}\n\nexport type MapLayer = TileLayer | ObjectLayer;\n\nexport interface Tileset {\n  name: string;\n  firstGid: number;\n  /** The image's path as written in the map, relative to the map file. */\n  image: string;\n  imageWidth: number;\n  imageHeight: number;\n  tileWidth: number;\n  tileHeight: number;\n  columns: number;\n  tileCount: number;\n  margin: number;\n  spacing: number;\n  /** Per local tile id: its custom properties. */\n  tileProperties: Map<number, Properties>;\n  /** Per local tile id: an animation (local tile ids and how long each shows, ms). */\n  animations: Map<number, { tileId: number; duration: number }[]>;\n  properties: Properties;\n}\n\nexport interface TileMap {\n  width: number;\n  height: number;\n  tileWidth: number;\n  tileHeight: number;\n  layers: MapLayer[];\n  tilesets: Tileset[];\n  properties: Properties;\n  backgroundColor?: string;\n}\n\n/** The tile id of a gid, without its flip flags. */\nexport const gidOf = (raw: number): number => raw & GID_MASK;\n\n/** Which tileset a gid belongs to, and the tile's id inside it; null for an empty cell or an unknown gid. */\nexport function tileAt(map: TileMap, raw: number): { tileset: Tileset; local: number } | null {\n  const gid = gidOf(raw);\n  if (gid === 0) return null;\n  let found: Tileset | null = null;\n  for (const ts of map.tilesets) if (ts.firstGid <= gid && (!found || ts.firstGid > found.firstGid)) found = ts;\n  if (!found || gid - found.firstGid >= found.tileCount) return null;\n  return { tileset: found, local: gid - found.firstGid };\n}\n\n/** Where tile `local` sits in its tileset image. */\nexport function tileRect(ts: Tileset, local: number): { x: number; y: number; w: number; h: number } {\n  const col = local % ts.columns;\n  const row = Math.floor(local / ts.columns);\n  return { x: ts.margin + col * (ts.tileWidth + ts.spacing), y: ts.margin + row * (ts.tileHeight + ts.spacing), w: ts.tileWidth, h: ts.tileHeight };\n}\n\nexport function layerByName(map: TileMap, name: string): MapLayer | undefined {\n  return map.layers.find((l) => l.name === name);\n}\n\n/** Every object of every object layer (optionally only those of one `type`/class). */\nexport function objectsOf(map: TileMap, type?: string): MapObject[] {\n  const out: MapObject[] = [];\n  for (const l of map.layers) if (l.kind === 'objects') for (const o of l.objects) if (type === undefined || o.type === type) out.push(o);\n  return out;\n}\n\n// ── Parsing ─────────────────────────────────────────────────────────────────────────────────────────────────────────\n\n/* eslint-disable @typescript-eslint/no-explicit-any -- the input is untrusted JSON, checked field by field below */\ntype Json = any;\n\nclass TiledError extends Error {\n  constructor(message: string) {\n    super(`Tiled map: ${message}`);\n  }\n}\n\nfunction props(list: Json): Properties {\n  const out: Properties = {};\n  if (!Array.isArray(list)) return out;\n  for (const p of list) if (p && typeof p.name === 'string' && ['string', 'number', 'boolean'].includes(typeof p.value)) out[p.name] = p.value;\n  return out;\n}\n\nfunction num(v: Json, what: string): number {\n  if (typeof v !== 'number' || !Number.isFinite(v)) throw new TiledError(`${what} must be a number`);\n  return v;\n}\n\nfunction decodeBase64(text: string): Uint8Array {\n  if (typeof atob === 'function') {\n    const bin = atob(text.trim());\n    const out = new Uint8Array(bin.length);\n    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);\n    return out;\n  }\n  return new Uint8Array((globalThis as Json).Buffer.from(text, 'base64'));\n}\n\nfunction layerData(l: Json, cells: number): Uint32Array {\n  if (l.compression) throw new TiledError(`layer \"${l.name}\" is ${l.compression}-compressed; save it as CSV or uncompressed base64`);\n  let data: Uint32Array;\n  if (l.encoding === 'base64') {\n    const bytes = decodeBase64(String(l.data));\n    if (bytes.length !== cells * 4) throw new TiledError(`layer \"${l.name}\" holds ${bytes.length / 4} cells, not ${cells}`);\n    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);\n    data = new Uint32Array(cells);\n    for (let i = 0; i < cells; i++) data[i] = view.getUint32(i * 4, true);\n  } else {\n    if (!Array.isArray(l.data) || l.data.length !== cells) throw new TiledError(`layer \"${l.name}\" must hold ${cells} cells`);\n    data = Uint32Array.from(l.data as number[]);\n  }\n  return data;\n}\n\nfunction parseObject(o: Json): MapObject {\n  const obj: MapObject = {\n    id: num(o.id, 'object id'),\n    name: String(o.name ?? ''),\n    type: String(o.type ?? o.class ?? ''),\n    x: num(o.x, 'object x'),\n    y: num(o.y, 'object y'),\n    width: Number(o.width ?? 0),\n    height: Number(o.height ?? 0),\n    rotation: Number(o.rotation ?? 0),\n    point: o.point === true,\n    ellipse: o.ellipse === true,\n    properties: props(o.properties),\n  };\n  if (typeof o.gid === 'number') obj.gid = o.gid;\n  if (Array.isArray(o.polygon)) obj.polygon = o.polygon.map((p: Json) => ({ x: num(p.x, 'polygon x'), y: num(p.y, 'polygon y') }));\n  return obj;\n}\n\nfunction parseLayers(list: Json, map: { width: number; height: number }, out: MapLayer[], parent = { visible: true, opacity: 1, x: 0, y: 0 }): void {\n  if (!Array.isArray(list)) return;\n  for (const l of list) {\n    const visible = parent.visible && l.visible !== false;\n    const opacity = parent.opacity * (typeof l.opacity === 'number' ? l.opacity : 1);\n    const offsetX = parent.x + Number(l.offsetx ?? 0);\n    const offsetY = parent.y + Number(l.offsety ?? 0);\n    if (l.type === 'tilelayer') {\n      out.push({ kind: 'tiles', name: String(l.name ?? ''), data: layerData(l, map.width * map.height), visible, opacity, offsetX, offsetY, properties: props(l.properties) });\n    } else if (l.type === 'objectgroup') {\n      out.push({ kind: 'objects', name: String(l.name ?? ''), objects: (l.objects ?? []).map(parseObject), visible, properties: props(l.properties) });\n    } else if (l.type === 'group') {\n      parseLayers(l.layers, map, out, { visible, opacity, x: offsetX, y: offsetY });\n    }\n    // image layers are ignored: draw backgrounds yourself\n  }\n}\n\nfunction parseTileset(t: Json): Tileset {\n  if (typeof t.source === 'string') throw new TiledError(`tileset \"${t.source}\" is external; embed it in the map (Map → Embed Tilesets)`);\n  if (typeof t.image !== 'string') throw new TiledError(`tileset \"${t.name}\" is a collection of images; use a single-image tileset`);\n  const tileProperties = new Map<number, Properties>();\n  const animations = new Map<number, { tileId: number; duration: number }[]>();\n  for (const tile of t.tiles ?? []) {\n    const id = num(tile.id, 'tile id');\n    if (tile.properties) tileProperties.set(id, props(tile.properties));\n    if (Array.isArray(tile.animation)) animations.set(id, tile.animation.map((f: Json) => ({ tileId: num(f.tileid, 'animation tileid'), duration: num(f.duration, 'animation duration') })));\n  }\n  return {\n    name: String(t.name ?? ''),\n    firstGid: num(t.firstgid, 'tileset firstgid'),\n    image: t.image,\n    imageWidth: num(t.imagewidth, 'tileset imagewidth'),\n    imageHeight: num(t.imageheight, 'tileset imageheight'),\n    tileWidth: num(t.tilewidth, 'tileset tilewidth'),\n    tileHeight: num(t.tileheight, 'tileset tileheight'),\n    columns: num(t.columns, 'tileset columns'),\n    tileCount: num(t.tilecount, 'tileset tilecount'),\n    margin: Number(t.margin ?? 0),\n    spacing: Number(t.spacing ?? 0),\n    tileProperties,\n    animations,\n    properties: props(t.properties),\n  };\n}\n\n/** Reads a Tiled JSON map (already parsed with `JSON.parse`). Throws a `Tiled map: …` error saying what is wrong. */\nexport function parseTiled(json: unknown): TileMap {\n  const m = json as Json;\n  if (!m || typeof m !== 'object') throw new TiledError('not a JSON object');\n  if (m.infinite) throw new TiledError('infinite maps are not supported; uncheck Map → Map Properties → Infinite');\n  if (m.orientation && m.orientation !== 'orthogonal') throw new TiledError(`${m.orientation} maps are not supported, only orthogonal`);\n  const width = num(m.width, 'width');\n  const height = num(m.height, 'height');\n  const layers: MapLayer[] = [];\n  parseLayers(m.layers, { width, height }, layers);\n  const map: TileMap = {\n    width,\n    height,\n    tileWidth: num(m.tilewidth, 'tilewidth'),\n    tileHeight: num(m.tileheight, 'tileheight'),\n    layers,\n    tilesets: (m.tilesets ?? []).map(parseTileset),\n    properties: props(m.properties),\n  };\n  if (typeof m.backgroundcolor === 'string') map.backgroundColor = m.backgroundcolor;\n  return map;\n}\n/* eslint-enable @typescript-eslint/no-explicit-any */\n"],"names":["FLIP_H","FLIP_V","FLIP_D","gidOf","raw","tileAt","map","gid","found","ts","tileRect","local","col","row","layerByName","name","l","objectsOf","type","out","o","TiledError","message","props","list","p","num","v","what","decodeBase64","text","bin","i","layerData","cells","data","bytes","view","parseObject","obj","parseLayers","parent","visible","opacity","offsetX","offsetY","parseTileset","t","tileProperties","animations","tile","id","f","parseTiled","json","m","width","height","layers"],"mappings":"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"}

package/dist/transitions/CrossfadeTransition.js

@@ -0,0 +1,24 @@
+import { RenderTexture as s, Sprite as i } from "pixi.js";
+import { tweenDone as n } from "./tweenDone.js";
+class h {
+  constructor(t = {}) {
+    this.options = t;
+  }
+  options;
+  still = null;
+  texture = null;
+  async cover(t) {
+    const { app: e } = t, r = s.create({ width: e.screen.width, height: e.screen.height, resolution: e.renderer.resolution });
+    e.renderer.render({ container: e.stage, target: r }), this.texture = r, this.still = new i(r), t.layer.addChild(this.still);
+  }
+  async reveal(t) {
+    this.still && await n(t.stage, { targets: this.still, alpha: 0, duration: this.options.duration ?? 400, ease: "Sine.InOut" });
+  }
+  dispose() {
+    this.still?.destroy(), this.still = null, this.texture?.destroy(!0), this.texture = null;
+  }
+}
+export {
+  h as CrossfadeTransition
+};
+//# sourceMappingURL=CrossfadeTransition.js.map

package/dist/transitions/CrossfadeTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrossfadeTransition.js","sources":["../../src/transitions/CrossfadeTransition.ts"],"sourcesContent":["import { RenderTexture, Sprite } from 'pixi.js';\nimport type { Transition, TransitionContext } from './Transition';\nimport { tweenDone } from './tweenDone';\n\nexport interface CrossfadeOptions {\n  /** Ms the old scene takes to fade out over the new one (default 400). */\n  duration?: number;\n}\n\n/**\n * The old scene's last frame laid over the new scene and faded out. Two live scenes cannot both be drawn (the old\n * one is gone once the new one enters), so the old frame is captured into one screen-sized render texture, freed\n * when the transition ends. The new scene's `onEnter` runs under the still frame, so a long load reads as a pause.\n */\nexport class CrossfadeTransition implements Transition {\n  private still: Sprite | null = null;\n  private texture: RenderTexture | null = null;\n\n  constructor(private readonly options: CrossfadeOptions = {}) {}\n\n  async cover(ctx: TransitionContext): Promise<void> {\n    const { app } = ctx;\n    const texture = RenderTexture.create({ width: app.screen.width, height: app.screen.height, resolution: app.renderer.resolution });\n    app.renderer.render({ container: app.stage, target: texture });\n    this.texture = texture;\n    this.still = new Sprite(texture);\n    ctx.layer.addChild(this.still);\n  }\n\n  async reveal(ctx: TransitionContext): Promise<void> {\n    if (!this.still) return;\n    await tweenDone(ctx.stage, { targets: this.still, alpha: 0, duration: this.options.duration ?? 400, ease: 'Sine.InOut' });\n  }\n\n  dispose(): void {\n    this.still?.destroy();\n    this.still = null;\n    this.texture?.destroy(true);\n    this.texture = null;\n  }\n}\n"],"names":["CrossfadeTransition","options","ctx","app","texture","RenderTexture","Sprite","tweenDone"],"mappings":";;AAcO,MAAMA,EAA0C;AAAA,EAIrD,YAA6BC,IAA4B,IAAI;AAAhC,SAAA,UAAAA;AAAA,EAAiC;AAAA,EAAjC;AAAA,EAHrB,QAAuB;AAAA,EACvB,UAAgC;AAAA,EAIxC,MAAM,MAAMC,GAAuC;AACjD,UAAM,EAAE,KAAAC,MAAQD,GACVE,IAAUC,EAAc,OAAO,EAAE,OAAOF,EAAI,OAAO,OAAO,QAAQA,EAAI,OAAO,QAAQ,YAAYA,EAAI,SAAS,YAAY;AAChI,IAAAA,EAAI,SAAS,OAAO,EAAE,WAAWA,EAAI,OAAO,QAAQC,GAAS,GAC7D,KAAK,UAAUA,GACf,KAAK,QAAQ,IAAIE,EAAOF,CAAO,GAC/BF,EAAI,MAAM,SAAS,KAAK,KAAK;AAAA,EAC/B;AAAA,EAEA,MAAM,OAAOA,GAAuC;AAClD,IAAK,KAAK,SACV,MAAMK,EAAUL,EAAI,OAAO,EAAE,SAAS,KAAK,OAAO,OAAO,GAAG,UAAU,KAAK,QAAQ,YAAY,KAAK,MAAM,cAAc;AAAA,EAC1H;AAAA,EAEA,UAAgB;AACd,SAAK,OAAO,QAAA,GACZ,KAAK,QAAQ,MACb,KAAK,SAAS,QAAQ,EAAI,GAC1B,KAAK,UAAU;AAAA,EACjB;AACF;"}