lantern-engine 0.0.0-stage → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,101 @@
+# Changelog
+
+All notable changes to this package are written here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and versions follow [Semantic Versioning](https://semver.org/); before 1.0 a minor version may break the API.
+
+## Unreleased
+
+## 0.4.0
+
+### Changed
+
+- Node 22 or later (Node 20 reached its end of life; Pixi reads `navigator`, which Node 20 lacks, as it loads).
+
+### Added
+
+- A documentation site (VitePress): home, guide, an API reference generated from the source by TypeDoc, the changelog,
+  and the examples running live; `npm run docs:dev` / `docs:build`, published by a GitHub Pages workflow.
+- Examples `pixel-dungeon` (dithered torchlight, a carried light, evaporating slimes) and `ecs-stress` (tens of
+  thousands of bodies with the frame rate and step time).
+- Types the public API refers to are exported too: `ComponentValues`, `ArrayOf`, `SettingsListener`, `Tween`,
+  `TweenConfig`, `TweenTarget`, `EaseFn`, `Vec2`, `AtlasPlan`, `AtlasPage`, `CameraLike`, `SoundEngine`,
+  `SoundOptions`, `TiledPropertyValue`; `PackedPixels` is exported as a class from the pixel module.
+
+## 0.3.0
+
+### Added
+
+- Characters: `RigView` draws a rig from cut-out images or vector shapes (origin at the feet, mirrored by `facing`,
+  joints readable for held items); `PosePlayer` blends key poses with crossfades between clips; `HUMANOID_POSES` (72)
+  and `HUMANOID_CLIPS`.
+- `LightLayer`: smooth darkness with soft lights, colour washes and flicker.
+- `music` / `MusicPlayer`: streamed tracks, crossfaded, looping, at the music volume, iOS-safe.
+- Multiplayer: the netcode protocol, `PredictedMover` (prediction and reconciliation), `InterpolationBuffer`, an
+  authoritative `Room` with input validation and flood limits, `RoomHost` for any Node WebSocket library, and a
+  client `Connection` with batching, clock sync and reconnection. Tested end to end with simulated latency and jitter,
+  and through real sockets in the example.
+- Examples `night-garden` (smooth art, rig, lights) and `multiplayer` (`npm run example:server`).
+
+## 0.2.0
+
+The engine is now **Lantern Engine** (`lantern-engine`), for 2D games in any art style; the pixel-art tools moved to
+their own module, **Dither** (`lantern-engine/pixel`).
+
+### Breaking
+
+- Pixel-art exports moved to `lantern-engine/pixel`: `PixelLayer`, `pixelPaint`, `pixelTone`, the colour and pixel-grid
+  helpers, `PALETTE`, the prop kit, `ramp`/`selectiveOutline`, `Darkness` and the transient lights, `Evaporation`,
+  `spritePixels`.
+- `stage.add.pixels()` is gone: use `addPixelLayer(stage)` from the pixel module, or `stage.add.existing(obj)` for any
+  object made elsewhere.
+- `EngineOptions.pixelArt` (default on) is now `pixelPerfect` (default off). Off, textures are smooth, antialiased and
+  drawn at the screen's density; on, they are sharp, at one backing pixel per CSS pixel, and the camera lands on
+  whole pixels (`Camera.roundPixels`).
+- `createCollisionGrid`'s fifth argument is an options object (`ground`, `shotOverTiles`, `bodyHalfWidth`,
+  `bodyHalfHeight`); `setShotOverTiles` is gone.
+
+### Added
+
+- `AssetLoader`: images, sprite sheets, JSON, text and Tiled maps with their tileset images, progress, a concurrency
+  limit, errors that name the URL.
+- Tiled maps: `parseTiled` (CSV and base64 layers, groups, objects, properties, flips, tile animations; clear refusals
+  for what is not supported), `collisionFromTiled` (a layer or a tile property), `TilemapView` (layers drawn in culled
+  chunks, each at its own depth among the bodies).
+- `Animator` (fps or per-frame durations, loop or finish, speed) and `animationSystem` with `SpriteComponent` and
+  `AnimationComponent`.
+- `Actions`: named input bound to keys, gamepad buttons and sticks (with a dead zone), and virtual touch buttons; per-step
+  edges, analog values, rebinding.
+- `Camera.track`: a soft follow that is the same at any frame rate, a deadzone, an offset, the bounds kept.
+- Example `top-down` with a Tiled map, written by `examples/top-down/make-assets.mjs`.
+- `world.each(A, B, fn)`: walks without allocating a row per entity.
+- `defineFields(name, { x: 'f32', … })`: numeric components kept in typed-array columns (`world.columns`).
+- `world.slots(A, B)`: the matching slot indices as a cached `Int32Array`, rebuilt only when membership changes.
+  With field components a step over 50,000 bodies takes 0.1 ms, 200 times the first release.
+- `world.count(type)`, `entityIndex(e)`, `npm run bench`.
+
+### Changed
+
+- `World` stores components in sparse sets instead of maps: a query over 50,000 bodies went from 21 ms to 2 ms a
+  step, and spawning and destroying makes a third of the garbage. Entity ids are recycled with a generation, so a
+  stale id never matches the entity that reuses its slot. Entities are walked last-added first.
+- Removing a component while a walk is in progress is deferred like destroying an entity, so nothing is skipped.
+
+## 0.1.0 (as Dither Engine)
+
+First release, split out of a shipped game's client.
+
+### Added
+
+- `Engine`, `Scene`, `SceneManager` (replace, push, pop, async `onEnter`) and `FixedLoop` (fixed-step simulation with
+  interpolation and a cap on catch-up steps).
+- `World` ECS: typed components, queries, `fixed` and `frame` systems, deferred destruction, error isolation.
+- `EventBus` with `once`, `off`, `listenerCount` and listener error isolation.
+- Rendering core: `Stage`, `Camera`, `PixelLayer`, display objects, tweens, timers, bitmap labels, texture atlas.
+- Pixel effects: `pixelPaint`, `pixelTone`, `Evaporation`, hit-stop and recoil curves.
+- Lighting: `Darkness` with dithered lamps and transient lights.
+- Skeleton rig, pose blending, material ramps, selective outline and `HUMANOID_RIG`.
+- Audio: `sound`, synthesized recipes (`registerSounds`), recorded takes (`registerTakes`).
+- Input: `Keyboard`, stick maths, long press, touch detection.
+- Networking: deterministic `stepMover` with a configurable body box, binary snapshot codec, cadence rules, server
+  clock.
+- Example: `walk-room`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Phadec
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,114 @@
-# Temporary Holding Version
+# Lantern Engine
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![CI](https://github.com/Phadec/lantern-engine/actions/workflows/ci.yml/badge.svg)](https://github.com/Phadec/lantern-engine/actions/workflows/ci.yml)
+[![Docs](https://github.com/Phadec/lantern-engine/actions/workflows/docs.yml/badge.svg)](https://phadec.github.io/lantern-engine/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+A 2D game engine for the web, built on [PixiJS 8](https://pixijs.com) and written in TypeScript, for games in any
+art style: hand-drawn, HD, vector or pixel art. Pixel art gets a module of its own, **Dither**.
+
+It grew out of a shipped online action RPG, so its pieces were made for a real game under real load: a fast ECS,
+a fixed-step simulation a server can replay **bit for bit**, Tiled maps, input that works the same on keyboard,
+gamepad and touch, and for pixel art, effects painted on the world's own pixel grid and dithered lighting.
+
+```ts
+import { Engine, Scene, defineComponent, system } from 'lantern-engine';
+
+const Position = defineComponent<{ x: number; y: number }>('Position');
+
+class Level extends Scene {
+  override onEnter() {
+    this.world.spawn([Position, { x: 0, y: 0 }]);
+    this.world.addSystem(
+      system('drift', 'fixed', ({ world, dt }) => {
+        world.each(Position, (_e, p) => (p.x += 30 * dt));
+      }),
+    );
+  }
+}
+
+const engine = await Engine.create({ parent: document.body });
+await engine.scenes.replace(new Level());
+```
+
+> **Status: 0.x, early.** The API will change between minor versions until 1.0. See [CHANGELOG.md](CHANGELOG.md).
+
+## Two entry points
+
+| Import | For | Holds |
+|---|---|---|
+| `lantern-engine` | every 2D game | engine, scenes, ECS, rendering core, assets, Tiled maps, animation, input, camera, rig maths, audio, networking |
+| `lantern-engine/pixel` | pixel-art games | `PixelLayer`, `pixelPaint` shapes, colour ramps, dithered `Darkness` lighting, `Evaporation`, sprite pixel tools |
+
+The core never imports the pixel module (a test holds it to that), so a game that does not use it does not ship it.
+Start a pixel-art game with `Engine.create({ pixelPerfect: true })`: sharp textures and a camera that lands on whole
+pixels. Without it, textures are smooth and drawn at the screen's own density.
+
+## Features
+
+| Area | What you get |
+|---|---|
+| **Engine** | `Engine` (canvas, renderer, frame loop), a stack of `Scene`s (`replace`, `push`, `pop`, async loading), a fixed-step `FixedLoop` with interpolation and spiral-of-death protection, typed `EventBus`. |
+| **ECS** | `World` on sparse sets: typed components, `query`, allocation-free `each`, numeric components in typed-array columns (`defineFields`) walked through a cached `slots()` list — a step over 50,000 bodies in 0.1 ms. Systems in `fixed` and `frame` phases, recycled ids with generations, error isolation. |
+| **Assets** | `AssetLoader`: images, sprite sheets, JSON, text and Tiled maps with their tilesets, with progress and a concurrency limit. |
+| **Tilemaps** | Tiled JSON maps (CSV or base64 layers, groups, objects, properties, flipped tiles), drawn in culled chunks by `TilemapView`, with collision from a layer or a tile property. |
+| **Animation** | `Animator` clips (fps or per-frame durations, looping or finishing) and an animation system for sprites. |
+| **Input** | `Actions`: named actions bound to keys, gamepad buttons and sticks, and on-screen touch buttons, with per-step edges and analog values. `Keyboard`, stick maths, long press, touch detection. |
+| **Camera** | Zoom, bounds, shake, flash, and `track` with a soft follow that is the same at any frame rate, a deadzone and an offset. |
+| **Rendering** | `Stage` with world and screen layers, display objects, tweens, timers, bitmap labels, a texture atlas that splits pages by the GPU's limit, guards that keep one bad frame from stopping the loop. |
+| **Characters** | A 2D skeleton rig drawn by `RigView` from cut-out images or vector shapes, `PosePlayer` blending key poses with crossfades, and a built-in humanoid with 72 poses and ready clips (idle, walk, run, roll, slash, thrust, cast, throw, emotes). |
+| **Light** | `LightLayer`: smooth darkness with soft radial lights, colour washes and flicker (the pixel module has its own dithered `Darkness`). |
+| **Audio** | Web Audio `sound` engine (synthesized recipes, recorded takes cleaned in a worker, voice limiting, distance muffling, panning) and `music`: streamed tracks crossfaded and looped. iOS unlock handled. |
+| **Multiplayer** | An authoritative `Room` and its socket host for Node, a client `Connection`, `PredictedMover` (prediction and reconciliation over deterministic movement: in tests and in the example the server never has to correct it), `InterpolationBuffer` for everyone else, binary snapshots, clock sync, input validation and flood limits, cadence rules. |
+| **Pixel art** (`/pixel`) | `PixelLayer` (thousands of pixel rects in one pooled texture), `pixelPaint` shapes shaded from hue-shifted ramps and faded by ordered dither, `Darkness` with dithered lamps and transient lights, `Evaporation`, the selective outline. |
+
+## Install
+
+```sh
+npm install lantern-engine pixi.js
+```
+
+`pixi.js` (8.6 or later) is a peer dependency. The package is ESM only and ships its TypeScript types. On a server
+(the multiplayer `Room`) it needs Node 22 or later.
+
+The engine renders with **WebGL 2** by default. `Engine.create({ preference: 'webgpu' })` opts into WebGPU, which
+is experimental here: it falls back to WebGL where the browser lacks it, but has not been profiled the way the WebGL
+path has.
+
+## Documentation
+
+**https://phadec.github.io/lantern-engine/** — the guide, the API reference and the examples running live.
+
+The documentation site (guide, API reference generated from the source, live examples) is built with
+`npm run docs:build` and published to GitHub Pages by `.github/workflows/docs.yml`; `npm run docs:dev` serves it
+locally.
+
+- [Getting started](docs/guide/getting-started.md): an engine, a scene, entities and systems, assets, a Tiled map, input,
+  the camera, a rigged character, light and music, and multiplayer, step by step.
+- [Architecture](docs/guide/architecture.md): how the frame loop, scenes, ECS and rendering fit together, and the rules that keep it fast.
+- [Examples](examples/), run with `npm run dev`:
+  - `top-down`: a Tiled map, asset loading, an animated hero, input actions on keyboard, gamepad and touch, camera follow.
+  - `night-garden`: smooth vector art, a rigged hero animated by blended poses, a lantern and fireflies in the dark.
+  - `pixel-dungeon`: the pixel module: dithered torchlight, a carried light, slimes that evaporate into their own pixels.
+  - `ecs-stress`: tens of thousands of bodies on typed-array components, with the frame rate and step time.
+  - `multiplayer`: `npm run example:server`, then two tabs: prediction, reconciliation and interpolation.
+  - `walk-room`: the smallest whole game, with pixel effects.
+
+## Develop
+
+```sh
+npm install
+npm run dev        # examples at http://127.0.0.1:5180/
+npm test           # unit tests under node
+npm run typecheck  # sources and tests
+npm run bench      # ECS benchmark
+npm run build      # dist/: both ESM bundles and their .d.ts files
+npm run check      # typecheck, test and build, as CI runs it
+npm run docs:dev   # the documentation site, with the API reference and examples
+```
+
+Contributions are welcome: read [CONTRIBUTING.md](CONTRIBUTING.md) first.
+
+## License
+
+[MIT](LICENSE)

package/dist/assets/takeCleanerWorker-DTcI_Jqr.js

@@ -0,0 +1,31 @@
+function m(l, h) {
+  const a = l[0]?.length ?? 0, f = 1 / Math.max(1, l.length), e = new Float32Array(a);
+  for (const t of l) for (let n = 0; n < a; n++) e[n] += t[n] * f;
+  let r = 0;
+  for (let t = 0; t < a; t++) {
+    const n = Math.abs(e[t]);
+    n > r && (r = n);
+  }
+  if (r < 5e-3) return null;
+  const i = r * 0.01;
+  let s = 0;
+  for (; s < a && Math.abs(e[s]) < i; ) s++;
+  let c = a;
+  for (; c > s && Math.abs(e[c - 1]) < i; ) c--;
+  if (c <= s) return null;
+  s = Math.max(0, s - Math.round(2e-3 * h));
+  const o = e.slice(s, c);
+  let M = 0;
+  for (let t = 0; t < o.length; t++) M += o[t] * o[t];
+  const d = Math.sqrt(M / o.length), g = Math.min(0.16 / Math.max(d, 1e-6), 0.95 / r), E = Math.min(o.length, Math.round(0.01 * h));
+  for (let t = 0; t < o.length; t++) {
+    const n = o.length - t;
+    o[t] *= g * (n < E ? n / E : 1);
+  }
+  return o;
+}
+self.onmessage = (l) => {
+  const { id: h, channels: a, sampleRate: f } = l.data, e = m(a, f);
+  self.postMessage({ id: h, data: e }, e ? { transfer: [e.buffer] } : void 0);
+};
+//# sourceMappingURL=takeCleanerWorker-DTcI_Jqr.js.map

package/dist/assets/takeCleanerWorker-DTcI_Jqr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"takeCleanerWorker-DTcI_Jqr.js","sources":["../src/audio/cleanTake.ts","../src/audio/takeCleanerWorker.ts"],"sourcesContent":["/*\n * Cleans one recorded take (`SampleBank`): folded to mono, the silence an encoder or the model leaves at the start cut\n * (a swing heard 30 ms late reads as lag) and at the end trimmed, and brought to one loudness (`LOUDNESS`, RMS of what\n * is left, never past `PEAK`), so takes from different prompts sit at one level. Pure: run in `takeCleanerWorker.ts`,\n * because on the main thread the first blows of a fight froze the game 70–170 ms a take on a Mac and several times\n * that on a phone (profiled).\n */\n\n/** Below this share of the take's own peak a sample counts as silence when trimming (-40 dB). */\nconst FLOOR = 0.01;\n/** A take whose peak is under this is treated as empty (about -46 dBFS): the model returned near-silence. */\nconst EMPTY = 0.005;\n/** Target RMS of a cleaned take (-16 dBFS) and the peak it may not pass. */\nconst LOUDNESS = 0.16;\nconst PEAK = 0.95;\n/** Kept before the first loud sample, so the attack is not clipped into a click (s). */\nconst LEAD = 0.002;\n/** A short fade over the cut end, so a trimmed tail does not click (s). */\nconst TAIL_FADE = 0.01;\n\n/** The cleaned mono samples, or null for a take that is silence. */\nexport function cleanSamples(channels: Float32Array[], sampleRate: number): Float32Array | null {\n  const n = channels[0]?.length ?? 0;\n  const k0 = 1 / Math.max(1, channels.length);\n  const mono = new Float32Array(n);\n  for (const ch of channels) for (let i = 0; i < n; i++) mono[i]! += ch[i]! * k0;\n  let top = 0;\n  for (let i = 0; i < n; i++) {\n    const a = Math.abs(mono[i]!);\n    if (a > top) top = a;\n  }\n  if (top < EMPTY) return null;\n  const floor = top * FLOOR;\n  let start = 0;\n  while (start < n && Math.abs(mono[start]!) < floor) start++;\n  let end = n;\n  while (end > start && Math.abs(mono[end - 1]!) < floor) end--;\n  if (end <= start) return null;\n  start = Math.max(0, start - Math.round(LEAD * sampleRate));\n  const data = mono.slice(start, end);\n  let power = 0;\n  for (let i = 0; i < data.length; i++) power += data[i]! * data[i]!;\n  const rms = Math.sqrt(power / data.length);\n  const k = Math.min(LOUDNESS / Math.max(rms, 1e-6), PEAK / top);\n  const fade = Math.min(data.length, Math.round(TAIL_FADE * sampleRate));\n  for (let i = 0; i < data.length; i++) {\n    const left = data.length - i;\n    data[i]! *= k * (left < fade ? left / fade : 1);\n  }\n  return data;\n}\n","import { cleanSamples } from './cleanTake';\n\n/* Cleans recorded takes off the main thread (`SampleBank`); one message per take, answered with its id. */\nself.onmessage = (e: MessageEvent<{ id: number; channels: Float32Array[]; sampleRate: number }>) => {\n  const { id, channels, sampleRate } = e.data;\n  const data = cleanSamples(channels, sampleRate);\n  self.postMessage({ id, data }, data ? { transfer: [data.buffer as ArrayBuffer] } : undefined);\n};\n"],"names":["cleanSamples","channels","sampleRate","n","k0","mono","ch","i","top","a","floor","start","end","data","power","rms","k","fade","left","e","id"],"mappings":"AAqBO,SAASA,EAAaC,GAA0BC,GAAyC;AAC9F,QAAMC,IAAIF,EAAS,CAAC,GAAG,UAAU,GAC3BG,IAAK,IAAI,KAAK,IAAI,GAAGH,EAAS,MAAM,GACpCI,IAAO,IAAI,aAAaF,CAAC;AAC/B,aAAWG,KAAML,EAAU,UAASM,IAAI,GAAGA,IAAIJ,GAAGI,IAAK,CAAAF,EAAKE,CAAC,KAAMD,EAAGC,CAAC,IAAKH;AAC5E,MAAII,IAAM;AACV,WAASD,IAAI,GAAGA,IAAIJ,GAAGI,KAAK;AAC1B,UAAME,IAAI,KAAK,IAAIJ,EAAKE,CAAC,CAAE;AAC3B,IAAIE,IAAID,MAAKA,IAAMC;AAAA,EACrB;AACA,MAAID,IAAM,KAAO,QAAO;AACxB,QAAME,IAAQF,IAAM;AACpB,MAAIG,IAAQ;AACZ,SAAOA,IAAQR,KAAK,KAAK,IAAIE,EAAKM,CAAK,CAAE,IAAID,IAAO,CAAAC;AACpD,MAAIC,IAAMT;AACV,SAAOS,IAAMD,KAAS,KAAK,IAAIN,EAAKO,IAAM,CAAC,CAAE,IAAIF,IAAO,CAAAE;AACxD,MAAIA,KAAOD,EAAO,QAAO;AACzB,EAAAA,IAAQ,KAAK,IAAI,GAAGA,IAAQ,KAAK,MAAM,OAAOT,CAAU,CAAC;AACzD,QAAMW,IAAOR,EAAK,MAAMM,GAAOC,CAAG;AAClC,MAAIE,IAAQ;AACZ,WAASP,IAAI,GAAGA,IAAIM,EAAK,QAAQN,IAAK,CAAAO,KAASD,EAAKN,CAAC,IAAKM,EAAKN,CAAC;AAChE,QAAMQ,IAAM,KAAK,KAAKD,IAAQD,EAAK,MAAM,GACnCG,IAAI,KAAK,IAAI,OAAW,KAAK,IAAID,GAAK,IAAI,GAAG,OAAOP,CAAG,GACvDS,IAAO,KAAK,IAAIJ,EAAK,QAAQ,KAAK,MAAM,OAAYX,CAAU,CAAC;AACrE,WAASK,IAAI,GAAGA,IAAIM,EAAK,QAAQN,KAAK;AACpC,UAAMW,IAAOL,EAAK,SAASN;AAC3B,IAAAM,EAAKN,CAAC,KAAMS,KAAKE,IAAOD,IAAOC,IAAOD,IAAO;AAAA,EAC/C;AACA,SAAOJ;AACT;AC/CA,KAAK,YAAY,CAACM,MAAkF;AAClG,QAAM,EAAE,IAAAC,GAAI,UAAAnB,GAAU,YAAAC,EAAA,IAAeiB,EAAE,MACjCN,IAAOb,EAAaC,GAAUC,CAAU;AAC9C,OAAK,YAAY,EAAE,IAAAkB,GAAI,MAAAP,EAAA,GAAQA,IAAO,EAAE,UAAU,CAACA,EAAK,MAAqB,EAAA,IAAM,MAAS;AAC9F;"}

package/dist/constants-CjYVdFid.js

@@ -0,0 +1,252 @@
+import { ColorMatrixFilter as y, Graphics as S, Container as x, BatchTextureArray as c } from "pixi.js";
+const f = /* @__PURE__ */ new Map();
+function T(s) {
+  let t = f.get(s);
+  if (t) return t;
+  const e = new y();
+  e.antialias = "off";
+  const i = (s >> 16 & 255) / 255, r = (s >> 8 & 255) / 255, l = (s & 255) / 255;
+  return e.matrix = [0, 0, 0, 0, i, 0, 0, 0, 0, r, 0, 0, 0, 0, l, 0, 0, 0, 1, 0], f.set(s, t = [e]), t;
+}
+function F(s) {
+  return class extends s {
+    scene;
+    sx = 1;
+    sy = 1;
+    fx = !1;
+    fy = !1;
+    /** The colour this object is filled with (`setTintFill`), or null. */
+    solidFillColor = null;
+    /** False once destroyed. */
+    get active() {
+      return !this.destroyed;
+    }
+    get depth() {
+      return this.zIndex;
+    }
+    set depth(t) {
+      this.zIndex = t;
+    }
+    get scaleX() {
+      return this.sx;
+    }
+    set scaleX(t) {
+      this.sx = t, this.applyScale();
+    }
+    get scaleY() {
+      return this.sy;
+    }
+    set scaleY(t) {
+      this.sy = t, this.applyScale();
+    }
+    get flipX() {
+      return this.fx;
+    }
+    set flipX(t) {
+      this.fx = t, this.applyScale();
+    }
+    get flipY() {
+      return this.fy;
+    }
+    set flipY(t) {
+      this.fy = t, this.applyScale();
+    }
+    applyScale() {
+      this.destroyed || this.scale.set(this.sx * (this.fx ? -1 : 1), this.sy * (this.fy ? -1 : 1));
+    }
+    setScale(t, e = t) {
+      return this.sx = t, this.sy = e, this.applyScale(), this;
+    }
+    setFlipX(t) {
+      return this.flipX = t, this;
+    }
+    setFlipY(t) {
+      return this.flipY = t, this;
+    }
+    setFlip(t, e) {
+      return this.fx = t, this.fy = e, this.applyScale(), this;
+    }
+    setDepth(t) {
+      return this.zIndex = t, this;
+    }
+    setAlpha(t = 1) {
+      return this.alpha = t, this;
+    }
+    setVisible(t) {
+      return this.visible = t, this;
+    }
+    setPosition(t = 0, e = t) {
+      return this.position.set(t, e), this;
+    }
+    setRotation(t = 0) {
+      return this.rotation = t, this;
+    }
+    setAngle(t = 0) {
+      return this.angle = t, this;
+    }
+    setBlendMode(t) {
+      return this.blendMode = t, this;
+    }
+    setTint(t = 16777215) {
+      return this.clearFill(), this.tint = t, this;
+    }
+    /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */
+    setTintFill(t) {
+      return this.tint = 16777215, this.solidFillColor === t ? this : (this.solidFillColor = t, this.filters = T(t), this);
+    }
+    clearTint() {
+      return this.clearFill(), this.tint = 16777215, this;
+    }
+    clearFill() {
+      this.solidFillColor !== null && (this.filters = null, this.solidFillColor = null);
+    }
+    /** 0 pins the object to the screen instead of the world (full-screen flashes). */
+    setScrollFactor(t) {
+      return t === 0 && this.scene.screen.addChild(this), this;
+    }
+    destroy() {
+      this.destroyed || (this.solidFillColor !== null && (this.filters = null), this.solidFillColor = null, super.destroy({ children: !0, context: !0 }));
+    }
+  };
+}
+class _ extends F(x) {
+  g = new S();
+  fill = { color: 16777215, alpha: 1 };
+  line = { width: 1, color: 16777215, alpha: 1 };
+  constructor() {
+    super(), this.addChild(this.g);
+  }
+  fillStyle(t, e = 1) {
+    return this.fill = { color: t, alpha: e }, this;
+  }
+  lineStyle(t, e, i = 1) {
+    return this.line = { width: t, color: e, alpha: i }, this;
+  }
+  clear() {
+    return this.g.clear(), this;
+  }
+  fillRect(t, e, i, r) {
+    return this.g.rect(t, e, i, r).fill(this.fill), this;
+  }
+  fillEllipse(t, e, i, r) {
+    return this.g.ellipse(t, e, i / 2, r / 2).fill(this.fill), this;
+  }
+  strokeEllipse(t, e, i, r) {
+    return this.g.ellipse(t, e, i / 2, r / 2).stroke(this.line), this;
+  }
+  fillCircle(t, e, i) {
+    return this.g.circle(t, e, i).fill(this.fill), this;
+  }
+  strokeCircle(t, e, i) {
+    return this.g.circle(t, e, i).stroke(this.line), this;
+  }
+  lineBetween(t, e, i, r) {
+    return this.g.moveTo(t, e).lineTo(i, r).stroke(this.line), this;
+  }
+  fillPoints(t, e = !0) {
+    return this.g.poly(t.flatMap((i) => [i.x, i.y]), !0).fill(this.fill), this;
+  }
+  strokePoints(t, e = !1) {
+    return this.g.poly(t.flatMap((i) => [i.x, i.y]), e).stroke(this.line), this;
+  }
+  /** A pie slice from the centre, for cone telegraphs. */
+  slice(t, e, i, r, l, n = !1) {
+    return this.g.moveTo(t, e).arc(t, e, i, r, l, n).closePath(), this;
+  }
+  beginPath() {
+    return this.g.beginPath(), this;
+  }
+  moveTo(t, e) {
+    return this.g.moveTo(t, e), this;
+  }
+  lineTo(t, e) {
+    return this.g.lineTo(t, e), this;
+  }
+  closePath() {
+    return this.g.closePath(), this;
+  }
+  fillPath() {
+    return this.g.fill(this.fill), this;
+  }
+  strokePath() {
+    return this.g.stroke(this.line), this;
+  }
+}
+function P(s) {
+  return s.override === "1" || s.override === "on" ? !0 : s.override === "0" || s.override === "off" ? !1 : s.native ? !0 : s.coarse && s.touchPoints > 0;
+}
+let o = null, p = !1;
+function w(s) {
+  p = s, o = null;
+}
+function m() {
+  try {
+    const s = new URLSearchParams(window.location.search).get("touch");
+    return s !== null ? s : localStorage.getItem("engine.touch");
+  } catch {
+    return null;
+  }
+}
+function I() {
+  return {
+    native: p,
+    coarse: typeof matchMedia == "function" && matchMedia("(pointer: coarse)").matches,
+    touchPoints: typeof navigator < "u" ? navigator.maxTouchPoints ?? 0 : 0,
+    override: m()
+  };
+}
+function L() {
+  return o === null && (o = typeof window < "u" && P(I())), o;
+}
+let d = !1;
+function A() {
+  if (d) return !0;
+  const s = c.prototype, t = new c();
+  return !(typeof s.clear == "function" && typeof t.ids == "object" && Array.isArray(t.textures) && typeof t.count == "number") || !/ids\[[^\]]+\]\s*=\s*null/.test(String(s.clear)) ? !1 : (s.clear = function() {
+    const r = this.ids, l = this.textures;
+    for (let n = 0; n < this.count; n++) {
+      const u = l[n];
+      l[n] = null, u && delete r[u.uid];
+    }
+    this.count = 0;
+  }, d = !0, !0);
+}
+const g = {
+  reducedFx: !1,
+  batterySaver: !1,
+  combatLights: !0,
+  sfxVolume: 0.8,
+  musicVolume: 0.6
+};
+let h = { ...g };
+const a = /* @__PURE__ */ new Set(), b = {
+  getState() {
+    return h;
+  },
+  set(s) {
+    h = { ...h, ...s };
+    for (const t of [...a]) t(h);
+  },
+  subscribe(s) {
+    return a.add(s), () => a.delete(s);
+  },
+  reset() {
+    b.set(g);
+  }
+}, E = 16, C = 60, k = 1 / C, M = 1, Y = 5, D = 3, G = 0.01;
+export {
+  Y as B,
+  G as C,
+  F as G,
+  M as I,
+  E as T,
+  _ as a,
+  D as b,
+  k as c,
+  C as d,
+  b as e,
+  L as i,
+  A as p,
+  w as s
+};
+//# sourceMappingURL=constants-CjYVdFid.js.map

package/dist/constants-CjYVdFid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants-CjYVdFid.js","sources":["../src/core/gameObject.ts","../src/core/Graphics.ts","../src/input/touchDetect.ts","../src/platform/touch.ts","../src/core/pixiPatches.ts","../src/settings.ts","../src/net/constants.ts"],"sourcesContent":["import { ColorMatrixFilter, type BLEND_MODES, type Container } from 'pixi.js';\nimport type { Stage } from './Stage';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Ctor<T> = new (...args: any[]) => T;\n\n/**\n * One solid-fill filter list per colour, shared by every object filled with it (a hit flash, a silhouette): a filter\n * made and destroyed on every hit of every body was garbage and shader state a blow. Kept for good —\n * a handful of colours are ever used.\n */\nconst FILLS = new Map<number, ColorMatrixFilter[]>();\n\nfunction fillFilters(color: number): ColorMatrixFilter[] {\n  let list = FILLS.get(color);\n  if (list) return list;\n  const f = new ColorMatrixFilter();\n  f.antialias = 'off';\n  const r = ((color >> 16) & 0xff) / 255;\n  const g = ((color >> 8) & 0xff) / 255;\n  const b = (color & 0xff) / 255;\n  f.matrix = [0, 0, 0, 0, r, 0, 0, 0, 0, g, 0, 0, 0, 0, b, 0, 0, 0, 1, 0];\n  FILLS.set(color, (list = [f]));\n  return list;\n}\n\n/** What `GameObject` adds to a Pixi display object. */\nexport interface GameObjectMembers {\n  scene: Stage;\n  /** False once destroyed. */\n  readonly active: boolean;\n  /** The draw order in the world layer (`zIndex`): bigger is in front. */\n  depth: number;\n  /** Scale without the flip: stays positive on a mirrored sprite. */\n  scaleX: number;\n  scaleY: number;\n  flipX: boolean;\n  flipY: boolean;\n  setScale(x: number, y?: number): this;\n  setFlipX(v: boolean): this;\n  setFlipY(v: boolean): this;\n  setFlip(x: boolean, y: boolean): this;\n  setDepth(d: number): this;\n  setAlpha(a?: number): this;\n  setVisible(v: boolean): this;\n  setPosition(x?: number, y?: number): this;\n  setRotation(r?: number): this;\n  setAngle(a?: number): this;\n  setBlendMode(mode: BLEND_MODES): this;\n  setTint(color?: number): this;\n  /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */\n  setTintFill(color: number): this;\n  clearTint(): this;\n  /** 0 pins the object to the screen instead of the world. */\n  setScrollFactor(f: number): this;\n  destroy(): void;\n}\n\n/**\n * The chainable setters the world code was written against (setDepth, setAlpha, setTintFill...), added onto a Pixi\n * display object. Scale is kept apart from flipping, so `scaleX` stays positive on a mirrored sprite as it did\n * before, and a tween on scale cannot undo a flip.\n */\nexport function GameObject<TBase extends Ctor<Container>>(Base: TBase): TBase & Ctor<GameObjectMembers> {\n  return class extends Base {\n    scene!: Stage;\n    private sx = 1;\n    private sy = 1;\n    private fx = false;\n    private fy = false;\n    /** The colour this object is filled with (`setTintFill`), or null. */\n    private solidFillColor: number | null = null;\n\n    /** False once destroyed. */\n    get active(): boolean {\n      return !this.destroyed;\n    }\n\n    get depth(): number {\n      return this.zIndex;\n    }\n\n    set depth(d: number) {\n      this.zIndex = d;\n    }\n\n    get scaleX(): number {\n      return this.sx;\n    }\n\n    set scaleX(v: number) {\n      this.sx = v;\n      this.applyScale();\n    }\n\n    get scaleY(): number {\n      return this.sy;\n    }\n\n    set scaleY(v: number) {\n      this.sy = v;\n      this.applyScale();\n    }\n\n    get flipX(): boolean {\n      return this.fx;\n    }\n\n    set flipX(v: boolean) {\n      this.fx = v;\n      this.applyScale();\n    }\n\n    get flipY(): boolean {\n      return this.fy;\n    }\n\n    set flipY(v: boolean) {\n      this.fy = v;\n      this.applyScale();\n    }\n\n    private applyScale(): void {\n      if (!this.destroyed) this.scale.set(this.sx * (this.fx ? -1 : 1), this.sy * (this.fy ? -1 : 1));\n    }\n\n    setScale(x: number, y = x): this {\n      this.sx = x;\n      this.sy = y;\n      this.applyScale();\n      return this;\n    }\n\n    setFlipX(v: boolean): this {\n      this.flipX = v;\n      return this;\n    }\n\n    setFlipY(v: boolean): this {\n      this.flipY = v;\n      return this;\n    }\n\n    setFlip(x: boolean, y: boolean): this {\n      this.fx = x;\n      this.fy = y;\n      this.applyScale();\n      return this;\n    }\n\n    setDepth(d: number): this {\n      this.zIndex = d;\n      return this;\n    }\n\n    setAlpha(a = 1): this {\n      this.alpha = a;\n      return this;\n    }\n\n    setVisible(v: boolean): this {\n      this.visible = v;\n      return this;\n    }\n\n    setPosition(x = 0, y = x): this {\n      this.position.set(x, y);\n      return this;\n    }\n\n    setRotation(r = 0): this {\n      this.rotation = r;\n      return this;\n    }\n\n    setAngle(a = 0): this {\n      this.angle = a;\n      return this;\n    }\n\n    setBlendMode(mode: BLEND_MODES): this {\n      this.blendMode = mode;\n      return this;\n    }\n\n    setTint(color = 0xffffff): this {\n      this.clearFill();\n      this.tint = color;\n      return this;\n    }\n\n    /** Paints every opaque pixel in one solid colour (hit flash, silhouettes). */\n    setTintFill(color: number): this {\n      this.tint = 0xffffff;\n      if (this.solidFillColor === color) return this;\n      this.solidFillColor = color;\n      this.filters = fillFilters(color);\n      return this;\n    }\n\n    clearTint(): this {\n      this.clearFill();\n      this.tint = 0xffffff;\n      return this;\n    }\n\n    private clearFill(): void {\n      if (this.solidFillColor === null) return;\n      this.filters = null;\n      this.solidFillColor = null;\n    }\n\n    /** 0 pins the object to the screen instead of the world (full-screen flashes). */\n    setScrollFactor(f: number): this {\n      if (f === 0) this.scene.screen.addChild(this);\n      return this;\n    }\n\n    override destroy(): void {\n      if (this.destroyed) return;\n      // the fill filters are shared (`FILLS`): let go of them, never destroy them\n      if (this.solidFillColor !== null) this.filters = null;\n      this.solidFillColor = null;\n      // `context`: a Pixi Graphics destroyed with options keeps its GraphicsContext — and that context's GPU buffers —\n      // until Pixi's own GC sweeps it a minute or more later. Every effect layer is a Graphics, so a crowded fight left\n      // hundreds a second on the GPU, and a phone that ran out dropped the WebGL context (the world rebuilt, seconds\n      // frozen, the socket timed out).\n      super.destroy({ children: true, context: true });\n    }\n  };\n}\n","import { Container, Graphics as PixiGraphics } from 'pixi.js';\nimport { GameObject } from './gameObject';\n\nexport interface Vec2 {\n  x: number;\n  y: number;\n}\n\n/**\n * Immediate-mode vector drawing with a current fill and line style (fillStyle + fillRect), on top of Pixi's\n * shape-then-fill Graphics. Wrapped rather than subclassed: Pixi's Graphics owns `fillStyle` as a property.\n */\nexport class Graphics extends GameObject(Container) {\n  private readonly g = new PixiGraphics();\n  private fill = { color: 0xffffff, alpha: 1 };\n  private line = { width: 1, color: 0xffffff, alpha: 1 };\n\n  constructor() {\n    super();\n    this.addChild(this.g);\n  }\n\n  fillStyle(color: number, alpha = 1): this {\n    this.fill = { color, alpha };\n    return this;\n  }\n\n  lineStyle(width: number, color: number, alpha = 1): this {\n    this.line = { width, color, alpha };\n    return this;\n  }\n\n  clear(): this {\n    this.g.clear();\n    return this;\n  }\n\n  fillRect(x: number, y: number, w: number, h: number): this {\n    this.g.rect(x, y, w, h).fill(this.fill);\n    return this;\n  }\n\n  fillEllipse(x: number, y: number, w: number, h: number): this {\n    this.g.ellipse(x, y, w / 2, h / 2).fill(this.fill);\n    return this;\n  }\n\n  strokeEllipse(x: number, y: number, w: number, h: number): this {\n    this.g.ellipse(x, y, w / 2, h / 2).stroke(this.line);\n    return this;\n  }\n\n  fillCircle(x: number, y: number, r: number): this {\n    this.g.circle(x, y, r).fill(this.fill);\n    return this;\n  }\n\n  strokeCircle(x: number, y: number, r: number): this {\n    this.g.circle(x, y, r).stroke(this.line);\n    return this;\n  }\n\n  lineBetween(x1: number, y1: number, x2: number, y2: number): this {\n    this.g.moveTo(x1, y1).lineTo(x2, y2).stroke(this.line);\n    return this;\n  }\n\n  fillPoints(points: Vec2[], _closeShape = true): this {\n    this.g.poly(points.flatMap((p) => [p.x, p.y]), true).fill(this.fill);\n    return this;\n  }\n\n  strokePoints(points: Vec2[], closeShape = false): this {\n    this.g.poly(points.flatMap((p) => [p.x, p.y]), closeShape).stroke(this.line);\n    return this;\n  }\n\n  /** A pie slice from the centre, for cone telegraphs. */\n  slice(x: number, y: number, r: number, start: number, end: number, anticlockwise = false): this {\n    this.g.moveTo(x, y).arc(x, y, r, start, end, anticlockwise).closePath();\n    return this;\n  }\n\n  beginPath(): this {\n    this.g.beginPath();\n    return this;\n  }\n\n  moveTo(x: number, y: number): this {\n    this.g.moveTo(x, y);\n    return this;\n  }\n\n  lineTo(x: number, y: number): this {\n    this.g.lineTo(x, y);\n    return this;\n  }\n\n  closePath(): this {\n    this.g.closePath();\n    return this;\n  }\n\n  fillPath(): this {\n    this.g.fill(this.fill);\n    return this;\n  }\n\n  strokePath(): this {\n    this.g.stroke(this.line);\n    return this;\n  }\n}\n","/** What decides whether the touch controls are shown; read off the browser by `touchDevice.ts`. */\nexport interface TouchEnv {\n  /** Running inside the native shell (Capacitor iOS). */\n  native: boolean;\n  /** `(pointer: coarse)` matches: the **primary** pointer is a finger. */\n  coarse: boolean;\n  /** `navigator.maxTouchPoints`. */\n  touchPoints: number;\n  /** `?touch=1|0` in the URL or `localStorage['engine.touch']`, for trying the controls on a desktop browser. */\n  override: string | null;\n}\n\n/**\n * Touch controls only where a finger is the main way in: the native app always, a browser whose primary pointer\n * is coarse and that reports touch points (a phone or tablet), never a desktop — a laptop with a touch screen\n * still has a fine primary pointer and keeps its mouse and keyboard.\n */\nexport function detectTouch(env: TouchEnv): boolean {\n  if (env.override === '1' || env.override === 'on') return true;\n  if (env.override === '0' || env.override === 'off') return false;\n  if (env.native) return true;\n  return env.coarse && env.touchPoints > 0;\n}\n","import { detectTouch, type TouchEnv } from '../input/touchDetect';\n\nlet cached: boolean | null = null;\nlet nativeShell = false;\n\n/** A native shell (Capacitor, Electron touch kiosk…) tells the engine it is one; browsers leave it false. */\nexport function setNativeShell(native: boolean): void {\n  nativeShell = native;\n  cached = null;\n}\n\nfunction readOverride(): string | null {\n  try {\n    const fromUrl = new URLSearchParams(window.location.search).get('touch');\n    if (fromUrl !== null) return fromUrl;\n    return localStorage.getItem('engine.touch');\n  } catch {\n    return null;\n  }\n}\n\nfunction readEnv(): TouchEnv {\n  return {\n    native: nativeShell,\n    coarse: typeof matchMedia === 'function' && matchMedia('(pointer: coarse)').matches,\n    touchPoints: typeof navigator !== 'undefined' ? navigator.maxTouchPoints ?? 0 : 0,\n    override: readOverride(),\n  };\n}\n\n/** True when the game is played with fingers (decided once per launch, `detectTouch`). */\nexport function isTouchUi(): boolean {\n  if (cached === null) cached = typeof window !== 'undefined' && detectTouch(readEnv());\n  return cached;\n}\n","import { BatchTextureArray } from 'pixi.js';\n\nlet patched = false;\n\n/**\n * Pixi 8's `BatchTextureArray.clear` sets `ids[source.uid] = null` instead of deleting the key, and its batches are\n * pooled, so every pooled batch keeps one key for every texture source ever drawn through it — about 70% of what a\n * fight's heap grew by in an hour (Pixi 8.21.0). The replacement deletes the key, which reads the\n * same to Pixi (`checkAndUpdateTexture` treats null and a missing key alike). Applied once, and only while `clear`\n * still has the shape it was written against, so a Pixi that fixed or changed it is left alone.\n */\nexport function patchPixi(): boolean {\n  if (patched) return true;\n  const proto = BatchTextureArray.prototype as unknown as { clear: () => void };\n  const probe = new BatchTextureArray() as unknown as { ids: unknown; textures: unknown; count: unknown };\n  const shaped = typeof proto.clear === 'function' && typeof probe.ids === 'object' && Array.isArray(probe.textures) && typeof probe.count === 'number';\n  if (!shaped || !/ids\\[[^\\]]+\\]\\s*=\\s*null/.test(String(proto.clear))) return false;\n  proto.clear = function clear(this: { ids: Record<number, number | null>; textures: ({ uid: number } | null)[]; count: number }): void {\n    const ids = this.ids;\n    const textures = this.textures;\n    for (let i = 0; i < this.count; i++) {\n      const t = textures[i];\n      textures[i] = null;\n      if (t) delete ids[t.uid];\n    }\n    this.count = 0;\n  };\n  patched = true;\n  return true;\n}\n","/**\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","/** World and movement constants. A game that needs other numbers forks these; client and server must agree. */\n\nexport const TILE_SIZE = 16;\n\n/** Fixed input steps a second; movement is simulated per step on both sides. */\nexport const INPUT_STEP_RATE = 60;\nexport const INPUT_STEP_DT = 1 / INPUT_STEP_RATE;\n\n/** Bit of an input step's flags that asks for a dodge roll. */\nexport const INPUT_FLAG_DASH = 1;\n\n/** The body's collision box, half extents (px). */\nexport const BODY_HALF_WIDTH = 5;\nexport const BODY_HALF_HEIGHT = 3;\nexport const COLLISION_EPSILON = 0.01;\n\n/** One fixed input step: [axisX, axisY, flags]. */\nexport type InputStep = [number, number, number];\n\nexport interface MovementParams {\n  speed: number;\n  dashSpeed: number;\n  dashSteps: number;\n  dashCooldownSteps: number;\n  canMove: boolean;\n  canDash: boolean;\n}\n\n/** One body's state in a snapshot: [id, x, y, aim, anim, hp, flags]. */\nexport type EntityUpdate = [number, number, number, number, number, number, number];\n"],"names":["FILLS","fillFilters","color","list","f","ColorMatrixFilter","r","g","b","GameObject","Base","d","v","x","y","a","mode","Graphics","Container","PixiGraphics","alpha","width","w","h","x1","y1","x2","y2","points","_closeShape","p","closeShape","start","end","anticlockwise","detectTouch","env","cached","nativeShell","setNativeShell","native","readOverride","fromUrl","readEnv","isTouchUi","patched","patchPixi","proto","BatchTextureArray","probe","ids","textures","i","t","DEFAULTS","state","listeners","engineSettings","patch","l","listener","TILE_SIZE","INPUT_STEP_RATE","INPUT_STEP_DT","INPUT_FLAG_DASH","BODY_HALF_WIDTH","BODY_HALF_HEIGHT","COLLISION_EPSILON"],"mappings":"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"}