1681-engine 0.0.0-stage → 0.5.9

package/dist/core/TimelineChild.js

@@ -0,0 +1,83 @@
+import { writeProp as f, readProp as u } from "./tweenProps.js";
+class m {
+  constructor(s, t, i, e = [], h = [], a = [], r = [], n = null, o = null, l = null) {
+    this.kind = s, this.start = t, this.duration = i, this.targets = e, this.props = h, this.ends = a, this.givenFrom = r, this.ease = n, this.fn = o, this.nested = l;
+  }
+  kind;
+  start;
+  duration;
+  targets;
+  props;
+  ends;
+  givenFrom;
+  ease;
+  fn;
+  nested;
+  /** Every target × prop start value, captured once (`inited`). */
+  froms = [];
+  inited = !1;
+  /** Progress (tween) or own time (nested) last written; NaN before the first, so the first always writes. */
+  last = Number.NaN;
+  get end() {
+    return this.start + this.duration;
+  }
+  /**
+   * The playhead moved from `a` to `b` (the parent's own time, either way). Calls fire when `fire` is set and their
+   * time lies in the span with its start left out and its end kept — so a call met at the end of one frame does not
+   * fire again at the start of the next — unless `includeStart` keeps the start too (a run or a repeat beginning).
+   */
+  play(s, t, i, e) {
+    switch (this.kind) {
+      case "tween":
+        this.playTween(t);
+        break;
+      case "call":
+        i && this.fn && p(s, t, this.start, e) && this.fn();
+        break;
+      case "nested":
+        this.playNested(s, t, i, e);
+        break;
+    }
+  }
+  playTween(s) {
+    if (!this.inited) {
+      if (s < this.start) return;
+      this.capture();
+    }
+    let t;
+    if (this.duration > 0 ? t = Math.min(1, Math.max(0, (s - this.start) / this.duration)) : t = s >= this.start ? 1 : 0, t === this.last) return;
+    this.last = t;
+    const i = this.ease ? this.ease(t) : t, e = this.props, h = e.length, a = this.targets;
+    for (let r = 0; r < a.length; r++) {
+      const n = a[r];
+      if (n.destroyed !== !0)
+        for (let o = 0; o < h; o++) {
+          const l = this.froms[r * h + o];
+          f(n, e[o], l + (this.ends[o] - l) * i);
+        }
+    }
+  }
+  capture() {
+    this.inited = !0;
+    const s = this.props;
+    for (const t of this.targets)
+      for (let i = 0; i < s.length; i++) this.froms.push(this.givenFrom[i] ?? u(t, s[i]));
+  }
+  playNested(s, t, i, e) {
+    const h = this.nested;
+    if (!h) return;
+    if (!this.inited) {
+      if (t < this.start) return;
+      this.inited = !0;
+    }
+    const a = h.totalDuration, r = Math.min(a, Math.max(0, s - this.start)), n = Math.min(a, Math.max(0, t - this.start)), l = t >= s ? s < this.start || s === this.start && e : s > this.end || s === this.end && e;
+    r === n && n === this.last && !l || (this.last = n, h.playNested(r, n, i, l));
+  }
+}
+function p(d, s, t, i) {
+  return t === d ? i : s >= d ? t > d && t <= s : t < d && t >= s;
+}
+export {
+  m as TimelineChild,
+  p as crossed
+};

package/dist/core/Tweener.js

@@ -0,0 +1,135 @@
+import { easeByName as m } from "./eases.js";
+import { Timeline as y } from "./Timeline.js";
+import { readProp as w, writeProp as g } from "./tweenProps.js";
+const v = /* @__PURE__ */ new Set([
+  "targets",
+  "duration",
+  "delay",
+  "hold",
+  "yoyo",
+  "repeat",
+  "ease",
+  "props",
+  "onStart",
+  "onUpdate",
+  "onComplete"
+]);
+class k {
+  constructor(e, t) {
+    this.cfg = e, this.ends = t;
+    const s = e.targets;
+    this.targets = Array.isArray(s) ? s : [s];
+  }
+  cfg;
+  ends;
+  tracks = null;
+  elapsed = 0;
+  plays = 0;
+  removed = !1;
+  targets;
+  /**
+   * Every target is a destroyed display object: nothing is left to move. A forever tween (`repeat: -1`) on a sprite
+   * its owner freed used to stay in the list for good, holding the sprite, and the list grew with every map loaded.
+   * A plain object (a clock a callback reads) has no `destroyed` and is never taken for one. Only a forever tween is
+   * dropped this way: a finite one still runs out and calls its `onComplete`, which may clean up more than the sprite.
+   */
+  orphaned() {
+    if (this.cfg.repeat !== -1) return !1;
+    const e = this.targets;
+    if (e.length === 0) return !1;
+    for (const t of e) if (t.destroyed !== !0) return !1;
+    return !0;
+  }
+  remove() {
+    this.removed = !0;
+  }
+  stop() {
+    this.removed = !0;
+  }
+  /** Advances by `dt` ms; returns false once the tween is finished. */
+  step(e) {
+    if (this.removed) return !1;
+    if (this.orphaned())
+      return this.removed = !0, !1;
+    const t = this.cfg, s = t.delay ?? 0;
+    if (this.elapsed += e, this.elapsed < s) return !0;
+    if (!this.tracks) {
+      this.tracks = [];
+      for (const i of this.targets)
+        for (const [p, u] of Object.entries(this.ends)) this.tracks.push({ target: i, prop: p, from: w(i, p), to: u });
+      t.onStart?.();
+    }
+    const n = Math.max(1, t.duration ?? 1e3), a = t.yoyo ? t.hold ?? 0 : 0, o = t.yoyo ? n * 2 + a : n;
+    let r = this.elapsed - s - this.plays * o;
+    const f = t.repeat ?? 0;
+    let h = !1;
+    r >= o && (f === -1 || this.plays < f ? (this.plays++, r -= o) : (r = o, h = !0));
+    let l;
+    t.yoyo ? r <= n ? l = r / n : r <= n + a ? l = 1 : l = 1 - (r - n - a) / n : l = r / n;
+    const d = m(t.ease)(Math.min(1, Math.max(0, l)));
+    for (const i of this.tracks) i.target.destroyed || g(i.target, i.prop, i.from + (i.to - i.from) * d);
+    return t.onUpdate?.(), h ? (this.removed = !0, t.onComplete?.(), !1) : !0;
+  }
+}
+class O {
+  /** Global speed factor; hit-stop slows every tween at once. */
+  timeScale = 1;
+  tweens = [];
+  add(e) {
+    const t = { ...e.props ?? {} }, s = {};
+    for (const [o, r] of Object.entries(e))
+      if (!v.has(o)) {
+        if (typeof r == "number") t[o] = r;
+        else if (r && typeof r == "object" && "to" in r) {
+          const f = r;
+          t[o] = f.to, f.from !== void 0 && (s[o] = f.from);
+        }
+      }
+    const n = Array.isArray(e.targets) ? e.targets : [e.targets];
+    for (const o of n) for (const [r, f] of Object.entries(s)) o[r] = f;
+    const a = new k(e, t);
+    return this.tweens.push(a), a;
+  }
+  /**
+   * Steps `item` every frame from the next one on, at this manager's `timeScale`, until its `step` answers false or
+   * the manager is cleared (a stage's manager is cleared when the stage is destroyed).
+   */
+  run(e) {
+    return this.tweens.push(e), e;
+  }
+  /** A `Timeline` driven by this manager: it follows `timeScale` and stops with `clear`. */
+  timeline(e = {}) {
+    return new y({ ...e, tweens: this });
+  }
+  killTweensOf(e) {
+    const t = new Set(Array.isArray(e) ? e : [e]);
+    for (const s of this.tweens) s.targets.some((n) => t.has(n)) && s.remove();
+  }
+  update(e) {
+    const t = e * this.timeScale, s = this.tweens, n = s.length;
+    let a = 0;
+    for (let o = 0; o < n; o++) {
+      const r = s[o];
+      S(r, t) && (s[a++] = r);
+    }
+    if (this.tweens === s) {
+      for (let o = n; o < s.length; o++) s[a++] = s[o];
+      s.length = a;
+    }
+  }
+  clear() {
+    for (const e of this.tweens) e.remove();
+    this.tweens = [];
+  }
+}
+function S(c, e) {
+  try {
+    return c.step(e);
+  } catch (t) {
+    return console.error("[tween] dropped after an error", t), !1;
+  }
+}
+export {
+  k as Tween,
+  O as Tweener
+};

package/dist/core/atlas.js

@@ -0,0 +1,37 @@
+import { ATLAS_PAGE_FULL as x, planAtlas as u } from "./atlasPlan.js";
+class H {
+  items = [];
+  add(n, s) {
+    this.items.push({ name: n, canvas: s });
+  }
+  addSheet(n, s, r, c) {
+    this.items.push({ name: n, canvas: s, frameWidth: r, frameHeight: c });
+  }
+  build(n, s, r = x) {
+    const c = this.items, d = u(c.map((a) => ({ w: a.canvas.width, h: a.canvas.height })), r), g = d.pages.map((a, t) => {
+      const e = document.createElement("canvas");
+      return e.width = a.width, e.height = a.height, { canvas: e, ctx: e.getContext("2d", { willReadFrequently: !0 }), key: t === 0 ? s : `${s}~${t}` };
+    });
+    c.forEach((a, t) => {
+      const e = d.places[t];
+      g[e.page].ctx.drawImage(a.canvas, e.x, e.y);
+    });
+    const i = n.addCanvas(s, g[0].canvas), p = g.map((a, t) => t === 0 ? i : n.addCanvas(a.key, a.canvas));
+    c.forEach((a, t) => {
+      const e = d.places[t], f = p[e.page], l = (o, m, h, $, w) => {
+        f.add(o, 0, m, h, $, w), e.page > 0 && i.adopt(o, f);
+      };
+      if (a.frameWidth && a.frameHeight) {
+        const o = Math.floor(a.canvas.width / a.frameWidth), m = Math.max(1, Math.floor(a.canvas.height / a.frameHeight));
+        for (let h = 0; h < o * m; h++)
+          l(`${a.name}#${h}`, e.x + h % o * a.frameWidth, e.y + Math.floor(h / o) * a.frameHeight, a.frameWidth, a.frameHeight);
+      } else
+        l(a.name, e.x, e.y, a.canvas.width, a.canvas.height);
+    });
+    const v = d.pages.map((a) => `${a.width}x${a.height}`).join(" + ");
+    console.info(`[atlas] ${s}: ${c.length} images packed into ${v}${d.pages.length > 1 ? ` (pages of ${r})` : ""}`);
+  }
+}
+export {
+  H as AtlasBuilder
+};

package/dist/core/atlasPlan.js

@@ -0,0 +1,21 @@
+const g = 2;
+const p = 8192;
+function w(t) {
+  return t === null || t >= 8192 ? 8192 : Math.min(4096, 2 ** Math.floor(Math.log2(Math.max(1, t))));
+}
+function D(t, _) {
+  const e = t.map((a, A) => A).sort((a, A) => t[A].h - t[a].h), P = t.reduce((a, A) => a + (A.w + 2) * (A.h + 2), 0), f = Math.max(1, ...t.map((a) => a.w + 2)), c = Math.min(_, Math.max(1024, 2 ** Math.ceil(Math.log2(Math.max(f, Math.sqrt(P)))))), l = new Array(t.length), M = [];
+  let r = 0, n = 0, h = 0, o = 0, L = c;
+  const S = () => M.push({ width: L, height: h + o });
+  for (const a of e) {
+    const A = t[a].w + 2, T = t[a].h + 2;
+    n > 0 && n + A > L && (n = 0, h += o, o = 0), h > 0 && h + T > _ && (S(), r++, n = 0, h = 0, o = 0, L = c), A > L && (L = A), l[a] = { page: r, x: n, y: h }, n += A, o = Math.max(o, T);
+  }
+  return t.length > 0 && S(), { pages: M, places: l };
+}
+export {
+  g as ATLAS_PAD,
+  p as ATLAS_PAGE_FULL,
+  w as atlasPageLimit,
+  D as planAtlas
+};

package/dist/core/blendLayer.js

@@ -0,0 +1,11 @@
+const h = /* @__PURE__ */ new WeakMap();
+function r(n, d = {}) {
+  const a = d.blend ?? "add", l = d.name ?? a;
+  let t = h.get(n);
+  t || (t = /* @__PURE__ */ new Map(), h.set(n, t));
+  let e = t.get(l);
+  return !e || e.destroyed ? (e = n.add.container(0, 0).setDepth(d.depth ?? 999e3), e.blendMode = a, t.set(l, e)) : d.depth !== void 0 && e.depth !== d.depth && e.setDepth(d.depth), e;
+}
+export {
+  r as blendLayer
+};

package/dist/core/eases.js

@@ -0,0 +1,20 @@
+const a = (n) => n, e = {
+  Linear: a,
+  "Quad.In": (n) => n * n,
+  "Quad.Out": (n) => n * (2 - n),
+  "Cubic.Out": (n) => 1 - Math.pow(1 - n, 3),
+  "Sine.In": (n) => 1 - Math.cos(n * Math.PI / 2),
+  "Sine.InOut": (n) => -(Math.cos(Math.PI * n) - 1) / 2,
+  "Back.Out": (n) => {
+    const u = n - 1;
+    return u * u * (2.70158 * u + 1.70158) + 1;
+  }
+};
+function o(n) {
+  if (!n) return e["Quad.Out"];
+  const t = e[n];
+  return t || console.warn(`[tween] unknown ease ${n}`), t ?? a;
+}
+export {
+  o as easeByName
+};

package/dist/core/gameObject.js

@@ -0,0 +1,117 @@
+import { ColorMatrixFilter as a } from "pixi.js";
+const e = /* @__PURE__ */ new Map();
+function o(s) {
+  let t = e.get(s);
+  if (t) return t;
+  const i = new a();
+  i.antialias = "off";
+  const r = (s >> 16 & 255) / 255, h = (s >> 8 & 255) / 255, n = (s & 255) / 255;
+  return i.matrix = [0, 0, 0, 0, r, 0, 0, 0, 0, h, 0, 0, 0, 0, n, 0, 0, 0, 1, 0], e.set(s, t = [i]), t;
+}
+function l(s) {
+  s.filters = null;
+}
+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, i = t) {
+      return this.sx = t, this.sy = i, this.applyScale(), this;
+    }
+    setFlipX(t) {
+      return this.flipX = t, this;
+    }
+    setFlipY(t) {
+      return this.flipY = t, this;
+    }
+    setFlip(t, i) {
+      return this.fx = t, this.fy = i, 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, i = t) {
+      return this.position.set(t, i), 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 = o(t), this);
+    }
+    clearTint() {
+      return this.clearFill(), this.tint = 16777215, this;
+    }
+    clearFill() {
+      this.solidFillColor !== null && (l(this), 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 && l(this), this.solidFillColor = null, super.destroy({ children: !0, context: !0 }));
+    }
+  };
+}
+export {
+  f as GameObject
+};

package/dist/core/pixelZoom.js

@@ -0,0 +1,43 @@
+const h = { pxPerStep: 290, baseMin: 2, baseMax: 5, min: 1, max: 6, halfZoom: 1.5 };
+function u(o) {
+  return o ? { ...h, ...o } : h;
+}
+function M(o, r) {
+  const n = u(r);
+  return Math.max(n.baseMin, Math.min(n.baseMax, Math.round(o / n.pxPerStep)));
+}
+function c(o, r = 0, n) {
+  const e = u(n), t = Math.max(e.min, Math.min(e.max, M(o, e) + Math.round(r * 2) / 2));
+  return Number.isInteger(t) || t === e.halfZoom ? t : Math.round(t);
+}
+function l(o, r = [-2, -1, 0, 1], n = -2.5, e) {
+  const t = u(e), f = [...r];
+  if (t.halfZoom !== null) {
+    const a = t.halfZoom - M(o, t);
+    a < 0 && a >= n && f.push(a);
+  }
+  const m = /* @__PURE__ */ new Map();
+  for (const a of f) {
+    const s = c(o, a, t), i = m.get(s);
+    (i === void 0 || Math.abs(a) < Math.abs(i)) && m.set(s, a);
+  }
+  return [...m].map(([a, s]) => ({ offset: s, zoom: a })).sort((a, s) => a.zoom - s.zoom);
+}
+function b(o, r, n = 1.5, e = 4) {
+  if (Number.isInteger(o) || r < n) return 1;
+  for (let t = 2; t <= e; t++) {
+    const f = o * t;
+    if (Math.abs(f - Math.round(f)) < 1e-9) return t;
+  }
+  return 1;
+}
+function p(o, r, n, e) {
+  return o <= 0 || r <= 0 ? 1 : Math.max(1, Math.floor(Math.min(n / o, e / r)));
+}
+export {
+  M as baseZoom,
+  p as fitScale,
+  c as worldZoom,
+  b as zoomResolution,
+  l as zoomSteps
+};

package/dist/core/pixiPatches.js

@@ -0,0 +1,17 @@
+import { BatchTextureArray as n } from "pixi.js";
+let i = !1;
+function l() {
+  if (i) return !0;
+  const e = n.prototype, r = new n();
+  return !(typeof e.clear == "function" && typeof r.ids == "object" && Array.isArray(r.textures) && typeof r.count == "number") || !/ids\[[^\]]+\]\s*=\s*null/.test(String(e.clear)) ? !1 : (e.clear = function() {
+    const c = this.ids, o = this.textures;
+    for (let t = 0; t < this.count; t++) {
+      const s = o[t];
+      o[t] = null, s && delete c[s.uid];
+    }
+    this.count = 0;
+  }, i = !0, !0);
+}
+export {
+  l as patchPixi
+};

package/dist/core/runDue.js

@@ -0,0 +1,28 @@
+function g(t, r, i, l) {
+  let o = 0;
+  for (let e = 0; e < t.length; e++) {
+    const n = t[e];
+    n.removed || (n.at <= i ? r.push(n) : t[o++] = n);
+  }
+  if (t.length = o, !!r.length)
+    try {
+      for (let e = 0; e < r.length; e++) {
+        const n = r[e];
+        if (!n.removed)
+          try {
+            n.fn();
+          } catch (f) {
+            try {
+              l(f);
+            } catch (u) {
+              console.error("[runDue] error handler failed", u);
+            }
+          }
+      }
+    } finally {
+      r.length = 0;
+    }
+}
+export {
+  g as runDue
+};

package/dist/core/silhouette.js

@@ -0,0 +1,49 @@
+import { Texture as h, CanvasSource as g } from "pixi.js";
+let c = /* @__PURE__ */ new WeakMap();
+const l = /* @__PURE__ */ new Set();
+function p(t, o = 16777215) {
+  let e = c.get(t);
+  const n = e?.get(o);
+  if (n && !n.destroyed) return n;
+  const u = t.source.resource, i = t.frame, s = Math.round(i.width), a = Math.round(i.height);
+  if (!u || s <= 0 || a <= 0 || t.rotate || typeof document > "u") return null;
+  const r = document.createElement("canvas");
+  r.width = s, r.height = a;
+  const f = r.getContext("2d");
+  if (!f) return null;
+  try {
+    f.drawImage(u, Math.round(i.x), Math.round(i.y), s, a, 0, 0, s, a);
+  } catch {
+    return null;
+  }
+  m(r, o);
+  const d = new h({
+    source: new g({ resource: r, scaleMode: t.source.scaleMode }),
+    orig: t.orig.clone(),
+    trim: t.trim ? t.trim.clone() : void 0
+  });
+  return e || (e = /* @__PURE__ */ new Map(), c.set(t, e)), e.set(o, d), l.add(d), d;
+}
+function m(t, o = 16777215) {
+  const e = t;
+  if (!e || typeof e.getContext != "function") return;
+  const n = e.getContext("2d");
+  n && (n.save(), n.globalCompositeOperation = "source-in", n.fillStyle = `#${(o & 16777215).toString(16).padStart(6, "0")}`, n.fillRect(0, 0, e.width, e.height), n.restore());
+}
+function y(t) {
+  if (t) {
+    const o = c.get(t);
+    if (!o) return;
+    for (const e of o.values())
+      l.delete(e), e.destroy(!0);
+    c.delete(t);
+    return;
+  }
+  for (const o of l) o.destroy(!0);
+  l.clear(), c = /* @__PURE__ */ new WeakMap();
+}
+export {
+  y as clearSilhouettes,
+  m as fillSolid,
+  p as solidSilhouette
+};

package/dist/core/timelinePlace.js

@@ -0,0 +1,23 @@
+const f = /^(.*?)(?:([+-])=(\d+(?:\.\d+)?))?$/, i = /^\d+(?:\.\d+)?$/;
+function b(s, e) {
+  if (s === void 0) return e.fallback;
+  if (typeof s == "number") return Math.max(0, s);
+  const a = s.trim();
+  if (i.test(a)) return Number(a);
+  const n = f.exec(a);
+  if (!n) return e.fallback;
+  const t = n[1] ?? "";
+  let l;
+  if (t === "") l = e.fallback;
+  else if (t === "<") l = e.lastStart;
+  else if (t === ">") l = e.lastEnd;
+  else {
+    const r = e.labels.get(t);
+    r === void 0 ? (e.labels.set(t, e.end), l = e.end) : l = r;
+  }
+  const o = n[3] === void 0 ? 0 : Number(n[3]) * (n[2] === "-" ? -1 : 1);
+  return Math.max(0, l + o);
+}
+export {
+  b as placeAt
+};

package/dist/core/tweenProps.js

@@ -0,0 +1,11 @@
+function s(c, n) {
+  const e = n === "scale" ? c.scaleX : c[n];
+  return typeof e == "number" ? e : 0;
+}
+function o(c, n, e) {
+  n === "scale" ? (c.scaleX = e, c.scaleY = e) : c[n] = e;
+}
+export {
+  s as readProp,
+  o as writeProp
+};