1681-engine 0.5.10 → 0.6.0

package/dist/net/Room.js

@@ -1,21 +1,38 @@
-import { createMover as l, stepMover as p } from "./movement.js";
-import { moverToWire as c } from "./protocol.js";
-class g {
+import { LagCompensator as f } from "./LagCompensator.js";
+import { createMover as m, stepMover as p } from "./movement.js";
+import { moverToWire as y } from "./protocol.js";
+import { SpatialHash as b } from "./SpatialHash.js";
+const g = 1 << 24;
+class M {
   constructor(e) {
     this.options = e, this.maxQueue = e.maxQueue ?? 30, this.maxSteps = e.maxStepsPerTick ?? 3, this.backlog = e.backlog ?? 4;
+    const i = e.interest;
+    if (i && !(i.radius > 0)) throw new Error(`Room: interest.radius must be above 0 (got ${i.radius})`);
+    this.hash = i ? new b(i.radius) : null, this.rewindMs = Math.max(0, e.rewindMs ?? 0), this.history = this.rewindMs > 0 ? new f(this.rewindMs + 200) : null;
   }
   options;
   players = /* @__PURE__ */ new Map();
+  /** The bodies the server moves (`addBody`). */
+  bodies = /* @__PURE__ */ new Map();
   tick = 0;
+  /** Past positions for judging shots against what a client saw, when the room was made with `rewindMs`. */
+  history;
+  /** How far back a client's claimed view time is honoured (`rewindMs`, 0 when off). */
+  rewindMs;
   known = /* @__PURE__ */ new Map();
+  hash;
+  nearby = [];
   maxQueue;
   maxSteps;
   backlog;
+  nextBodyId = g;
   join(e, i) {
     if (this.players.has(e)) throw new Error(`Room: player ${e} has already joined`);
-    const r = this.options.spawn(e, i), t = {
+    if (this.bodies.has(e)) throw new Error(`Room: id ${e} is a body's`);
+    const t = this.options.spawn(e, i), s = {
+      kind: "player",
       id: e,
-      mover: l(r.x, r.y),
+      mover: m(t.x, t.y),
       data: i,
       params: { ...this.options.params },
       ack: -1,
@@ -26,66 +43,128 @@ class g {
       flags: 0,
       strikes: 0
     };
-    return this.players.set(e, t), this.known.set(e, /* @__PURE__ */ new Set()), t;
+    return this.players.set(e, s), this.known.set(e, /* @__PURE__ */ new Set()), this.hash?.set(e, t.x, t.y), s;
   }
   leave(e) {
-    this.players.delete(e), this.known.delete(e);
+    this.players.delete(e), this.known.delete(e), this.hash?.delete(e), this.history?.forget(e);
+  }
+  /**
+   * Records where every body is now, at server time `time`, into `history`; `RoomHost` calls it as each round of
+   * snapshots goes out, so the history holds exactly the positions clients interpolate between.
+   */
+  record(e) {
+    if (!this.history) return;
+    const i = [...this.players.values()].map((t) => ({ id: t.id, x: t.mover.x, y: t.mover.y }));
+    for (const t of this.bodies.values()) i.push({ id: t.id, x: t.x, y: t.y });
+    this.history.record(e, i);
+  }
+  /**
+   * Adds a body the server moves, at (x, y), with the game's `data` (what players are told it looks like). Its id
+   * is `id`, or the next from `BODY_ID_BASE` up; an id a player or body has is refused.
+   */
+  addBody(e, i, t, s) {
+    let o = s;
+    if (o === void 0) {
+      for (; this.bodies.has(this.nextBodyId) || this.players.has(this.nextBodyId); ) this.nextBodyId++;
+      o = this.nextBodyId++;
+    } else if (this.bodies.has(o) || this.players.has(o)) throw new Error(`Room: id ${o} is taken`);
+    if (!Number.isInteger(o) || o < 0 || o > 2147483647) throw new Error(`Room: a body id must fit an i32 (got ${o})`);
+    const a = { kind: "body", id: o, x: i, y: t, aim: 0, anim: 0, hp: 0, flags: 0, data: e };
+    return this.bodies.set(o, a), this.hash?.set(o, i, t), a;
+  }
+  /** Takes a body out: players who saw it get it in `rm` with their next snapshot. */
+  removeBody(e) {
+    this.bodies.delete(e) && (this.hash?.delete(e), this.history?.forget(e));
   }
   /**
    * Input steps `seq`, `seq + 1`, … from a player. Steps already received are skipped (a resend), any step with
    * numbers no client sends refuses the whole message, and steps past a full queue are dropped. Returns false when
    * something was refused.
    */
-  input(e, i, r) {
-    const t = this.players.get(e);
-    if (!t) return !1;
-    if (!Number.isInteger(i) || i < 0 || !Array.isArray(r) || r.length > this.maxQueue)
-      return t.strikes++, !1;
-    for (const s of r)
-      if (!Array.isArray(s) || s.length !== 3 || !s.every((u) => Number.isFinite(u)) || Math.abs(s[0]) > 1 || Math.abs(s[1]) > 1 || !Number.isInteger(s[2]))
-        return t.strikes++, !1;
-    const n = t.ack + 1 + t.queue.length, o = i - n;
-    if (o > this.maxQueue)
-      return t.strikes++, !1;
-    for (let s = 0; s < o; s++) t.queue.push([0, 0, 0]);
-    let h = !0;
-    for (let s = 0; s < r.length; s++)
-      if (!(i + s < n)) {
-        if (t.queue.length >= this.maxQueue) {
-          h = !1, t.strikes++;
+  input(e, i, t) {
+    const s = this.players.get(e);
+    if (!s) return !1;
+    if (!Number.isInteger(i) || i < 0 || !Array.isArray(t) || t.length > this.maxQueue)
+      return s.strikes++, !1;
+    for (const r of t)
+      if (!Array.isArray(r) || r.length !== 3 || !r.every((h) => Number.isFinite(h)) || Math.abs(r[0]) > 1 || Math.abs(r[1]) > 1 || !Number.isInteger(r[2]))
+        return s.strikes++, !1;
+    const o = s.ack + 1 + s.queue.length, a = i - o;
+    if (a > this.maxQueue)
+      return s.strikes++, !1;
+    for (let r = 0; r < a; r++) s.queue.push([0, 0, 0]);
+    let u = !0;
+    for (let r = 0; r < t.length; r++)
+      if (!(i + r < o)) {
+        if (s.queue.length >= this.maxQueue) {
+          u = !1, s.strikes++;
           break;
         }
-        t.queue.push([r[s][0], r[s][1], r[s][2]]);
+        s.queue.push([t[r][0], t[r][1], t[r][2]]);
       }
-    return h;
+    return u;
   }
   /** One simulation step for everyone. */
   step() {
     this.tick++;
     for (const e of this.players.values()) {
-      const i = e.queue.length;
-      if (i === 0) continue;
-      const r = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : 1;
-      for (let t = 0; t < r; t++) {
-        const n = e.queue.shift();
-        p(e.mover, n, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, n);
+      const i = e.queue.length, t = i > this.backlog ? Math.min(this.maxSteps, i - this.backlog + 1) : Math.min(1, i);
+      for (let s = 0; s < t; s++) {
+        const o = e.queue.shift();
+        p(e.mover, o, e.params, this.options.grid), e.ack++, this.options.onStep?.(e, o);
       }
+      this.hash?.set(e.id, e.mover.x, e.mover.y);
     }
+    if (this.hash) for (const e of this.bodies.values()) this.hash.set(e.id, e.x, e.y);
+  }
+  /**
+   * Moves a player by hand (a teleport, a respawn), and files it in the interest grid at once. Writing `mover.x/y`
+   * directly also works; the room then finds it at its new place from the next step.
+   */
+  place(e, i, t) {
+    const s = this.players.get(e), o = this.bodies.get(e);
+    if (s)
+      s.mover.x = i, s.mover.y = t;
+    else if (o)
+      o.x = i, o.y = t;
+    else return;
+    this.hash?.set(e, i, t);
   }
   /** The snapshot player `id` should get now. `time` is the server's wall clock (ms). */
   snapshotFor(e, i) {
-    const r = this.players.get(e), t = this.known.get(e);
-    if (!r || !t) return null;
-    const n = [], o = [], h = /* @__PURE__ */ new Set();
-    for (const a of this.players.values())
-      h.add(a.id), n.push([a.id, a.mover.x, a.mover.y, a.aim, a.anim, a.hp, a.flags]), t.has(a.id) || (t.add(a.id), o.push({ id: a.id, data: a.data }));
-    const s = [];
-    for (const a of t)
-      h.has(a) || (t.delete(a), s.push(a));
-    const u = { t: "snap", tick: this.tick, time: i, ack: r.ack, me: c(r.mover), up: n };
-    return o.length && (u.sp = o), s.length && (u.rm = s), u;
+    const t = this.players.get(e), s = this.known.get(e);
+    if (!t || !s) return null;
+    const o = [], a = [], u = /* @__PURE__ */ new Set();
+    for (const n of this.visibleTo(t, s)) {
+      u.add(n.id);
+      const c = d(n);
+      o.push([n.id, c.x, c.y, n.aim, n.anim, n.hp, n.flags]), s.has(n.id) || (s.add(n.id), a.push({ id: n.id, data: n.data }));
+    }
+    const r = [];
+    for (const n of s)
+      u.has(n) || (s.delete(n), r.push(n));
+    const h = { t: "snap", tick: this.tick, time: i, ack: t.ack, me: y(t.mover), up: o };
+    return a.length && (h.sp = a), r.length && (h.rm = r), h;
+  }
+  /** What `me` is sent: itself always; with interest, the rest in range (a known one until past the margin). */
+  visibleTo(e, i) {
+    const t = this.options.interest;
+    if (!t || !this.hash) return [...this.players.values(), ...this.bodies.values()];
+    const s = t.radius, o = s + (t.leaveMargin ?? s / 4), a = this.nearby;
+    a.length = 0, this.hash.near(e.mover.x, e.mover.y, o, a);
+    const u = [e];
+    for (const r of a) {
+      if (r === e.id) continue;
+      const h = this.players.get(r) ?? this.bodies.get(r);
+      if (!h) continue;
+      const n = d(h);
+      (n.x - e.mover.x) ** 2 + (n.y - e.mover.y) ** 2 > s * s && !i.has(r) || t.canSee && !t.canSee(e, h) || u.push(h);
+    }
+    return u.sort((r, h) => r.id - h.id);
   }
 }
+const d = (l) => l.kind === "player" ? l.mover : l;
 export {
-  g as Room
+  g as BODY_ID_BASE,
+  M as Room
 };

package/dist/net/RoomHost.js

@@ -1,5 +1,6 @@
-import { encodeSnapshotFrame as n } from "./snapshotCodec.js";
-class p {
+import { LagCompensator as n } from "./LagCompensator.js";
+import { encodeSnapshotFrame as r } from "./snapshotCodec.js";
+class c {
   constructor(t, s = {}) {
     this.room = t, this.options = s, this.stepMs = 1e3 / (s.stepRate ?? 60), this.snapEvery = Math.max(1, Math.round((s.stepRate ?? 60) / (s.snapRate ?? 20))), this.now = s.now ?? Date.now;
   }
@@ -64,7 +65,7 @@ class p {
   /** Sends one of the game's own messages to a player. */
   sendTo(t, s) {
     const e = this.sockets.get(t);
-    e && (s.t === "snap" && s.up?.length ? e.send(n(s)) : e.send(JSON.stringify(s)));
+    e && (s.t === "snap" && s.up?.length ? e.send(r(s)) : e.send(JSON.stringify(s)));
   }
   /** Starts stepping on a timer. Steps are counted by the clock, so a late timer runs the steps it owes. */
   start() {
@@ -81,11 +82,19 @@ class p {
   stepOnce() {
     if (this.room.step(), this.room.tick % this.snapEvery !== 0) return;
     const t = this.now();
+    this.room.record(t);
     for (const s of this.joined) {
       const e = this.room.snapshotFor(s, t);
       e && this.sendTo(s, e);
     }
   }
+  /**
+   * The server time a client's claimed view time (`InterpolationBuffer.viewTime`, sent with a shot) is judged at:
+   * kept within the room's `rewindMs` of now, so no claim reaches further back. `now` with no history kept.
+   */
+  rewindTime(t) {
+    return n.clampTime(t, this.now(), this.room.rewindMs);
+  }
   strike(t) {
     const s = this.room.players.get(t);
     s && (s.strikes++, this.checkStrikes(t));
@@ -96,5 +105,5 @@ class p {
   }
 }
 export {
-  p as RoomHost
+  c as RoomHost
 };

package/dist/net/SpatialHash.js

@@ -0,0 +1,66 @@
+const z = (a, t) => (a + 32768) * 65536 + (t + 32768);
+class M {
+  /** `cellSize`: world px per cell. About the radius queries ask for keeps a query to a 3×3 block. */
+  constructor(t) {
+    if (this.cellSize = t, !(t > 0)) throw new Error(`SpatialHash: cellSize must be above 0 (got ${t})`);
+  }
+  cellSize;
+  cells = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.entries.size;
+  }
+  has(t) {
+    return this.entries.has(t);
+  }
+  /** Puts `id` at (x, y), or moves it there. */
+  set(t, s, e) {
+    const l = z(Math.floor(s / this.cellSize), Math.floor(e / this.cellSize)), i = this.entries.get(t);
+    if (i) {
+      if (i.x = s, i.y = e, i.cell === l) return;
+      this.unlink(t, i.cell), i.cell = l;
+    } else this.entries.set(t, { x: s, y: e, cell: l });
+    let n = this.cells.get(l);
+    n || this.cells.set(l, n = /* @__PURE__ */ new Set()), n.add(t);
+  }
+  delete(t) {
+    const s = this.entries.get(t);
+    s && (this.unlink(t, s.cell), this.entries.delete(t));
+  }
+  clear() {
+    this.cells.clear(), this.entries.clear();
+  }
+  /** The ids within `radius` of (x, y), edge included, pushed onto `out` in no set order. */
+  near(t, s, e, l = []) {
+    const i = e * e;
+    return this.visit(t - e, s - e, t + e, s + e, (n, c) => {
+      const r = c.x - t, o = c.y - s;
+      r * r + o * o <= i && l.push(n);
+    }), l;
+  }
+  /** The ids inside the box from (x0, y0) to (x1, y1), edges included. */
+  inRect(t, s, e, l, i = []) {
+    return this.visit(t, s, e, l, (n, c) => {
+      c.x >= t && c.x <= e && c.y >= s && c.y <= l && i.push(n);
+    }), i;
+  }
+  visit(t, s, e, l, i) {
+    const n = this.cellSize, c = Math.floor(t / n), r = Math.floor(s / n), o = Math.floor(e / n), S = Math.floor(l / n);
+    if ((o - c + 1) * (S - r + 1) > this.entries.size) {
+      for (const [h, f] of this.entries) i(h, f);
+      return;
+    }
+    for (let h = r; h <= S; h++)
+      for (let f = c; f <= o; f++) {
+        const g = this.cells.get(z(f, h));
+        if (g) for (const u of g) i(u, this.entries.get(u));
+      }
+  }
+  unlink(t, s) {
+    const e = this.cells.get(s);
+    e && (e.delete(t), e.size === 0 && this.cells.delete(s));
+  }
+}
+export {
+  M as SpatialHash
+};

package/dist/types/ai/behaviorTree.d.ts

@@ -0,0 +1,133 @@
+/** What a node answers each tick: done well, done badly, or not done yet. */
+export type BtStatus = 'success' | 'failure' | 'running';
+/**
+ * One node of a tree. Nodes hold no state of their own, so one tree drives any number of agents: what a node must
+ * remember between ticks (the child a sequence is on, when a wait began) lives in the agent's memory, `run.state`.
+ */
+export interface BtNode<C> {
+    readonly kind: string;
+    /** Shown in a trace; actions and conditions are named after what they do. */
+    readonly name?: string;
+    readonly children: readonly BtNode<C>[];
+    tick(ctx: C, run: BtRun<C>): BtStatus;
+    /** A running node left behind (its parent moved on, the tree was reset): undo what it started. */
+    halt?(ctx: C, run: BtRun<C>): void;
+}
+/** What a node may use while it ticks: the agent's clock and memory, and its children's ticks. */
+export interface BtRun<C> {
+    /** The time this tick was given (ms), for waits, cooldowns and timeouts. */
+    readonly now: number;
+    /** This node's memory for this agent, made by `init` the first time and after a halt. */
+    state<T>(node: BtNode<C>, init: () => T): T;
+    /** Memory that outlives the node finishing (a cooldown's ready time); only `reset` clears it. */
+    lasting<T>(node: BtNode<C>, init: () => T): T;
+    /** Ticks a child; use this, never `child.tick`, so it is traced and halted right. */
+    tick(child: BtNode<C>, ctx: C): BtStatus;
+    /** Stops a child that was left running, and everything under it. */
+    halt(child: BtNode<C>, ctx: C): void;
+}
+/** One line of `BtAgent.trace`: a node, how deep it is, and what it last answered (null: not ticked this time). */
+export interface BtTraceLine {
+    depth: number;
+    kind: string;
+    name: string | undefined;
+    status: BtStatus | null;
+}
+/** A tree's root, and the agents it drives. */
+export declare class BehaviorTree<C> {
+    readonly root: BtNode<C>;
+    constructor(root: BtNode<C>);
+    /** A new agent on this tree, with memory of its own. */
+    agent(): BtAgent<C>;
+}
+/** One agent running a tree: its memory, and the tick that drives it. */
+export declare class BtAgent<C> implements BtRun<C> {
+    readonly root: BtNode<C>;
+    now: number;
+    private memory;
+    private readonly kept;
+    /** Nodes that answered 'running' last time they ticked: the ones a halt must reach. */
+    private readonly open;
+    private last;
+    private seen;
+    constructor(root: BtNode<C>);
+    /** Ticks the tree once at time `now` (ms) and returns the root's answer. */
+    update(ctx: C, now: number): BtStatus;
+    /** Halts whatever is running and forgets all memory: the agent starts the tree afresh (it died, it was stunned). */
+    reset(ctx: C): void;
+    /** Whether a node is running for this agent now. */
+    isRunning(node: BtNode<C>): boolean;
+    state<T>(node: BtNode<C>, init: () => T): T;
+    lasting<T>(node: BtNode<C>, init: () => T): T;
+    tick(child: BtNode<C>, ctx: C): BtStatus;
+    halt(child: BtNode<C>, ctx: C): void;
+    /** The tree as it ran on the last tick, depth first: for a debug overlay. */
+    trace(): BtTraceLine[];
+}
+/**
+ * A trace as text, one node a line, indented by depth, with what each answered (`·` when it was not ticked): for a
+ * debug overlay's `Text`, or a log.
+ *
+ * ```
+ * reactive-selector running
+ *   sequence failure
+ *     hurt failure
+ *     flee ·
+ *   wander running
+ * ```
+ */
+export declare function formatTrace(trace: readonly BtTraceLine[]): string;
+/**
+ * Runs its children in order until one fails: all must succeed. A running child is resumed on the next tick
+ * without asking the ones before it again (`reactiveSequence` does ask them).
+ */
+export declare function sequence<C>(...children: BtNode<C>[]): BtNode<C>;
+/** Tries its children in order until one does not fail: the first that works. Resumes a running child. */
+export declare function selector<C>(...children: BtNode<C>[]): BtNode<C>;
+/**
+ * A sequence that asks every child from the first again on each tick: a guard in front ("still sees the player?")
+ * is checked every time, and when it fails the child that was running is halted.
+ */
+export declare function reactiveSequence<C>(...children: BtNode<C>[]): BtNode<C>;
+/**
+ * A selector that asks from the first child again on each tick: a higher-priority branch ("flee when hurt") takes
+ * over the moment it can run, halting the lower one it interrupts.
+ */
+export declare function reactiveSelector<C>(...children: BtNode<C>[]): BtNode<C>;
+export interface ParallelPolicy {
+    /** Children that must succeed for the whole to (default all). */
+    succeed?: number;
+    /** Children that must fail for the whole to (default 1). */
+    fail?: number;
+}
+/**
+ * Ticks every child each tick (walk and look about at once). Succeeds once `succeed` have succeeded, fails once
+ * `fail` have failed, halting the rest; a child that finished is not ticked again until the whole finishes.
+ */
+export declare function parallel<C>(policy: ParallelPolicy, ...children: BtNode<C>[]): BtNode<C>;
+/** Swaps success and failure. */
+export declare function invert<C>(child: BtNode<C>): BtNode<C>;
+/** Succeeds whatever its child answers, once the child is done: an optional step. */
+export declare function succeed<C>(child: BtNode<C>): BtNode<C>;
+/**
+ * Runs its child `times` times in a row (Infinity: for good), stopping at the first failure. One pass per tick at
+ * most, so a child that succeeds at once cannot spin a frame.
+ */
+export declare function repeat<C>(times: number, child: BtNode<C>): BtNode<C>;
+/** Tries its child up to `times` times until it succeeds, a try a tick. */
+export declare function retry<C>(times: number, child: BtNode<C>): BtNode<C>;
+/** Runs its child at most once every `ms`: after it finishes, it fails at once until the time is up. */
+export declare function cooldown<C>(ms: number, child: BtNode<C>): BtNode<C>;
+/** Fails, halting its child, when the child has run longer than `ms`. */
+export declare function timeout<C>(ms: number, child: BtNode<C>): BtNode<C>;
+/** Runs for `ms`, then succeeds. */
+export declare function wait<C>(ms: number): BtNode<C>;
+/** A test: success when `test` holds, else failure. Never runs. */
+export declare function condition<C>(name: string, test: (ctx: C) => boolean): BtNode<C>;
+export interface ActionOptions<C> {
+    /** The action was running and the tree left it (a higher branch took over): stop what it started. */
+    onHalt?: (ctx: C) => void;
+}
+/** Something the agent does: `run` answers each tick until the doing is done. */
+export declare function action<C>(name: string, run: (ctx: C, now: number) => BtStatus, options?: ActionOptions<C>): BtNode<C>;
+//# sourceMappingURL=behaviorTree.d.ts.map

package/dist/types/ai/behaviorTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"behaviorTree.d.ts","sourceRoot":"","sources":["../../../src/ai/behaviorTree.ts"],"names":[],"mappings":"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"}

package/dist/types/ai/buildTree.d.ts

@@ -0,0 +1,55 @@
+import { type ActionOptions, type BtNode, type BtStatus } from './behaviorTree.js';
+/**
+ * A tree written as data (a JSON file a designer edits): composites hold `children`, decorators one `child`, and
+ * leaves name an action or a condition the game registered.
+ *
+ * ```json
+ * { "type": "reactiveSelector", "children": [
+ *   { "type": "sequence", "children": [{ "type": "condition", "name": "hurt" }, { "type": "action", "name": "flee" }] },
+ *   { "type": "cooldown", "ms": 2000, "child": { "type": "action", "name": "bark" } },
+ *   { "type": "action", "name": "wander" }
+ * ] }
+ * ```
+ */
+export type BtSpec = {
+    type: 'sequence' | 'selector' | 'reactiveSequence' | 'reactiveSelector';
+    children: BtSpec[];
+} | {
+    type: 'parallel';
+    succeed?: number;
+    fail?: number;
+    children: BtSpec[];
+} | {
+    type: 'invert' | 'succeed';
+    child: BtSpec;
+} | {
+    type: 'repeat' | 'retry';
+    times: number;
+    child: BtSpec;
+} | {
+    type: 'cooldown' | 'timeout';
+    ms: number;
+    child: BtSpec;
+} | {
+    type: 'wait';
+    ms: number;
+} | {
+    type: 'action' | 'condition';
+    name: string;
+}
+/** A named subtree of the registry, so a tree is shared by several (a "flee" every monster uses). */
+ | {
+    type: 'tree';
+    name: string;
+};
+/** What the leaves of a data tree name. */
+export interface BtRegistry<C> {
+    actions?: Record<string, ((ctx: C, now: number) => BtStatus) | ({
+        run: (ctx: C, now: number) => BtStatus;
+    } & ActionOptions<C>)>;
+    conditions?: Record<string, (ctx: C) => boolean>;
+    trees?: Record<string, BtSpec>;
+}
+/** A tree from its data. Throws, naming the path, on an unknown type, a missing leaf or a subtree that names itself. */
+export declare function buildTree<C>(spec: BtSpec, registry: BtRegistry<C>): BtNode<C>;
+//# sourceMappingURL=buildTree.d.ts.map

package/dist/types/ai/buildTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildTree.d.ts","sourceRoot":"","sources":["../../../src/ai/buildTree.ts"],"names":[],"mappings":"AAAA,OAAO,EAeL,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,QAAQ,EACd,MAAM,gBAAgB,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,MAAM,GACd;IAAE,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,kBAAkB,GAAG,kBAAkB,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAC/F;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GACzE;IAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,IAAI,EAAE,UAAU,GAAG,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC5B;IAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE;AAChD,qGAAqG;GACnG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC,2CAA2C;AAC3C,MAAM,WAAW,UAAU,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,CAAC,IAAG;QAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,CAAA;KAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA,CAAC,CAAC;IAC9H,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAED,wHAAwH;AACxH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAE7E"}

package/dist/types/audio/spatial.d.ts

@@ -0,0 +1,107 @@
+/** A point in the world, px. */
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+export interface SpatialMixOptions {
+    /** Beyond this (px) the source is not heard (default 480). */
+    range?: number;
+    /** How the loudness falls off: 1 straight, higher drops faster near the edge of `range` (default 1.5). */
+    rolloff?: number;
+    /** Px off to one side at which the sound is panned fully that way (default `range / 2`). */
+    panWidth?: number;
+    /** The furthest it pans, 0–1: 1 is one ear only, which sounds wrong on headphones (default 0.8). */
+    maxPan?: number;
+    /** Low-pass cutoff (Hz) beside the listener and at the edge of `range`, so far sounds are dull; null for none. */
+    muffle?: readonly [number, number] | null;
+}
+/** How a source sounds from where the listener stands. */
+export interface SpatialMix {
+    /** Within `range`. */
+    audible: boolean;
+    /** 0–1. */
+    gain: number;
+    /** −1 left … 1 right. */
+    pan: number;
+    /** The low-pass cutoff, Hz (the top of hearing when `muffle` is null). */
+    cutoffHz: number;
+}
+/** The mix of a source at `source` heard from `listener`: louder near, panned to its side, duller far. */
+export declare function spatialMix(listener: Point, source: Point, options?: SpatialMixOptions): SpatialMix;
+export interface EmitterOptions extends SpatialMixOptions {
+    /** 0–1 (default 1). */
+    volume?: number;
+    /** Plays on for good (default true); a one-shot ends by itself. */
+    loop?: boolean;
+    playbackRate?: number;
+}
+/** A sound placed in the world by `SpatialAudio`. */
+export interface SpatialEmitter {
+    x: number;
+    y: number;
+    volume: number;
+    /** Playing now: false while out of range (a loop waits silent), and for good once stopped or ended. */
+    readonly playing: boolean;
+    readonly done: boolean;
+    stop(fadeMs?: number): void;
+}
+/**
+ * Sounds placed in the world, heard from a listener that moves: a waterfall, a campfire, a machine humming, or a
+ * one-shot at a spot. Each emitter is panned to its side, fades with distance and loses its highs far away
+ * (`spatialMix`), eased each `update` so a moving source does not click. A loop out of range stops its source to
+ * save the voice and starts again at the point it would have reached, so it seems to have played on.
+ *
+ * ```ts
+ * const world = new SpatialAudio(audioContext);
+ * const falls = world.emitter(fallsBuffer, 320, 96, { range: 400, volume: 0.6 });
+ * // each frame: world.update(hero);
+ * ```
+ */
+export declare class SpatialAudio {
+    readonly context: BaseAudioContext;
+    /** Every emitter's gain goes through this: the game's volume setting. */
+    readonly output: GainNode;
+    private readonly emitters;
+    private here;
+    constructor(context: BaseAudioContext, destination?: AudioNode);
+    /** The listener's place as of the last `update`. */
+    get listener(): Point;
+    /** How many emitters are alive (playing or waiting out of range). */
+    get size(): number;
+    /** A sound at (x, y), looping by default. Starts at once when in range of the listener. */
+    emitter(buffer: AudioBuffer, x: number, y: number, options?: EmitterOptions): SpatialEmitter;
+    /** A one-shot at (x, y), dropped when it ends; skipped (and done at once) when out of range. */
+    play(buffer: AudioBuffer, x: number, y: number, options?: Omit<EmitterOptions, 'loop'>): SpatialEmitter;
+    /** Moves the listener and re-mixes every emitter. Call once a frame. */
+    update(listener?: Point): void;
+    /** Stops every emitter. */
+    stopAll(fadeMs?: number): void;
+    destroy(): void;
+    /** @internal */
+    forget(e: Emitter): void;
+}
+declare class Emitter implements SpatialEmitter {
+    private readonly owner;
+    private readonly buffer;
+    x: number;
+    y: number;
+    private readonly options;
+    volume: number;
+    done: boolean;
+    private source;
+    private readonly gain;
+    private readonly panner;
+    private readonly filter;
+    /** When the loop would have begun, had it never stopped: where a restart picks it up. */
+    private readonly origin;
+    private readonly rate;
+    constructor(owner: SpatialAudio, buffer: AudioBuffer, x: number, y: number, options: EmitterOptions);
+    get playing(): boolean;
+    refresh(listener: Point, smooth: boolean): void;
+    stop(fadeMs?: number): void;
+    private begin;
+    private halt;
+    private release;
+}
+export {};
+//# sourceMappingURL=spatial.d.ts.map

package/dist/types/audio/spatial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../../../src/audio/spatial.ts"],"names":[],"mappings":"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"}