1681-engine 0.0.0-stage → 0.5.9

package/dist/audio/music/MusicChannel.js

@@ -0,0 +1,57 @@
+class h {
+  constructor(e, t) {
+    this.volume = e, this.makeVoice = t;
+  }
+  volume;
+  makeVoice;
+  voice = null;
+  url = null;
+  level = 1;
+  /** The url of the track playing (or fading in), if any. */
+  get current() {
+    return this.url;
+  }
+  /** Plays `url`, crossfading from what plays now; the track already playing only takes the new `volume`. */
+  play(e, t = {}) {
+    const s = Math.min(1, Math.max(0, t.volume ?? 1));
+    if (e === this.url) {
+      s !== this.level && (this.level = s, this.refresh());
+      return;
+    }
+    if (typeof Audio > "u") return;
+    const o = Math.max(0, t.fadeMs ?? 1200);
+    this.fadeOut(o), this.url = e, this.level = s;
+    const i = new Audio(e);
+    i.loop = t.loop !== !1, i.preload = "auto";
+    const l = this.makeVoice(i);
+    l.set(0), this.voice = l, i.play().catch(() => {
+    }), l.fade(this.target(), o);
+  }
+  /** Fades this channel out and stops it. */
+  stop(e = 1200) {
+    this.fadeOut(Math.max(0, e)), this.url = null;
+  }
+  /** Retries a start the browser refused, and follows the music volume. */
+  refresh() {
+    const e = this.voice;
+    e && (e.el.paused && e.el.play().catch(() => {
+    }), e.busy || e.set(this.target()));
+  }
+  /** Stops where it is (the app went to the background); `refresh` picks it up again. */
+  pause() {
+    this.voice?.el.pause();
+  }
+  dispose() {
+    this.voice?.dispose(), this.voice = null, this.url = null;
+  }
+  target() {
+    return Math.max(0, Math.min(1, this.volume() * this.level));
+  }
+  fadeOut(e) {
+    const t = this.voice;
+    this.voice = null, t && t.fade(0, e, () => t.dispose());
+  }
+}
+export {
+  h as MusicChannel
+};

package/dist/audio/music/musicVoice.js

@@ -0,0 +1,12 @@
+function n() {
+  if (typeof Audio > "u") return !1;
+  const e = typeof navigator < "u" ? navigator : null;
+  if (e && (/iPhone|iPad|iPod/.test(e.userAgent) || /Macintosh/.test(e.userAgent) && e.maxTouchPoints > 1)) return !0;
+  const t = new Audio();
+  return t.volume = 0.5, Math.abs(t.volume - 0.5) > 0.01;
+}
+const o = (e) => Math.max(0, Math.min(1, e));
+export {
+  o as clamp01,
+  n as elementVolumeLocked
+};

package/dist/audio/sampleBank.js

@@ -0,0 +1,81 @@
+import { cleanSamples as d } from "./cleanTake.js";
+const c = {};
+function k(e) {
+  for (const [n, t] of Object.entries(e)) {
+    const r = /(?:^|\/)([a-z_]+?)(?:_\d+)?\.mp3$/.exec(n);
+    r && (c[r[1]] ??= []).push(t);
+  }
+}
+const y = (e) => !!c[e];
+class M {
+  decoded = /* @__PURE__ */ new Map();
+  loading = /* @__PURE__ */ new Set();
+  last = /* @__PURE__ */ new Map();
+  names() {
+    return Object.keys(c);
+  }
+  /** A decoded take, or null while none is ready (the caller then synthesises); starts loading on first ask. */
+  take(n, t) {
+    const r = this.decoded.get(t);
+    if (!r?.length)
+      return this.load(n, t), null;
+    let s = Math.floor(Math.random() * r.length);
+    return r.length > 1 && s === this.last.get(t) && (s = (s + 1) % r.length), this.last.set(t, s), r[s];
+  }
+  load(n, t) {
+    const r = c[t];
+    if (!r || this.loading.has(t)) return;
+    this.loading.add(t);
+    const s = [];
+    this.decoded.set(t, s);
+    for (const l of r)
+      fetch(l).then((a) => a.arrayBuffer()).then((a) => n.decodeAudioData(a)).then((a) => p(a)).then((a) => {
+        if (!a) return;
+        const h = n.createBuffer(1, a.length, n.sampleRate);
+        h.copyToChannel(a, 0), s.push(h);
+      }).catch(() => {
+      });
+  }
+}
+let o, f = 0;
+const i = /* @__PURE__ */ new Map();
+function m() {
+  if (o !== void 0) return o;
+  try {
+    o = new Worker(new URL(
+      /* @vite-ignore */
+      "" + new URL("../assets/takeCleanerWorker-DTcI_Jqr.js", import.meta.url).href,
+      import.meta.url
+    ), { type: "module" }), o.onmessage = (e) => {
+      i.get(e.data.id)?.(e.data.data), i.delete(e.data.id);
+    }, o.onerror = () => {
+      o?.terminate(), o = null;
+      for (const e of i.values()) e(null);
+      i.clear();
+    };
+  } catch {
+    o = null;
+  }
+  return o;
+}
+let u = Promise.resolve();
+function p(e) {
+  return new Promise((n) => {
+    u = u.then(() => new Promise((t) => setTimeout(t, 0))).then(() => {
+      g(e).then(n, () => n(null));
+    });
+  });
+}
+function g(e) {
+  const n = Array.from({ length: e.numberOfChannels }, (s, l) => e.getChannelData(l).slice()), t = m();
+  if (!t) return Promise.resolve(d(n, e.sampleRate));
+  const r = f++;
+  return new Promise((s) => {
+    i.set(r, s), t.postMessage({ id: r, channels: n, sampleRate: e.sampleRate }, { transfer: n.map((l) => l.buffer) });
+  });
+}
+export {
+  M as SampleBank,
+  y as hasTakes,
+  k as registerTakes
+};

package/dist/audio/soundTable.js

@@ -0,0 +1,8 @@
+const s = { master: 1, recipes: {} };
+function r(e) {
+  e.master !== void 0 && (s.master = e.master), e.recipes && Object.assign(s.recipes, e.recipes);
+}
+export {
+  s as SOUNDS,
+  r as registerSounds
+};

package/dist/audio/synth.js

@@ -0,0 +1,35 @@
+const Y = 22050, N = {
+  sine: (e) => Math.sin(e * Math.PI * 2),
+  square: (e, a) => e < a ? 1 : -1,
+  tri: (e) => 1 - 4 * Math.abs(e - 0.5),
+  saw: (e) => 2 * e - 1
+}, i = (e, a, n) => e > 0 && a > 0 ? e * Math.pow(a / e, n) : e + (a - e) * n;
+function R(e) {
+  return 1 - Math.exp(-2 * Math.PI * Math.min(e, 22050 * 0.45) / 22050);
+}
+function _(e) {
+  const a = Math.max(...e.layers.map((t) => (t.d ?? 0) + t.t)), n = new Float32Array(Math.ceil(a * 22050) + 1);
+  let s = 2654435769;
+  const S = () => (s ^= s << 13, s ^= s >>> 17, s ^= s << 5, (s >>> 0) / 4294967295 * 2 - 1);
+  for (const t of e.layers) {
+    const u = Math.round((t.d ?? 0) * 22050), f = Math.round(t.t * 22050), l = Math.max(1, Math.round((t.at ?? 4e-3) * 22050));
+    let c = 0, A = 0, M = 0, T = 0;
+    for (let o = 0; o < f && u + o < n.length; o++) {
+      const p = o / f, d = t.f ? i(t.f[0], t.f[1], p) : 0;
+      c += d / 22050;
+      const E = c - Math.floor(c);
+      let h;
+      t.w === "noise" ? ((!t.f || E < d / 22050 || o === 0) && (A = S()), h = t.f ? A : S()) : h = N[t.w](E, t.duty ?? 0.5), t.lp && (M += (h - M) * R(i(t.lp[0], t.lp[1], p)), h = M), t.hp && (T += (h - T) * R(i(t.hp[0], t.hp[1], p)), h -= T);
+      const H = o < l ? o / l : Math.pow(1 - (o - l) / Math.max(1, f - l), t.c ?? 2);
+      n[u + o] += h * H * t.g;
+    }
+  }
+  let r = 0;
+  for (const t of n) r = Math.max(r, Math.abs(t));
+  if (r > 0.95) for (let t = 0; t < n.length; t++) n[t] *= 0.95 / r;
+  return n;
+}
+export {
+  Y as SYNTH_RATE,
+  _ as renderRecipe
+};

package/dist/core/BitmapLabel.js

@@ -0,0 +1,48 @@
+import { DynamicBitmapFont as S, BitmapFont as d, BitmapText as $ } from "pixi.js";
+import { GameObject as h } from "./gameObject.js";
+const m = /* @__PURE__ */ new Set(), u = [[" ", "~"]];
+function w(s) {
+  u.push(s);
+}
+const x = 128;
+function b(s, t, e, r, c, a, n = "") {
+  const i = `label|${s}|${t}|${e}|${r}|${c}|${a}${n ? `|${n}` : ""}`;
+  if (!m.has(i)) {
+    const o = S.defaultOptions, l = o.textureSize;
+    o.textureSize = x;
+    try {
+      d.install({
+        name: i,
+        chars: n ? [...u, n] : u,
+        resolution: a,
+        style: { fontFamily: s, fontSize: t, fill: e, stroke: { color: r, width: c, join: "round" } }
+      });
+    } finally {
+      o.textureSize = l;
+    }
+    m.add(i);
+  }
+  return i;
+}
+class y extends h($) {
+  /**
+   * `fontFamily` must already be loaded (`document.fonts.load`), or the glyphs bake in the fallback.
+   * Styled like `worldText`: the same font, size, colour and outline, rasterised at the same resolution. `glyphs`:
+   * letters beyond ASCII it prints (see `installLabelFont`).
+   */
+  constructor(t, e, r, c, a, n, i, o, l, f = "") {
+    const p = b(c, a, n, i, o, l, f);
+    super({ text: r, style: { fontFamily: p, fontSize: a } }), this.position.set(t, e);
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.anchor.set(t, e), this;
+  }
+  setText(t) {
+    return this.text = t, this;
+  }
+}
+export {
+  y as BitmapLabel,
+  w as addLabelGlyphs,
+  b as installLabelFont
+};

package/dist/core/Camera.js

@@ -0,0 +1,149 @@
+import { Rectangle as k } from "./Rectangle.js";
+class g {
+  constructor(t, s) {
+    this.world = t, this.screen = s;
+  }
+  world;
+  screen;
+  zoom = 1;
+  /** The zoom `reset` goes back to: the engine sets it from its `zoom` option (default 1). */
+  defaultZoom = 1;
+  /** Backing pixels per screen pixel (the renderer's resolution, `zoomResolution(zoom, devicePixelRatio)`): what `snap` rounds to. */
+  resolution = 1;
+  /** Lands the view on whole backing pixels (pixel art); off, the world moves smoothly between them. */
+  roundPixels = !1;
+  scrollX = 0;
+  scrollY = 0;
+  width = 0;
+  height = 0;
+  bounds = null;
+  shakeUntil = 0;
+  shakeMs = 1;
+  shakeAngle = void 0;
+  shakeIntensity = 0;
+  flashRect = null;
+  flashStart = 0;
+  flashMs = 1;
+  flashPeak = 1;
+  /** Screen-layer containers laid over the world with its exact transform, shake included (see `follow`). */
+  followers = /* @__PURE__ */ new Set();
+  target = null;
+  trackOpts = { lerp: 1, deadzoneWidth: 0, deadzoneHeight: 0, offsetX: 0, offsetY: 0 };
+  lastApply = -1;
+  get worldView() {
+    const t = this.width / this.zoom, s = this.height / this.zoom;
+    return { x: this.scrollX, y: this.scrollY, width: t, height: s, right: this.scrollX + t, bottom: this.scrollY + s };
+  }
+  setZoom(t) {
+    return this.zoom = t, this;
+  }
+  /** A world coordinate snapped to the nearest backing pixel: one screen pixel, or a half at ×1.5. */
+  snap(t) {
+    const s = this.zoom * this.resolution;
+    return Math.round(t * s) / s;
+  }
+  setBounds(t, s, h, e) {
+    return this.bounds = { x: t, y: s, width: h, height: e }, this;
+  }
+  /** Lets the view go anywhere again. */
+  clearBounds() {
+    return this.bounds = null, this;
+  }
+  /**
+   * Back to how the engine made it: no target, no bounds, `defaultZoom`, scrolled to 0, no shake or flash. The camera
+   * is the engine's, shared by every scene, so a level's target and bounds would otherwise hold over the next scene
+   * (a title screen kept following a hero that no longer existed). `SceneManager.replace` calls it between the old
+   * scenes leaving and the new one entering; `push` and `pop` leave the camera alone, since the scene under a pause
+   * menu still wants its view when it comes back. Layers added with `follow` are kept: they belong to tools that
+   * outlive scenes (a debug overlay), not to a scene.
+   */
+  reset() {
+    return this.target = null, this.bounds = null, this.zoom = this.defaultZoom, this.scrollX = 0, this.scrollY = 0, this.shakeUntil = 0, this.shakeIntensity = 0, this.flashRect && !this.flashRect.destroyed && this.flashRect.setVisible(!1), this;
+  }
+  /** The tracked target, if any. */
+  get tracking() {
+    return this.target;
+  }
+  /** The bounds the view is kept inside, if any. */
+  get boundsRect() {
+    return this.bounds;
+  }
+  centerOn(t, s) {
+    return this.scrollX = t - this.width / this.zoom / 2, this.scrollY = s - this.height / this.zoom / 2, this.clamp(), this;
+  }
+  setScroll(t, s) {
+    return this.scrollX = t, this.scrollY = s, this.clamp(), this;
+  }
+  /**
+   * Screen shake: `intensity` is a fraction of the screen size, like before. With an `angle` (the way a blow travelled)
+   * the shake runs back and forth along it instead of at random, so a hit is felt coming from somewhere.
+   */
+  shake(t, s, h) {
+    const e = performance.now();
+    e < this.shakeUntil && s < this.shakeIntensity || (this.shakeUntil = e + t, this.shakeMs = t, this.shakeIntensity = s, this.shakeAngle = h);
+  }
+  /**
+   * Keeps a container on the screen layer placed exactly over the world layer — zoom, scroll and this frame's
+   * shake — for things drawn in world units above the screen-layer night (fireflies). Written in `apply`, after
+   * the scene updated, so it never lags the world by a frame or misses a shake the world takes.
+   */
+  follow(t) {
+    this.followers.add(t);
+  }
+  unfollow(t) {
+    this.followers.delete(t);
+  }
+  /** Full-screen colour flash starting at `peak` alpha and fading out over `ms`. */
+  flash(t, s, h, e, r = !1, o = 1) {
+    (!this.flashRect || this.flashRect.destroyed) && (this.flashRect = new k(1, 1, 16777215).setOrigin(0, 0), this.screen.addChild(this.flashRect)), this.flashRect.resize(this.width, this.height).setFillStyle(s << 16 | h << 8 | e).setAlpha(o).setVisible(!0), this.flashStart = performance.now(), this.flashMs = t, this.flashPeak = o;
+  }
+  /**
+   * Keeps `target` (anything with `x` and `y`, read every frame: an entity's position, a sprite) in view, inside the
+   * bounds if there are any. Replaces any target before.
+   */
+  track(t, s = {}) {
+    return this.target = t, this.trackOpts = { lerp: 1, deadzoneWidth: 0, deadzoneHeight: 0, offsetX: 0, offsetY: 0, ...s }, (s.lerp ?? 1) >= 1 && this.centerOn(t.x + this.trackOpts.offsetX, t.y + this.trackOpts.offsetY), this;
+  }
+  untrack() {
+    return this.target = null, this;
+  }
+  /** Moves the view toward the tracked target for a frame `dtMs` long. */
+  follow1(t) {
+    const s = this.target;
+    if (!s) return;
+    const h = this.trackOpts, e = this.width / this.zoom, r = this.height / this.zoom, o = this.scrollX + e / 2, n = this.scrollY + r / 2, i = s.x + h.offsetX, l = s.y + h.offsetY, a = h.deadzoneWidth / 2, c = h.deadzoneHeight / 2, f = i - o > a ? i - o - a : i - o < -a ? i - o + a : 0, u = l - n > c ? l - n - c : l - n < -c ? l - n + c : 0, d = h.lerp >= 1 ? 1 : 1 - Math.pow(1 - Math.max(0, h.lerp), t / (1e3 / 60));
+    this.scrollX += f * d, this.scrollY += u * d, this.clamp();
+  }
+  /** Writes the camera into the world layer; called once per frame after the scene updated. */
+  apply(t) {
+    const s = this.lastApply < 0 ? 16.666666666666668 : Math.min(100, t - this.lastApply);
+    this.lastApply = t, this.follow1(s);
+    let h = 0, e = 0;
+    if (t < this.shakeUntil) {
+      const i = (this.shakeUntil - t) / this.shakeMs;
+      if (this.shakeAngle !== void 0) {
+        const l = Math.cos((t - (this.shakeUntil - this.shakeMs)) / 28 * Math.PI) * this.shakeIntensity * this.width * i;
+        h = Math.round(Math.cos(this.shakeAngle) * l), e = Math.round(Math.sin(this.shakeAngle) * l);
+      } else
+        h = Math.round((Math.random() * 2 - 1) * this.shakeIntensity * this.width * i), e = Math.round((Math.random() * 2 - 1) * this.shakeIntensity * this.height * i);
+    }
+    this.world.scale.set(this.zoom);
+    const r = this.zoom * this.resolution, o = this.roundPixels ? Math.round(this.scrollX * r) / this.resolution : this.scrollX * this.zoom, n = this.roundPixels ? Math.round(this.scrollY * r) / this.resolution : this.scrollY * this.zoom;
+    this.world.position.set(-o + h, -n + e);
+    for (const i of this.followers)
+      i.scale.set(this.zoom), i.position.copyFrom(this.world.position);
+    if (this.flashRect?.visible) {
+      const i = (t - this.flashStart) / this.flashMs;
+      i >= 1 ? this.flashRect.setVisible(!1) : this.flashRect.alpha = this.flashPeak * (1 - i);
+    }
+  }
+  clamp() {
+    const t = this.bounds;
+    if (!t) return;
+    const s = this.width / this.zoom, h = this.height / this.zoom;
+    this.scrollX = s >= t.width ? t.x + (t.width - s) / 2 : Math.min(Math.max(this.scrollX, t.x), t.x + t.width - s), this.scrollY = h >= t.height ? t.y + (t.height - h) / 2 : Math.min(Math.max(this.scrollY, t.y), t.y + t.height - h);
+  }
+}
+export {
+  g as Camera
+};

package/dist/core/Clock.js

@@ -0,0 +1,40 @@
+import { runDue as o } from "./runDue.js";
+class i {
+  constructor(e, r) {
+    this.at = e, this.fn = r;
+  }
+  at;
+  fn;
+  removed = !1;
+  /** An arrow, so a handle's `remove` still works when taken off it (`const { remove } = …`). */
+  remove = () => {
+    this.removed = !0;
+  };
+}
+class h {
+  now = performance.now();
+  /** Told of every error a timer throws (default: logged). `Stage` routes it into its guarded-step reporting. */
+  onError = (e) => console.error("[timer] failed", e);
+  timers = [];
+  due = [];
+  /** Made once, so `update` hands `runDue` no fresh closure; reads `onError` late so it may be swapped any time. */
+  report = (e) => this.onError(e);
+  delayedCall(e, r) {
+    const t = new i(this.now + e, r);
+    return this.timers.push(t), t;
+  }
+  /** Timers waiting to run (removed ones not yet swept included). */
+  get pending() {
+    return this.timers.length;
+  }
+  update(e) {
+    this.now = e, o(this.timers, this.due, e, this.report);
+  }
+  clear() {
+    for (const e of this.due) e.removed = !0;
+    this.timers.length = 0;
+  }
+}
+export {
+  h as Clock
+};

package/dist/core/Graphics.js

@@ -0,0 +1,68 @@
+import { Graphics as h, Container as n } from "pixi.js";
+import { GameObject as o } from "./gameObject.js";
+class u extends o(n) {
+  g = new h();
+  fill = { color: 16777215, alpha: 1 };
+  line = { width: 1, color: 16777215, alpha: 1 };
+  constructor() {
+    super(), this.addChild(this.g);
+  }
+  fillStyle(t, i = 1) {
+    return this.fill = { color: t, alpha: i }, this;
+  }
+  lineStyle(t, i, e = 1) {
+    return this.line = { width: t, color: i, alpha: e }, this;
+  }
+  clear() {
+    return this.g.clear(), this;
+  }
+  fillRect(t, i, e, l) {
+    return this.g.rect(t, i, e, l).fill(this.fill), this;
+  }
+  fillEllipse(t, i, e, l) {
+    return this.g.ellipse(t, i, e / 2, l / 2).fill(this.fill), this;
+  }
+  strokeEllipse(t, i, e, l) {
+    return this.g.ellipse(t, i, e / 2, l / 2).stroke(this.line), this;
+  }
+  fillCircle(t, i, e) {
+    return this.g.circle(t, i, e).fill(this.fill), this;
+  }
+  strokeCircle(t, i, e) {
+    return this.g.circle(t, i, e).stroke(this.line), this;
+  }
+  lineBetween(t, i, e, l) {
+    return this.g.moveTo(t, i).lineTo(e, l).stroke(this.line), this;
+  }
+  fillPoints(t, i = !0) {
+    return this.g.poly(t.flatMap((e) => [e.x, e.y]), !0).fill(this.fill), this;
+  }
+  strokePoints(t, i = !1) {
+    return this.g.poly(t.flatMap((e) => [e.x, e.y]), i).stroke(this.line), this;
+  }
+  /** A pie slice from the centre, for cone telegraphs. */
+  slice(t, i, e, l, s, r = !1) {
+    return this.g.moveTo(t, i).arc(t, i, e, l, s, r).closePath(), this;
+  }
+  beginPath() {
+    return this.g.beginPath(), this;
+  }
+  moveTo(t, i) {
+    return this.g.moveTo(t, i), this;
+  }
+  lineTo(t, i) {
+    return this.g.lineTo(t, i), this;
+  }
+  closePath() {
+    return this.g.closePath(), this;
+  }
+  fillPath() {
+    return this.g.fill(this.fill), this;
+  }
+  strokePath() {
+    return this.g.stroke(this.line), this;
+  }
+}
+export {
+  u as Graphics
+};

package/dist/core/Group.js

@@ -0,0 +1,28 @@
+import { Container as r } from "pixi.js";
+import { GameObject as i } from "./gameObject.js";
+class a extends i(r) {
+  get list() {
+    return this.children;
+  }
+  add(t) {
+    for (const e of Array.isArray(t) ? t : [t]) this.addChild(e);
+    return this;
+  }
+  addAt(t, e) {
+    return this.addChildAt(t, Math.min(e, this.children.length)), this;
+  }
+  remove(t, e = !1) {
+    return t.parent === this && this.removeChild(t), e && t.destroy({ children: !0, context: !0 }), this;
+  }
+  /** Puts `child` directly below `other` in the draw order. */
+  moveBelow(t, e) {
+    return t.parent !== this || e.parent !== this || t === e ? this : (this.removeChild(t), this.addChildAt(t, this.getChildIndex(e)), this);
+  }
+  /** Puts `child` directly above `other` in the draw order. */
+  moveAbove(t, e) {
+    return t.parent !== this || e.parent !== this || t === e ? this : (this.removeChild(t), this.addChildAt(t, this.getChildIndex(e) + 1), this);
+  }
+}
+export {
+  a as Group
+};

package/dist/core/Image.js

@@ -0,0 +1,50 @@
+import { Sprite as h } from "pixi.js";
+import { GameObject as a } from "./gameObject.js";
+class o extends a(h) {
+  constructor(t, e, s, r, i) {
+    super(t.get(r, i)), this.registry = t, this.textureKey = r, this.frameName = i === void 0 ? "" : String(i), this.anchor.set(0.5), this.position.set(e, s);
+  }
+  registry;
+  textureKey;
+  frameName;
+  get originX() {
+    return this.anchor.x;
+  }
+  get originY() {
+    return this.anchor.y;
+  }
+  /** Width of the frame itself, unscaled. */
+  get frameWidth() {
+    return this.texture.orig.width;
+  }
+  get frameHeight() {
+    return this.texture.orig.height;
+  }
+  get displayWidth() {
+    return Math.abs(this.frameWidth * this.scaleX);
+  }
+  set displayWidth(t) {
+    this.scaleX = t / this.frameWidth;
+  }
+  get displayHeight() {
+    return Math.abs(this.frameHeight * this.scaleY);
+  }
+  set displayHeight(t) {
+    this.scaleY = t / this.frameHeight;
+  }
+  setOrigin(t = 0.5, e = t) {
+    return this.anchor.set(t, e), this;
+  }
+  setDisplaySize(t, e) {
+    return this.setScale(t / this.frameWidth, e / this.frameHeight);
+  }
+  setFrame(t) {
+    return this.frameName = String(t), this.texture = this.registry.get(this.textureKey, t), this;
+  }
+  setTexture(t, e) {
+    return this.textureKey = t, this.frameName = e === void 0 ? "" : String(e), this.texture = this.registry.get(t, e), this;
+  }
+}
+export {
+  o as Image
+};

package/dist/core/ObjectFactory.js

@@ -0,0 +1,54 @@
+import { BitmapLabel as m } from "./BitmapLabel.js";
+import { Graphics as u } from "./Graphics.js";
+import { Group as g } from "./Group.js";
+import { Image as p } from "./Image.js";
+import { Rectangle as l } from "./Rectangle.js";
+import { Text as x } from "./Text.js";
+class L {
+  constructor(t) {
+    this.stage = t;
+  }
+  stage;
+  image(t, e, r, a) {
+    return this.attach(new p(this.stage.textures, t, e, r, a));
+  }
+  /**
+   * A copy of `src` as it is drawn right now (afterimages, clones). A live texture, repainted every frame, is
+   * snapshotted first, and the snapshot is freed with the copy.
+   */
+  still(t, e, r) {
+    const a = this.stage.textures;
+    if (!a.isLive(r.textureKey)) return this.image(t, e, r.textureKey, r.frameName);
+    const s = a.snapshot(r.textureKey, r.frameName), i = this.image(t, e, s, "0");
+    return i.once("destroyed", () => a.remove(s)), i;
+  }
+  graphics(t) {
+    const e = this.attach(new u());
+    return e.position.set(t?.x ?? 0, t?.y ?? 0), e;
+  }
+  container(t = 0, e = 0, r = []) {
+    const a = this.attach(new g());
+    return a.position.set(t, e), a.add(r), a;
+  }
+  rectangle(t, e, r, a, s, i = 1) {
+    const n = this.attach(new l(r, a, s, i));
+    return n.position.set(t, e), n;
+  }
+  text(t, e, r, a) {
+    return this.attach(new x(t, e, r, a));
+  }
+  /** A bitmap-font label (`BitmapLabel`): cheap to change, for text rewritten many times a second. */
+  label(t, e, r, a, s, i, n, o, h, c = "") {
+    return this.attach(new m(t, e, r, a, s, i, n, o, h, c));
+  }
+  /** Puts an object made elsewhere on the world layer, as the factory's own are (a `PixelLayer`, a custom class). */
+  existing(t) {
+    return this.attach(t);
+  }
+  attach(t) {
+    return t.scene = this.stage, this.stage.world.addChild(t), t;
+  }
+}
+export {
+  L as ObjectFactory
+};