1681-engine 0.5.10 → 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/audio/spatial.js

@@ -0,0 +1,118 @@
+const l = [18e3, 1800];
+function f(c, t, e = {}) {
+  const i = e.range ?? 480, s = t.x - c.x, n = Math.hypot(s, t.y - c.y), r = e.maxPan ?? 0.8, h = Math.max(-r, Math.min(r, s / (e.panWidth ?? i / 2))), o = e.muffle === void 0 ? l : e.muffle, a = Math.min(1, n / i), u = o ? o[0] * Math.pow(o[1] / o[0], a) : 2e4;
+  return n >= i ? { audible: !1, gain: 0, pan: h, cutoffHz: u } : { audible: !0, gain: Math.pow(1 - a, e.rolloff ?? 1.5), pan: h, cutoffHz: u };
+}
+const m = 0.05;
+class d {
+  constructor(t, e = t.destination) {
+    this.context = t, this.output = t.createGain(), this.output.connect(e);
+  }
+  context;
+  /** Every emitter's gain goes through this: the game's volume setting. */
+  output;
+  emitters = /* @__PURE__ */ new Set();
+  here = { x: 0, y: 0 };
+  /** The listener's place as of the last `update`. */
+  get listener() {
+    return this.here;
+  }
+  /** How many emitters are alive (playing or waiting out of range). */
+  get size() {
+    return this.emitters.size;
+  }
+  /** A sound at (x, y), looping by default. Starts at once when in range of the listener. */
+  emitter(t, e, i, s = {}) {
+    const n = new p(this, t, e, i, s);
+    return this.emitters.add(n), n.refresh(this.here, !1), n;
+  }
+  /** A one-shot at (x, y), dropped when it ends; skipped (and done at once) when out of range. */
+  play(t, e, i, s = {}) {
+    return this.emitter(t, e, i, { ...s, loop: !1 });
+  }
+  /** Moves the listener and re-mixes every emitter. Call once a frame. */
+  update(t = this.here) {
+    this.here = { x: t.x, y: t.y };
+    for (const e of this.emitters) e.refresh(this.here, !0);
+  }
+  /** Stops every emitter. */
+  stopAll(t = 0) {
+    for (const e of [...this.emitters]) e.stop(t);
+  }
+  destroy() {
+    this.stopAll(), this.output.disconnect();
+  }
+  /** @internal */
+  forget(t) {
+    this.emitters.delete(t);
+  }
+}
+class p {
+  constructor(t, e, i, s, n) {
+    this.owner = t, this.buffer = e, this.x = i, this.y = s, this.options = n;
+    const r = t.context;
+    this.volume = n.volume ?? 1, this.rate = n.playbackRate ?? 1, this.origin = r.currentTime, this.filter = r.createBiquadFilter(), this.filter.type = "lowpass", this.gain = r.createGain(), this.panner = r.createStereoPanner(), this.filter.connect(this.gain).connect(this.panner).connect(t.output);
+  }
+  owner;
+  buffer;
+  x;
+  y;
+  options;
+  volume;
+  done = !1;
+  source = null;
+  gain;
+  panner;
+  filter;
+  /** When the loop would have begun, had it never stopped: where a restart picks it up. */
+  origin;
+  rate;
+  get playing() {
+    return this.source !== null;
+  }
+  refresh(t, e) {
+    if (this.done) return;
+    const i = f(t, this, this.options), s = this.options.loop ?? !0;
+    if (!i.audible) {
+      if (!s) return this.stop();
+      this.halt();
+      return;
+    }
+    const n = this.owner.context, r = n.currentTime, h = (o, a) => e && this.source ? o.setTargetAtTime(a, r, m) : o.setValueAtTime(a, r);
+    h(this.gain.gain, i.gain * Math.max(0, Math.min(1, this.volume))), h(this.panner.pan, i.pan), h(this.filter.frequency, Math.min(i.cutoffHz, n.sampleRate / 2)), this.source || this.begin(s);
+  }
+  stop(t = 0) {
+    if (this.done) return;
+    this.done = !0, this.owner.forget(this);
+    const e = this.source, i = this.owner.context;
+    if (e && t > 0) {
+      const s = i.currentTime + t / 1e3;
+      this.gain.gain.setValueAtTime(this.gain.gain.value, i.currentTime), this.gain.gain.linearRampToValueAtTime(0, s), e.stop(s), e.onended = () => this.release();
+    } else
+      this.halt(), this.release();
+  }
+  begin(t) {
+    const e = this.owner.context, i = e.createBufferSource();
+    i.buffer = this.buffer, i.loop = t, i.playbackRate.value = this.rate, i.connect(this.filter);
+    const s = t ? (e.currentTime - this.origin) * this.rate % this.buffer.duration : 0;
+    i.start(e.currentTime, s), t || (i.onended = () => this.stop()), this.source = i;
+  }
+  halt() {
+    const t = this.source;
+    if (t) {
+      this.source = null, t.onended = null;
+      try {
+        t.stop();
+      } catch {
+      }
+      t.disconnect();
+    }
+  }
+  release() {
+    this.filter.disconnect(), this.gain.disconnect(), this.panner.disconnect();
+  }
+}
+export {
+  d as SpatialAudio,
+  f as spatialMix
+};

package/dist/cjs/electron/webPatcher.d.ts

@@ -47,6 +47,7 @@ export declare class WebPatcher {
     private loaded;
     /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
     private tidying;
+    private tidyChain;
     constructor(options: WebPatcherOptions);
     /** This shell's identity. */
     get shell(): string;
@@ -75,6 +76,8 @@ export declare class WebPatcher {
     private promote;
     /** A pointer this shell may load: its own shell, newer than the installed build, its folder whole. */
     private usable;
-    /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
+    /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+     * one is running waits for it and then runs once more, so two never delete the same folder at once. */
     tidy(): Promise<void>;
+    private tidyOnce;
 }

package/dist/cjs/electron/webPatcher.js

@@ -27,6 +27,7 @@ class WebPatcher {
     loaded = null;
     /** The tidy a start began: a build waits for it, or it could delete the `.part` folder being filled. */
     tidying = Promise.resolve();
+    tidyChain = Promise.resolve();
     constructor(options) {
         this.options = options;
         this.o = {
@@ -197,8 +198,14 @@ class WebPatcher {
     usable(p) {
         return !!p && p.shell === this.shell && (0, manifest_1.isNewer)(p.version, this.o.appVersion) && (0, node_fs_1.existsSync)((0, node_path_1.join)(this.o.root, p.version, this.o.entry));
     }
-    /** Removes every patched web but the active, pending and previous one, and any half-made folder. */
-    async tidy() {
+    /** Removes every patched web but the active, pending and previous one, and any half-made folder. A call made while
+     * one is running waits for it and then runs once more, so two never delete the same folder at once. */
+    tidy() {
+        const next = this.tidyChain.then(() => this.tidyOnce());
+        this.tidyChain = next;
+        return next;
+    }
+    async tidyOnce() {
         try {
             const names = ['active', 'pending', 'previous'];
             const keep = new Set([...names.map((n) => this.pointers.read(n)?.version), this.loaded?.version].filter((v) => !!v));

package/dist/dialogue/DialogueRunner.js

@@ -0,0 +1,173 @@
+import { expr as u } from "./expr.js";
+const f = 1e3;
+class d {
+  constructor(t, s = {}) {
+    this.script = t, this.options = s, this.vars = s.vars ?? {};
+    const i = s.functions ?? {};
+    this.scope = {
+      get: (e) => l(this.vars, e),
+      call: (e, n) => {
+        if (e === "visited") return this.visits.get(String(n[0])) ?? 0;
+        if (e === "chose") return this.chosen.has(`${n[0]}#${n[1]}`);
+        const o = i[e];
+        if (!o) throw new Error(`dialogue: no function '${e}'`);
+        return o(...n);
+      }
+    };
+  }
+  script;
+  options;
+  vars;
+  node = null;
+  line = 0;
+  step = { type: "end" };
+  visits = /* @__PURE__ */ new Map();
+  chosen = /* @__PURE__ */ new Set();
+  scope;
+  /** The step showing now. */
+  get current() {
+    return this.step;
+  }
+  /** The node the dialogue is in, or null once it has ended. */
+  get at() {
+    return this.node;
+  }
+  /** How many times a node was entered. */
+  visited(t) {
+    return this.visits.get(t) ?? 0;
+  }
+  /** Begins at `node` (default the script's `start`, else its first node). */
+  start(t = this.script.start ?? Object.keys(this.script.nodes)[0]) {
+    return t === void 0 ? this.finish() : this.go(t);
+  }
+  /** The line showing was read: on to the next line, the choices, or wherever the node leads. */
+  next() {
+    return this.step.type !== "line" ? this.step : (this.line++, this.show(0));
+  }
+  /** Picks a choice by its `index` (as shown). A locked or unknown index changes nothing. */
+  choose(t) {
+    if (this.step.type !== "choices" || this.node === null) return this.step;
+    if (!this.step.choices.find((n) => n.index === t)?.enabled) return this.step;
+    const i = this.node, e = this.nodeOf(i).choices[t];
+    return this.chosen.add(`${i}#${t}`), this.assign(e.set), this.run(e.do), e.goto === void 0 ? this.finish() : this.go(e.goto);
+  }
+  /** Jumps to a node from outside (the game's own event broke in). */
+  jump(t) {
+    return this.go(t);
+  }
+  /** Ends the dialogue now. */
+  stop() {
+    return this.finish();
+  }
+  /** The value of an expression over this dialogue's variables, for a game that shares the language. */
+  evaluate(t) {
+    return u(t)(this.scope);
+  }
+  save() {
+    return {
+      node: this.node,
+      line: this.line,
+      vars: structuredClone(this.vars),
+      visits: Object.fromEntries(this.visits),
+      chosen: [...this.chosen]
+    };
+  }
+  /** Puts a saved dialogue back where it was, without running the node's `set` and `do` again. */
+  restore(t) {
+    for (const s of Object.keys(this.vars)) delete this.vars[s];
+    Object.assign(this.vars, structuredClone(t.vars)), this.visits.clear();
+    for (const [s, i] of Object.entries(t.visits)) this.visits.set(s, i);
+    this.chosen.clear();
+    for (const s of t.chosen) this.chosen.add(s);
+    return t.node === null || !this.script.nodes[t.node] ? this.finish() : (this.node = t.node, this.line = t.line, this.show(0));
+  }
+  go(t) {
+    return this.enter(t, 0);
+  }
+  enter(t, s) {
+    if (s > f) throw new Error(`dialogue: '${t}' loops without showing anything`);
+    const i = this.nodeOf(t);
+    return this.node = t, this.line = 0, this.visits.set(t, (this.visits.get(t) ?? 0) + 1), this.assign(i.set), this.run(i.do), this.node !== t ? this.step : this.show(s);
+  }
+  /** The step from the current line on: the next line that holds, else the choices, else the way on. */
+  show(t) {
+    const s = this.node, i = this.nodeOf(s), e = i.lines ?? [];
+    for (; this.line < e.length; this.line++) {
+      const r = e[this.line], h = typeof r == "string" ? { text: r } : r;
+      if (!(h.if !== void 0 && !this.test(h.if)))
+        return this.step = { type: "line", node: s, speaker: h.speaker, text: this.text(h.text, h.key), tags: h.tags ?? [] };
+    }
+    const n = this.offered(s, i);
+    if (n.length > 0) return this.step = { type: "choices", node: s, choices: n };
+    const o = this.wayOn(i);
+    return o === null ? this.finish() : this.enter(o, t + 1);
+  }
+  offered(t, s) {
+    const i = [];
+    return (s.choices ?? []).forEach((e, n) => {
+      if (e.once && this.chosen.has(`${t}#${n}`)) return;
+      const o = e.if === void 0 || this.test(e.if);
+      !o && !e.showLocked || i.push({ index: n, text: this.text(e.text, e.key), enabled: o });
+    }), i.some((e) => e.enabled) ? i : [];
+  }
+  wayOn(t) {
+    if (t.next === void 0) return null;
+    if (typeof t.next == "string") return t.next;
+    for (const s of t.next) if (s.if === void 0 || this.test(s.if)) return s.goto;
+    return null;
+  }
+  finish() {
+    return this.node = null, this.step = { type: "end" };
+  }
+  nodeOf(t) {
+    const s = this.script.nodes[t];
+    if (!s) throw new Error(`dialogue: no node '${t}'`);
+    return s;
+  }
+  test(t) {
+    return !!u(t)(this.scope);
+  }
+  assign(t) {
+    if (!t) return;
+    const s = Object.entries(t).map(([i, e]) => [i, u(e)(this.scope)]);
+    for (const [i, e] of s) p(this.vars, i, e);
+  }
+  run(t) {
+    for (const s of t ?? []) {
+      const i = typeof s == "string" ? s : s.name;
+      this.options.onCommand?.(i, typeof s == "string" ? [] : s.args ?? [], this);
+    }
+  }
+  /** `text` translated, with each `{expression}` replaced by its value; `{{` and `}}` are braces. */
+  text(t, s) {
+    return (this.options.translate ? this.options.translate(t, s) : t).replace(/\{\{|\}\}|\{([^{}]+)\}/g, (e, n) => {
+      if (e === "{{") return "{";
+      if (e === "}}") return "}";
+      const o = u(n.trim())(this.scope);
+      return o == null ? "" : String(o);
+    });
+  }
+}
+function l(c, t) {
+  let s = c;
+  for (const i of t.split(".")) {
+    if (s === null || typeof s != "object" || !Object.prototype.hasOwnProperty.call(s, i)) return;
+    s = s[i];
+  }
+  return s;
+}
+function p(c, t, s) {
+  const i = t.split(".");
+  let e = c;
+  for (const o of i.slice(0, -1)) {
+    if (o === "__proto__" || o === "constructor" || o === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+    const r = e[o];
+    e = r !== null && typeof r == "object" ? r : e[o] = {};
+  }
+  const n = i[i.length - 1];
+  if (n === "__proto__" || n === "constructor" || n === "prototype") throw new Error(`dialogue: cannot set '${t}'`);
+  e[n] = s;
+}
+export {
+  d as DialogueRunner
+};