1681-engine 0.5.9 → 0.6.0

package/dist/ai/behaviorTree.js

@@ -0,0 +1,198 @@
+class k {
+  constructor(t) {
+    this.root = t;
+  }
+  root;
+  /** A new agent on this tree, with memory of its own. */
+  agent() {
+    return new p(this.root);
+  }
+}
+class p {
+  constructor(t) {
+    this.root = t;
+  }
+  root;
+  now = 0;
+  memory = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Map();
+  /** Nodes that answered 'running' last time they ticked: the ones a halt must reach. */
+  open = /* @__PURE__ */ new Set();
+  last = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Map();
+  /** Ticks the tree once at time `now` (ms) and returns the root's answer. */
+  update(t, e) {
+    this.now = e, this.seen = /* @__PURE__ */ new Map();
+    const n = this.tick(this.root, t);
+    return this.last = this.seen, n;
+  }
+  /** Halts whatever is running and forgets all memory: the agent starts the tree afresh (it died, it was stunned). */
+  reset(t) {
+    this.halt(this.root, t), this.memory.clear(), this.kept.clear(), this.open.clear(), this.last.clear();
+  }
+  /** Whether a node is running for this agent now. */
+  isRunning(t) {
+    return this.open.has(t);
+  }
+  state(t, e) {
+    return this.memory.has(t) || this.memory.set(t, e()), this.memory.get(t);
+  }
+  lasting(t, e) {
+    return this.kept.has(t) || this.kept.set(t, e()), this.kept.get(t);
+  }
+  tick(t, e) {
+    const n = t.tick(e, this);
+    return this.seen.set(t, n), n === "running" ? this.open.add(t) : (this.open.delete(t), this.memory.delete(t)), n;
+  }
+  halt(t, e) {
+    if (this.open.has(t)) {
+      for (const n of t.children) this.halt(n, e);
+      t.halt?.(e, this), this.open.delete(t), this.memory.delete(t);
+    }
+  }
+  /** The tree as it ran on the last tick, depth first: for a debug overlay. */
+  trace() {
+    const t = [], e = (n, r) => {
+      t.push({ depth: r, kind: n.kind, name: n.name, status: this.last.get(n) ?? null });
+      for (const o of n.children) e(o, r + 1);
+    };
+    return e(this.root, 0), t;
+  }
+}
+function m(s) {
+  return s.map((t) => `${"  ".repeat(t.depth)}${t.name ?? t.kind} ${t.status ?? "·"}`).join(`
+`);
+}
+const u = (s, t, e, n = {}) => ({
+  kind: s,
+  children: t,
+  tick: e,
+  ...n
+});
+function w(...s) {
+  const t = u("sequence", s, (e, n) => {
+    const r = n.state(t, () => ({ i: 0 }));
+    for (; r.i < s.length; r.i++) {
+      const o = n.tick(s[r.i], e);
+      if (o !== "success") return o;
+    }
+    return "success";
+  });
+  return t;
+}
+function y(...s) {
+  const t = u("selector", s, (e, n) => {
+    const r = n.state(t, () => ({ i: 0 }));
+    for (; r.i < s.length; r.i++) {
+      const o = n.tick(s[r.i], e);
+      if (o !== "failure") return o;
+    }
+    return "failure";
+  });
+  return t;
+}
+function v(...s) {
+  return g("reactive-sequence", s, "success");
+}
+function M(...s) {
+  return g("reactive-selector", s, "failure");
+}
+function g(s, t, e) {
+  return u(s, t, (n, r) => {
+    for (let o = 0; o < t.length; o++) {
+      const i = r.tick(t[o], n);
+      if (i !== e) {
+        for (let c = o + 1; c < t.length; c++) r.halt(t[c], n);
+        return i;
+      }
+    }
+    return e;
+  });
+}
+function b(s, ...t) {
+  const e = Math.min(t.length, s.succeed ?? t.length), n = Math.min(t.length, s.fail ?? 1), r = u("parallel", t, (o, i) => {
+    const c = i.state(r, () => /* @__PURE__ */ new Map());
+    for (let a = 0; a < t.length; a++) {
+      if (c.has(a)) continue;
+      const h = i.tick(t[a], o);
+      h !== "running" && c.set(a, h);
+    }
+    let f = 0, l = 0;
+    for (const a of c.values()) a === "success" ? f++ : l++;
+    if (f < e && l < n) return "running";
+    for (const a of t) i.halt(a, o);
+    return f >= e ? "success" : "failure";
+  });
+  return r;
+}
+function q(s) {
+  return u("invert", [s], (t, e) => {
+    const n = e.tick(s, t);
+    return n === "success" ? "failure" : n === "failure" ? "success" : "running";
+  });
+}
+function A(s) {
+  return u("succeed", [s], (t, e) => e.tick(s, t) === "running" ? "running" : "success");
+}
+function S(s, t) {
+  const e = u("repeat", [t], (n, r) => {
+    const o = r.state(e, () => ({ n: 0 })), i = r.tick(t, n);
+    return i !== "success" ? i : (o.n++, o.n >= s ? "success" : "running");
+  });
+  return e;
+}
+function $(s, t) {
+  const e = u("retry", [t], (n, r) => {
+    const o = r.state(e, () => ({ n: 0 })), i = r.tick(t, n);
+    return i !== "failure" ? i : (o.n++, o.n >= s ? "failure" : "running");
+  });
+  return e;
+}
+function j(s, t) {
+  const e = u("cooldown", [t], (n, r) => {
+    const o = r.lasting(e, () => ({ readyAt: -1 / 0 }));
+    if (r.now < o.readyAt) return "failure";
+    const i = r.tick(t, n);
+    return i !== "running" && (o.readyAt = r.now + s), i;
+  });
+  return e;
+}
+function B(s, t) {
+  const e = u("timeout", [t], (n, r) => {
+    const o = r.state(e, () => ({ began: r.now }));
+    return r.now - o.began >= s ? (r.halt(t, n), "failure") : r.tick(t, n);
+  });
+  return e;
+}
+function H(s) {
+  const t = u("wait", [], (e, n) => {
+    const r = n.state(t, () => ({ began: n.now }));
+    return n.now - r.began >= s ? "success" : "running";
+  });
+  return t;
+}
+function T(s, t) {
+  return u("condition", [], (e) => t(e) ? "success" : "failure", { name: s });
+}
+function F(s, t, e = {}) {
+  return u("action", [], (n, r) => t(n, r.now), { name: s, halt: e.onHalt ? (n) => e.onHalt(n) : void 0 });
+}
+export {
+  k as BehaviorTree,
+  p as BtAgent,
+  F as action,
+  T as condition,
+  j as cooldown,
+  m as formatTrace,
+  q as invert,
+  b as parallel,
+  M as reactiveSelector,
+  v as reactiveSequence,
+  S as repeat,
+  $ as retry,
+  y as selector,
+  w as sequence,
+  A as succeed,
+  B as timeout,
+  H as wait
+};

package/dist/ai/buildTree.js

@@ -0,0 +1,54 @@
+import { action as m, condition as s, wait as h, timeout as $, cooldown as y, retry as b, repeat as w, succeed as q, invert as v, parallel as S, reactiveSelector as k, reactiveSequence as A, selector as H, sequence as T } from "./behaviorTree.js";
+function x(e, t) {
+  return l(e, t, "$", []);
+}
+function l(e, t, u, c) {
+  const r = (n) => {
+    throw new Error(`buildTree: ${u}: ${n}`);
+  };
+  if (!e || typeof e != "object") return r("not a node");
+  const a = (n) => !Array.isArray(n) || n.length === 0 ? r("needs children") : n.map((d, f) => l(d, t, `${u}.children[${f}]`, c)), i = (n) => l(n, t, `${u}.child`, c), o = (n, d) => typeof n == "number" && n >= 0 ? n : r(`${d} must be a number of at least 0`);
+  switch (e.type) {
+    case "sequence":
+      return T(...a(e.children));
+    case "selector":
+      return H(...a(e.children));
+    case "reactiveSequence":
+      return A(...a(e.children));
+    case "reactiveSelector":
+      return k(...a(e.children));
+    case "parallel":
+      return S({ succeed: e.succeed, fail: e.fail }, ...a(e.children));
+    case "invert":
+      return v(i(e.child));
+    case "succeed":
+      return q(i(e.child));
+    case "repeat":
+      return w(o(e.times, "times"), i(e.child));
+    case "retry":
+      return b(o(e.times, "times"), i(e.child));
+    case "cooldown":
+      return y(o(e.ms, "ms"), i(e.child));
+    case "timeout":
+      return $(o(e.ms, "ms"), i(e.child));
+    case "wait":
+      return h(o(e.ms, "ms"));
+    case "condition": {
+      const n = t.conditions?.[e.name];
+      return n ? s(e.name, n) : r(`no condition '${e.name}'`);
+    }
+    case "action": {
+      const n = t.actions?.[e.name];
+      return n ? typeof n == "function" ? m(e.name, n) : m(e.name, n.run, { onHalt: n.onHalt }) : r(`no action '${e.name}'`);
+    }
+    case "tree": {
+      const n = t.trees?.[e.name];
+      return n ? c.includes(e.name) ? r(`tree '${e.name}' contains itself`) : l(n, t, `${u}<${e.name}>`, [...c, e.name]) : r(`no tree '${e.name}'`);
+    }
+    default:
+      return r(`unknown type '${e.type}'`);
+  }
+}
+export {
+  x as buildTree
+};

package/dist/ambient/life/Birds.js

@@ -0,0 +1,73 @@
+import { birdFrame as x, flockSlot as m } from "./lifeMotion.js";
+class b {
+  constructor(s, t) {
+    this.options = t, this.snap = t.snap ?? !0, this.random = t.random ?? Math.random;
+    const e = t.maxFlock ?? 6;
+    for (let i = 0; i < e; i++) {
+      const d = s.add.image(0, 0, t.frames[0]).setOrigin(0.5, 0.5).setDepth(t.depth ?? 95e4).setVisible(!1), n = t.shadow ? s.add.image(0, 0, t.shadow).setOrigin(0.5, 0.5).setDepth(t.shadowDepth ?? -999980).setVisible(!1) : null;
+      this.birds.push({ img: d, shadow: n, dx: 0, dy: 0, flap: this.random() * 1e3 });
+    }
+  }
+  options;
+  birds = [];
+  snap;
+  random;
+  active = 0;
+  nextAt = Number.NaN;
+  x = 0;
+  y = 0;
+  vx = 0;
+  vy = 0;
+  altitude = 60;
+  /** Whether a flock is crossing now. */
+  get flying() {
+    return this.active > 0;
+  }
+  update(s, t, e, i, d = !0) {
+    if (Number.isNaN(this.nextAt)) {
+      const [o, h] = this.options.firstMs ?? [3e3, 9e3];
+      this.nextAt = s + o + this.random() * (h - o);
+    }
+    if (!d) {
+      this.active && this.land();
+      return;
+    }
+    if (!this.active) {
+      s >= this.nextAt && i.night < (this.options.maxNight ?? 0.5) && this.launch(s, e, i.wind);
+      return;
+    }
+    const n = t / 1e3;
+    this.x += this.vx * n, this.y += this.vy * n;
+    const [c, l] = this.options.frames;
+    for (let o = 0; o < this.active; o++) {
+      const h = this.birds[o], a = this.snap ? Math.round(this.x + h.dx) : this.x + h.dx, r = this.snap ? Math.round(this.y + h.dy) : this.y + h.dy;
+      h.img.setTexture(x(s, h.flap) ? l : c).setFlipX(this.vx < 0), h.img.setPosition(a, r), h.shadow?.setPosition(a + Math.round(this.altitude * 0.25), r + Math.round(this.altitude));
+    }
+    (this.x < e.x - 120 || this.x > e.right + 120 || this.y < e.y - 120 || this.y > e.bottom + 120) && this.land();
+  }
+  destroy() {
+    for (const s of this.birds)
+      s.img.destroy(), s.shadow?.destroy();
+    this.birds.length = 0, this.active = 0;
+  }
+  launch(s, t, e) {
+    const i = this.random, [d, n] = this.options.flock;
+    this.active = Math.min(this.birds.length, d + Math.floor(i() * (n - d + 1)));
+    const c = i() < 0.5 + e * 0.3, l = 34 + i() * 18 + e * 14;
+    this.x = c ? t.x - 30 : t.right + 30, this.y = t.y + t.height * (0.1 + i() * 0.7), this.vx = c ? l : -l, this.vy = (i() - 0.5) * l * 0.35, this.altitude = 46 + i() * 40;
+    for (let a = 0; a < this.active; a++) {
+      const r = this.birds[a], f = m(a, this.vx, i(), i());
+      r.dx = f.dx, r.dy = f.dy, r.img.setVisible(!0), r.shadow?.setVisible(!0);
+    }
+    const [o, h] = this.options.everyS;
+    this.nextAt = s + (o + i() * (h - o)) * 1e3;
+  }
+  land() {
+    for (const s of this.birds)
+      s.img.setVisible(!1), s.shadow?.setVisible(!1);
+    this.active = 0;
+  }
+}
+export {
+  b as Birds
+};

package/dist/ambient/life/Butterflies.js

@@ -0,0 +1,43 @@
+class g {
+  constructor(e, o) {
+    if (this.options = o, this.snap = o.snap ?? !0, this.random = o.random ?? Math.random, !!o.looks.length)
+      for (let s = 0; s < o.count; s++) {
+        const h = o.looks[s % o.looks.length], n = e.add.image(0, 0, h[0]).setOrigin(0.5, 1).setDepth(o.depth ?? 9e5).setVisible(!1);
+        this.flies.push({ img: n, look: h, homeX: 0, homeY: 0, x: 0, y: 0, tx: 0, ty: 0, retargetAt: 0, seed: this.random() * 1e3, home: !1 });
+      }
+  }
+  options;
+  flies = [];
+  snap;
+  random;
+  update(e, o, s, h, n = !0) {
+    const m = o / 1e3, i = this.random, a = n && h.night < (this.options.maxNight ?? 0.4);
+    for (const t of this.flies) {
+      const l = t.homeX < s.x - 40 || t.homeX > s.right + 40 || t.homeY < s.y - 40 || t.homeY > s.bottom + 40;
+      if (!a || t.home && l) {
+        t.home = !1, t.img.visible && t.img.setVisible(!1);
+        continue;
+      }
+      if (!t.home) {
+        if (i() > 0.02 || !this.settle(t, s)) continue;
+        t.img.setVisible(!0);
+      }
+      e >= t.retargetAt && (t.tx = t.homeX + (i() - 0.5) * 34 + h.wind * 6, t.ty = t.homeY - 4 - i() * 14, t.retargetAt = e + 500 + i() * 1400);
+      const r = Math.min(1, m * 2.4);
+      t.x += (t.tx - t.x) * r, t.y += (t.ty - t.y) * r;
+      const f = Math.floor((e + t.seed) / 90) % 3 !== 0, d = Math.sin((e + t.seed) / 160) > 0 ? 1 : 0;
+      t.img.setTexture(f ? t.look[0] : t.look[1]), t.img.setPosition(this.snap ? Math.round(t.x) : t.x, (this.snap ? Math.round(t.y) : t.y) - d);
+    }
+  }
+  destroy() {
+    for (const e of this.flies) e.img.destroy();
+    this.flies.length = 0;
+  }
+  settle(e, o) {
+    const s = this.options.home(o, this.random);
+    return s ? (e.homeX = s.x + (s.w ?? 0) / 2, e.homeY = s.y + (s.h ?? 0) / 2, e.x = e.tx = e.homeX + (this.random() - 0.5) * 16, e.y = e.ty = e.homeY - 6 - this.random() * 6, e.home = !0, !0) : !1;
+  }
+}
+export {
+  g as Butterflies
+};

package/dist/ambient/life/ChimneySmoke.js

@@ -0,0 +1,50 @@
+import { puffOffset as p } from "./lifeMotion.js";
+class b {
+  constructor(n, t) {
+    if (this.options = t, this.snap = t.snap ?? !0, this.random = t.random ?? Math.random, !t.frames.length) return;
+    const h = t.puffs ?? 7;
+    for (const r of t.mouths) {
+      const o = [];
+      for (let f = 0; f < h; f++) {
+        const m = n.add.image(0, 0, t.frames[0]).setOrigin(0.5, 1).setDepth(t.depth ?? 9e5).setVisible(!1);
+        o.push({ img: m, born: -1, seed: this.random() });
+      }
+      this.chimneys.push({ x: Math.round(r.x), y: Math.round(r.y), puffs: o, next: 0 });
+    }
+  }
+  options;
+  chimneys = [];
+  snap;
+  random;
+  update(n, t, h, r = !0) {
+    const o = this.options, f = o.puffEveryMs ?? 650, m = o.lifeMs ?? 4600, u = { rise: o.rise ?? 7, drift: o.drift ?? 9 }, a = o.frames;
+    for (const e of this.chimneys) {
+      if (!(r && e.x > t.x - 40 && e.x < t.right + 40 && e.y > t.y - 20 && e.y < t.bottom + 120)) {
+        for (const s of e.puffs)
+          s.born >= 0 && s.img.setVisible(!1), s.born = -1;
+        continue;
+      }
+      if (n >= e.next) {
+        const s = e.puffs.find((i) => i.born < 0);
+        s && (s.born = n, s.seed = this.random(), s.img.setVisible(!0)), e.next = n + f * (0.7 + this.random() * 0.6);
+      }
+      for (const s of e.puffs) {
+        if (s.born < 0) continue;
+        const i = (n - s.born) / m;
+        if (i >= 1) {
+          s.born = -1, s.img.setVisible(!1);
+          continue;
+        }
+        const { dx: c, dy: d } = p((n - s.born) / 1e3, i, s.seed, h.wind, u);
+        s.img.setTexture(a[Math.min(a.length - 1, Math.floor(i * a.length))]), s.img.setPosition(this.snap ? Math.round(e.x + c) : e.x + c, this.snap ? Math.round(e.y + d) : e.y + d);
+      }
+    }
+  }
+  destroy() {
+    for (const n of this.chimneys) for (const t of n.puffs) t.img.destroy();
+    this.chimneys.length = 0;
+  }
+}
+export {
+  b as ChimneySmoke
+};

package/dist/ambient/life/Drift.js

@@ -0,0 +1,75 @@
+class l {
+  constructor(t, e) {
+    if (this.options = e, this.kind = e.kind, this.snap = e.snap ?? !0, this.random = e.random ?? Math.random, !!e.looks.length)
+      for (let s = 0; s < e.count; s++) {
+        const n = e.looks[s % e.looks.length], i = t.add.image(0, 0, n[0]).setOrigin(0, 0).setDepth(e.depth ?? 9e5).setVisible(!1);
+        this.motes.push({ img: i, look: n, x: 0, y: 0, vx: 0, vy: 0, ground: 0, landedAt: -1, rising: !1, seed: this.random() * 1e3 });
+      }
+  }
+  options;
+  motes = [];
+  kind;
+  snap;
+  random;
+  /** `now` and `dt` in ms. */
+  update(t, e, s, n, i = !0) {
+    const d = e / 1e3;
+    for (let o = 0; o < this.motes.length; o++) {
+      const r = this.motes[o];
+      if (!i) {
+        r.img.visible && r.img.setVisible(!1), r.landedAt = -1;
+        continue;
+      }
+      const h = r.x < s.x - 40 || r.x > s.right + 40 || r.y < s.y - 60 || r.y > s.bottom + 30;
+      if (r.landedAt < 0 || h) {
+        if (this.random() > 0.08 || !this.spawn(r, s, n.wind, r.landedAt < 0 && this.random() < 0.5)) {
+          r.img.visible && r.img.setVisible(!1), r.landedAt = -1;
+          continue;
+        }
+        r.img.setVisible(!0);
+      }
+      this.step(r, t, d), r.img.setPosition(this.snap ? Math.round(r.x) : r.x, this.snap ? Math.round(r.y) : r.y);
+    }
+  }
+  destroy() {
+    for (const t of this.motes) t.img.destroy();
+    this.motes.length = 0;
+  }
+  /** `anywhere`: a first fill lands bodies all over the view, not only at its edge, so a scene opens already alive. */
+  spawn(t, e, s, n) {
+    const i = this.random;
+    t.landedAt = 0, t.rising = !1;
+    const d = this.options.from?.(e, i) ?? null;
+    return d ? this.spawnFrom(t, d, s) : this.options.sourceOnly ? !1 : (t.x = e.x - 20 + i() * (e.width + 30), this.kind === "ember" ? (t.y = n ? e.y + i() * e.height : e.bottom + 2, t.vx = s * 8 * i(), t.vy = -10 - i() * 12, t.ground = e.y + i() * e.height * 0.6) : this.kind === "mote" ? (t.y = e.y + i() * e.height, t.vx = (i() - 0.5) * 4, t.vy = (i() - 0.5) * 3, t.ground = 0) : (t.y = n ? e.y + i() * e.height : e.y - 6 - i() * 20, t.vx = 4 + s * 16 * (0.5 + i()), t.vy = 6 + i() * 8, t.ground = e.bottom + 10), !0);
+  }
+  spawnFrom(t, e, s) {
+    const n = this.random;
+    return t.x = e.x + n() * (e.w ?? 0), t.y = e.y + n() * (e.h ?? 0), this.kind === "ember" || this.kind === "ash" ? (t.rising = !0, t.vx = 2 + s * 10 * n(), this.kind === "ember" ? (t.vy = -10 - n() * 12, t.ground = t.y - 16 - n() * 30) : (t.vy = -3 - n() * 5, t.ground = t.y - 30 - n() * 40), !0) : (t.vx = 2 + s * 14 * (0.5 + n()), t.vy = 9 + n() * 7, t.ground = e.y + (e.h ?? 0) + 10 + n() * 22, !0);
+  }
+  step(t, e, s) {
+    const n = this.kind, i = t.look;
+    if (n === "leaf") {
+      if (t.landedAt > 0) {
+        e - t.landedAt > 1600 && (t.landedAt = -1);
+        return;
+      }
+      t.x += (t.vx + Math.sin(e / 260 + t.seed) * 10) * s, t.y += t.vy * s, t.img.setTexture(i[Math.floor(e / 140 + t.seed) % i.length]), t.y >= t.ground && (t.y = t.ground, t.landedAt = e, t.img.setTexture(i[0]));
+      return;
+    }
+    if (n === "ember") {
+      t.x += (t.vx + Math.sin(e / 300 + t.seed) * 4) * s, t.y += t.vy * s;
+      const o = t.y - t.ground, r = o < 0 ? 2 : o < 20 ? 1 : 0;
+      t.img.setTexture(i[Math.min(i.length - 1, r)]), o < -12 && (t.landedAt = -1);
+      return;
+    }
+    if (t.rising) {
+      t.x += (t.vx + Math.sin(e / 500 + t.seed) * 3) * s, t.y += t.vy * s, t.y < t.ground && (t.landedAt = -1);
+      return;
+    }
+    const d = n === "mote" ? 2 : 7;
+    t.x += (t.vx + Math.sin(e / 700 + t.seed) * d) * s, t.y += (t.vy + Math.cos(e / 900 + t.seed) * (n === "mote" ? 2 : 1)) * s, n !== "mote" && t.y > t.ground && (t.landedAt = -1), n === "mote" && this.random() < s / 9 && (t.landedAt = -1);
+  }
+}
+export {
+  l as Drift
+};

package/dist/ambient/life/Fireflies.js

@@ -0,0 +1,52 @@
+import { Sprite as y, Container as p } from "pixi.js";
+import { firefliesOut as x, fireflyOffset as g, fireflyGlow as b } from "./lifeMotion.js";
+class Y {
+  constructor(s, e) {
+    this.stage = s, this.options = e, this.dim = s.textures.get(e.frames[0]), this.lit = s.textures.get(e.frames[1]), this.onScreen = (e.layer ?? "screen") === "screen", this.snap = e.snap ?? !0, this.random = e.random ?? Math.random, this.onScreen ? (s.screen.addChild(this.layer), s.cameras.main.follow(this.layer)) : (this.layer.zIndex = e.depth ?? 9e5, s.world.addChild(this.layer)), this.layer.visible = !1;
+    for (let i = 0; i < e.count; i++) {
+      const r = new y(this.dim);
+      r.anchor.set(0.5), r.visible = !1, this.layer.addChild(r), this.flies.push({ sprite: r, homeX: 0, homeY: 0, seed: this.random() * 1e4, home: !1 });
+    }
+  }
+  stage;
+  options;
+  layer = new p();
+  flies = [];
+  dim;
+  lit;
+  onScreen;
+  snap;
+  random;
+  update(s, e, i, r = !0) {
+    if (!this.flies.length) return;
+    const n = !r || i.night < 0.5;
+    if (this.layer.visible = !n, n) {
+      for (const h of this.flies) h.home = !1;
+      return;
+    }
+    const m = x(this.flies.length, i.night);
+    for (let h = 0; h < this.flies.length; h++) {
+      const t = this.flies[h], d = t.homeX < e.x - 30 || t.homeX > e.right + 30 || t.homeY < e.y - 30 || t.homeY > e.bottom + 30;
+      if (h >= m || t.home && d) {
+        t.home = !1, t.sprite.visible = !1;
+        continue;
+      }
+      if (!t.home && (this.random() > 0.05 || !this.settle(t, e))) continue;
+      const l = (s + t.seed) / 1e3, o = b(l);
+      if (t.sprite.visible = o > 0, !o) continue;
+      t.sprite.texture = o === 2 ? this.lit : this.dim;
+      const { dx: c, dy: u } = g(l), a = t.homeX + c, f = t.homeY + u;
+      t.sprite.position.set(this.snap ? Math.round(a) : a, this.snap ? Math.round(f) : f);
+    }
+  }
+  destroy() {
+    this.onScreen && this.stage.cameras.main.unfollow(this.layer), this.layer.destroy({ children: !0 }), this.flies.length = 0;
+  }
+  settle(s, e) {
+    const i = this.options.home(e, this.random);
+    return i ? (s.homeX = i.x + (i.w ?? 0) / 2 + (this.random() - 0.5) * 24, s.homeY = i.y + (i.h ?? 0) / 2 - 4 - this.random() * 16, s.home = !0, !0) : !1;
+  }
+}
+export {
+  Y as Fireflies
+};

package/dist/ambient/life/lifeMotion.js

@@ -0,0 +1,49 @@
+function i(t, n, r = 0) {
+  return t.x + (t.w ?? 0) >= n.x - r && t.x <= n.right + r && t.y + (t.h ?? 0) >= n.y - r && t.y <= n.bottom + r;
+}
+function e(t, n, r, f = 8) {
+  if (!t.length) return null;
+  for (let o = 0; o < f; o++) {
+    const u = t[Math.floor(r() * t.length)];
+    if (i(u, n)) return u;
+  }
+  return null;
+}
+function c(t, n = 8) {
+  return (r, f) => e(t, r, f, n);
+}
+function l(t, n, r = 110) {
+  const f = Math.floor((t + n) / r) % 8;
+  return f < 5 ? f % 2 : 0;
+}
+function h(t, n, r, f) {
+  const o = Math.ceil(t / 2), u = t % 2 ? 1 : -1;
+  return { dx: -Math.sign(n) * o * (6 + r * 3), dy: u * o * (4 + f * 2) };
+}
+function s(t) {
+  const n = (t * 0.45 % 1 + 1) % 1;
+  return n < 0.18 ? 2 : n < 0.26 || n > 0.94 ? 1 : 0;
+}
+function M(t) {
+  return { dx: Math.sin(t * 0.7) * 9 + Math.sin(t * 1.9) * 3, dy: Math.cos(t * 0.5) * 5 };
+}
+function a(t, n) {
+  return n < 0.5 ? 0 : Math.round(t * Math.min(1, (n - 0.5) / 0.35));
+}
+function d(t, n, r, f, o) {
+  return {
+    dx: (r - 0.5) * 2 + o.drift * (0.25 + f) * t * n * 2 + Math.sin(t * 1.3 + r * 6) * 1.2,
+    dy: -o.rise * t * (1 - n * 0.25)
+  };
+}
+export {
+  l as birdFrame,
+  i as boxInView,
+  a as firefliesOut,
+  s as fireflyGlow,
+  M as fireflyOffset,
+  h as flockSlot,
+  e as pickInView,
+  d as puffOffset,
+  c as sourceOf
+};