@aethervtt/shard-core 0.0.1 → 0.2.0

package/dist/ecs/world.js

@@ -3,12 +3,14 @@ import { Registry } from "../schema/registry.js";
 import { formatEntity, MAX_ENTITIES, makeEntity } from "./entity.js";
 import { EventQueue, EventReader } from "./events.js";
 import { ChildOf, Children } from "./hierarchy.js";
+import { assertHostWrite } from "./host-write.js";
 import {
   ObserverTable,
   onAdd,
   onRemove,
   onSet
 } from "./observers.js";
+import { Owners } from "./owners.js";
 import { Query, queryKey } from "./query.js";
 import { Table } from "./table.js";
 const FREE = 4294967295;
@@ -19,6 +21,14 @@ class World {
   /** Change-detection clock. The scheduler advances it once per system run. */
   tick = 1;
   registry = new Registry();
+  /**
+   * While true, the next write (`set`, `add`, `remove`, `spawn`, `despawn`, `insertResource`,
+   * `removeResource`, `send`, `patchResource`, `touchResource`) clears it and calls `onWake`. The
+   * on-demand runner sets it when a frame ends and nothing asks for another (0052).
+   */
+  asleep = false;
+  /** Called by the first write while `asleep`. Set by the on-demand runner. */
+  onWake = void 0;
   generations = new Uint32Array(1024);
   tableOf = new Uint32Array(1024).fill(FREE);
   rowOf = new Uint32Array(1024);
@@ -30,18 +40,36 @@ class World {
   emptyTable;
   queries = /* @__PURE__ */ new Map();
   resources = /* @__PURE__ */ new Map();
+  /** Change tick per resource id: set by insertResource, patchResource, and touchResource. */
+  resourceTicks = [];
   eventQueues = /* @__PURE__ */ new Map();
   observers = new ObserverTable();
   registered = [];
+  owners_;
   constructor() {
     this.emptyTable = this.getOrCreateTable([]);
     this.installHierarchy();
   }
+  /**
+   * Who made what (0061): owners hold entities and asset leases, and release them together.
+   * Only code holding an `Owner` can spawn into it, lease for it, or release it.
+   */
+  get owners() {
+    this.owners_ ??= new Owners(this);
+    return this.owners_;
+  }
   incrementTick() {
     return ++this.tick;
   }
+  /** Wakes the world as a write would: if it's asleep, clears `asleep` and calls `onWake`. */
+  wake() {
+    if (!this.asleep) return;
+    this.asleep = false;
+    this.onWake?.();
+  }
   // --- entities --------------------------------------------------------------
   spawn(...inits) {
+    if (this.asleep) this.wake();
     const entity = this.allocate();
     this.insert(entity, inits);
     return entity;
@@ -55,6 +83,7 @@ class World {
     if (index >= this.nextIndex || this.tableOf[index] !== PENDING || this.generations[index] !== Math.floor(entity / MAX_ENTITIES)) {
       throw new ShardError("ecs/dead-entity", `Entity ${formatEntity(entity)} is not reserved`);
     }
+    if (this.asleep) this.wake();
     this.insert(entity, inits);
   }
   isAlive(entity) {
@@ -69,6 +98,7 @@ class World {
   /** Despawns the entity and, if it has children, all of its descendants. */
   despawn(entity) {
     this.locate(entity);
+    if (this.asleep) this.wake();
     const children = this.tryGet(entity, Children);
     if (children) {
       for (const child of children.entities) {
@@ -80,6 +110,7 @@ class World {
   /** Despawns only this entity. Its children lose their `ChildOf` and become roots. */
   despawnSingle(entity) {
     this.locate(entity);
+    if (this.asleep) this.wake();
     const children = this.tryGet(entity, Children);
     if (children) {
       for (const child of children.entities) {
@@ -105,7 +136,9 @@ class World {
   /** Adds a component (defaults for missing fields). If present, replaces it and fires `onSet`. */
   add(entity, component, value) {
     const def = component;
+    if (def.hostOnly) assertHostWrite(def);
     const index = this.locate(entity);
+    if (this.asleep) this.wake();
     this.ensureRegistered(def);
     const table = this.tables[this.tableOf[index]];
     const row = this.rowOf[index];
@@ -134,8 +167,10 @@ class World {
   }
   /** Removes a component. Returns false if the entity didn't have it. */
   remove(entity, component) {
+    if (component.hostOnly) assertHostWrite(component);
     let index = this.locate(entity);
     if (!this.tables[this.tableOf[index]].has(component)) return false;
+    if (this.asleep) this.wake();
     this.fire("remove", entity, component, void 0);
     index = this.locate(entity);
     const table = this.tables[this.tableOf[index]];
@@ -162,9 +197,11 @@ class World {
   /** Writes the given fields and marks the component changed. */
   set(entity, component, values) {
     const def = component;
+    if (def.hostOnly) assertHostWrite(def);
     const index = this.locate(entity);
     const table = this.tables[this.tableOf[index]];
     if (!table.has(def)) throw missingComponent(entity, def.name);
+    if (this.asleep) this.wake();
     const row = this.rowOf[index];
     const previous = this.hasObservers("set", def) ? table.readComponent(def, row) : void 0;
     table.writeComponent(def, row, values);
@@ -207,7 +244,32 @@ class World {
   // --- resources -------------------------------------------------------------
   insertResource(def, value) {
     this.registry.register(def);
+    if (this.asleep) this.wake();
     this.resources.set(def.id, value);
+    this.resourceTicks[def.id] = this.tick;
+  }
+  /**
+   * Assigns `partial`'s fields onto the resource, marks it changed, and wakes the world. How code
+   * outside a frame writes a resource; a bare field assignment is invisible to both (0052).
+   */
+  patchResource(def, partial) {
+    const value = this.resource(def);
+    Object.assign(value, partial);
+    this.touchResource(def);
+    return value;
+  }
+  /** Marks the resource changed and wakes the world, after editing it in place. */
+  touchResource(def) {
+    if (!this.resources.has(def.id)) this.resource(def);
+    this.resourceTicks[def.id] = this.tick;
+    if (this.asleep) this.wake();
+  }
+  /**
+   * Whether the resource was inserted, patched, or touched after tick `since` (a system passes
+   * `ctx.lastRunTick`), like component change detection.
+   */
+  resourceChanged(def, since) {
+    return (this.resourceTicks[def.id] ?? 0) > since;
   }
   /** Inserts the resource from its `init` if it isn't present yet, and returns it. */
   initResource(def) {
@@ -240,10 +302,14 @@ class World {
     return this.resources.has(def.id);
   }
   removeResource(def) {
+    if (!this.resources.has(def.id)) return false;
+    if (this.asleep) this.wake();
+    this.resourceTicks[def.id] = this.tick;
     return this.resources.delete(def.id);
   }
   // --- events ----------------------------------------------------------------
   send(def, ...data) {
+    if (this.asleep) this.wake();
     this.eventQueue(def).send(data[0]);
   }
   reader(def) {
@@ -350,6 +416,7 @@ class World {
     for (let i = 0; i < inits.length; i++) {
       const init = inits[i];
       const def = Array.isArray(init) ? init[0] : init;
+      if (def.hostOnly) assertHostWrite(def);
       this.ensureRegistered(def);
       table = this.tableWith(table, def);
     }

package/dist/math/index.d.ts

@@ -5,6 +5,7 @@ export * as frustum from './frustum.js';
 export { hash32, hashSeed, LATTICE_PRIMES, mix32 } from './hash.js';
 export * as mat3 from './mat3.js';
 export * as mat4 from './mat4.js';
+export * as polygon from './polygon.js';
 export * as quat from './quat.js';
 export * as ray from './ray.js';
 export { Rng } from './rng.js';

package/dist/math/index.js

@@ -5,6 +5,7 @@ import * as frustum from "./frustum.js";
 import { hash32, hashSeed, LATTICE_PRIMES, mix32 } from "./hash.js";
 import * as mat3 from "./mat3.js";
 import * as mat4 from "./mat4.js";
+import * as polygon from "./polygon.js";
 import * as quat from "./quat.js";
 import * as ray from "./ray.js";
 import { Rng } from "./rng.js";
@@ -25,6 +26,7 @@ export {
   mat3,
   mat4,
   mix32,
+  polygon,
   quat,
   ray,
   vec2,

package/dist/math/polygon.d.ts

@@ -0,0 +1,17 @@
+/** The signed area of a ring. Positive when counter-clockwise (y up). */
+export declare function signedArea(points: ArrayLike<number>, start?: number, end?: number): number;
+/** The total area of triangles given by `indices` into flat xy `points`. */
+export declare function trianglesArea(points: ArrayLike<number>, indices: ArrayLike<number>): number;
+/**
+ * Triangulates a simple polygon, with optional holes, by ear clipping. `points` holds the outer
+ * ring first, then each hole; `holes` lists the vertex index where each hole starts. Either
+ * winding works for any ring. Returns vertex indices, three per triangle, counter-clockwise.
+ * Holes are bridged to the outer ring first, so the result covers the polygon minus its holes.
+ */
+export declare function triangulate(points: ArrayLike<number>, holes?: ArrayLike<number>): number[];
+/**
+ * Clips a convex polygon (flat xy, `n` points, in `src`) to the rectangle
+ * `[minX, maxX] × [minY, maxY]` (Sutherland–Hodgman). Writes the result to `out` and returns its
+ * point count (0 when nothing is inside). `out` and `scratch` need room for `n + 4` points.
+ */
+export declare function clipToRect(src: ArrayLike<number>, n: number, minX: number, minY: number, maxX: number, maxY: number, out: Float64Array, scratch: Float64Array): number;

package/dist/math/polygon.js

@@ -0,0 +1,307 @@
+function signedArea(points, start = 0, end = points.length >> 1) {
+  let area = 0;
+  for (let i = start, j = end - 1; i < end; j = i++) {
+    area += points[j * 2] * points[i * 2 + 1] - points[i * 2] * points[j * 2 + 1];
+  }
+  return area / 2;
+}
+function trianglesArea(points, indices) {
+  let area = 0;
+  for (let i = 0; i + 2 < indices.length; i += 3) {
+    const a = indices[i] * 2;
+    const b = indices[i + 1] * 2;
+    const c = indices[i + 2] * 2;
+    area += Math.abs(
+      (points[b] - points[a]) * (points[c + 1] - points[a + 1]) - (points[c] - points[a]) * (points[b + 1] - points[a + 1])
+    );
+  }
+  return area / 2;
+}
+function triangulate(points, holes = []) {
+  const out = [];
+  const count = points.length >> 1;
+  const outerEnd = holes.length > 0 ? holes[0] : count;
+  let outer = ring(points, 0, outerEnd, true);
+  if (!outer || outer.next === outer.prev) return out;
+  if (holes.length > 0) outer = eliminateHoles(points, holes, outer, count);
+  earcut(outer, out, 0);
+  return out;
+}
+function ring(points, start, end, ccw) {
+  if (end - start < 3) return void 0;
+  const forward = signedArea(points, start, end) > 0 === ccw;
+  let last;
+  if (forward) for (let i = start; i < end; i++) last = insert(i, points, last);
+  else for (let i = end - 1; i >= start; i--) last = insert(i, points, last);
+  if (last && last.x === last.next.x && last.y === last.next.y) {
+    const next = last.next;
+    remove(last);
+    last = next;
+  }
+  return last;
+}
+function insert(i, points, last) {
+  const node = { i, x: points[i * 2], y: points[i * 2 + 1], gone: false };
+  if (!last) {
+    node.prev = node;
+    node.next = node;
+  } else {
+    node.next = last.next;
+    node.prev = last;
+    last.next.prev = node;
+    last.next = node;
+  }
+  return node;
+}
+function remove(node) {
+  node.next.prev = node.prev;
+  node.prev.next = node.next;
+  node.gone = true;
+}
+function area2(a, b, c) {
+  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+}
+function pointInTriangle(ax, ay, bx, by, cx, cy, px, py) {
+  return (cx - px) * (ay - py) >= (ax - px) * (cy - py) && (ax - px) * (by - py) >= (bx - px) * (ay - py) && (bx - px) * (cy - py) >= (cx - px) * (by - py);
+}
+function isEar(ear) {
+  const a = ear.prev;
+  const b = ear;
+  const c = ear.next;
+  if (area2(a, b, c) <= 0) return false;
+  for (let p = c.next; p !== a; p = p.next) {
+    if (p.x === a.x && p.y === a.y || p.x === b.x && p.y === b.y || p.x === c.x && p.y === c.y)
+      continue;
+    if (pointInTriangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y) && area2(p.prev, p, p.next) <= 0)
+      return false;
+  }
+  return true;
+}
+function earcut(start, out, pass) {
+  let ear = start;
+  let stop = ear;
+  while (ear.prev !== ear.next) {
+    const prev = ear.prev;
+    const next = ear.next;
+    if (isEar(ear)) {
+      out.push(prev.i, ear.i, next.i);
+      remove(ear);
+      ear = next.next;
+      stop = next.next;
+      continue;
+    }
+    ear = next;
+    if (ear === stop) {
+      if (pass === 0) earcut(filterPoints(ear), out, 1);
+      else if (pass === 1) earcut(cureLocalIntersections(filterPoints(ear), out), out, 2);
+      else if (pass === 2) splitEarcut(ear, out);
+      return;
+    }
+  }
+}
+function filterPoints(start) {
+  let p = start;
+  let end = start;
+  let again;
+  do {
+    again = false;
+    if (p.x === p.next.x && p.y === p.next.y || area2(p.prev, p, p.next) === 0) {
+      remove(p);
+      p = end = p.prev;
+      if (p === p.next) break;
+      again = true;
+    } else p = p.next;
+  } while (again || p !== end);
+  return end;
+}
+function intersects(p1, q1, p2, q2) {
+  const o1 = Math.sign(area2(p1, q1, p2));
+  const o2 = Math.sign(area2(p1, q1, q2));
+  const o3 = Math.sign(area2(p2, q2, p1));
+  const o4 = Math.sign(area2(p2, q2, q1));
+  return o1 !== o2 && o3 !== o4;
+}
+function locallyInside(a, b) {
+  return area2(a.prev, a, a.next) < 0 ? area2(a, b, a.next) >= 0 && area2(a, a.prev, b) >= 0 : area2(a, b, a.prev) < 0 || area2(a, a.next, b) < 0;
+}
+function cureLocalIntersections(start, out) {
+  let p = start;
+  do {
+    const a = p.prev;
+    const b = p.next.next;
+    if (!(a.x === b.x && a.y === b.y) && intersects(a, p, p.next, b) && locallyInside(a, b) && locallyInside(b, a)) {
+      out.push(a.i, p.i, b.i);
+      remove(p);
+      remove(p.next);
+      p = start = b;
+    }
+    p = p.next;
+  } while (p !== start);
+  return filterPoints(p);
+}
+function middleInside(a, b) {
+  let p = a;
+  let inside = false;
+  const px = (a.x + b.x) / 2;
+  const py = (a.y + b.y) / 2;
+  do {
+    if (p.y > py !== p.next.y > py && p.next.y !== p.y && px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x)
+      inside = !inside;
+    p = p.next;
+  } while (p !== a);
+  return inside;
+}
+function intersectsPolygon(a, b) {
+  let p = a;
+  do {
+    if (p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i && intersects(p, p.next, a, b))
+      return true;
+    p = p.next;
+  } while (p !== a);
+  return false;
+}
+function isValidDiagonal(a, b) {
+  return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b);
+}
+function splitPolygon(a, b) {
+  const a2 = { i: a.i, x: a.x, y: a.y, gone: false };
+  const b2 = { i: b.i, x: b.x, y: b.y, gone: false };
+  const an = a.next;
+  const bp = b.prev;
+  a.next = b;
+  b.prev = a;
+  a2.next = an;
+  an.prev = a2;
+  b2.next = a2;
+  a2.prev = b2;
+  bp.next = b2;
+  b2.prev = bp;
+  return b2;
+}
+function splitEarcut(start, out) {
+  let a = start;
+  do {
+    let b = a.next.next;
+    while (b !== a.prev) {
+      if (a.i !== b.i && isValidDiagonal(a, b)) {
+        let c = splitPolygon(a, b);
+        a = filterPoints(a);
+        c = filterPoints(c);
+        earcut(a, out, 0);
+        earcut(c, out, 0);
+        return;
+      }
+      b = b.next;
+    }
+    a = a.next;
+  } while (a !== start);
+}
+function eliminateHoles(points, holes, outer, count) {
+  const queue = [];
+  for (let h = 0; h < holes.length; h++) {
+    const start = holes[h];
+    const end = h + 1 < holes.length ? holes[h + 1] : count;
+    const list = ring(points, start, end, false);
+    if (!list) continue;
+    let left = list;
+    let p = list;
+    do {
+      if (p.x < left.x || p.x === left.x && p.y < left.y) left = p;
+      p = p.next;
+    } while (p !== list);
+    queue.push(left);
+  }
+  queue.sort((a, b) => a.x - b.x || a.y - b.y);
+  for (const hole of queue) outer = filterPoints(eliminateHole(hole, outer));
+  return outer;
+}
+function eliminateHole(hole, outer) {
+  const bridge = findHoleBridge(hole, outer);
+  if (!bridge) return outer;
+  const reverse = splitPolygon(bridge, hole);
+  filterPoints(reverse);
+  return filterPoints(bridge);
+}
+function findHoleBridge(hole, outer) {
+  let p = outer;
+  const hx = hole.x;
+  const hy = hole.y;
+  let qx = -Infinity;
+  let m;
+  do {
+    if (hy <= p.y && hy >= p.next.y && p.next.y !== p.y) {
+      const x = p.x + (hy - p.y) * (p.next.x - p.x) / (p.next.y - p.y);
+      if (x <= hx && x > qx) {
+        qx = x;
+        m = p.x < p.next.x ? p : p.next;
+        if (x === hx) return m;
+      }
+    }
+    p = p.next;
+  } while (p !== outer);
+  if (!m) return void 0;
+  const stop = m;
+  const mx = m.x;
+  const my = m.y;
+  let tanMin = Infinity;
+  p = m;
+  do {
+    if (hx >= p.x && p.x >= mx && hx !== p.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y)) {
+      const tan = Math.abs(hy - p.y) / (hx - p.x);
+      if (locallyInside(p, hole) && (tan < tanMin || tan === tanMin && (p.x > m.x || p.x === m.x && sectorContainsSector(m, p)))) {
+        m = p;
+        tanMin = tan;
+      }
+    }
+    p = p.next;
+  } while (p !== stop);
+  return m;
+}
+function sectorContainsSector(m, p) {
+  return area2(m.prev, m, p.prev) < 0 && area2(p.next, m, m.next) < 0;
+}
+function clipToRect(src, n, minX, minY, maxX, maxY, out, scratch) {
+  let count = clipEdge(src, n, scratch, 0, minX, 1);
+  count = clipEdge(scratch, count, out, 0, maxX, -1);
+  count = clipEdge(out, count, scratch, 1, minY, 1);
+  count = clipEdge(scratch, count, out, 1, maxY, -1);
+  return count;
+}
+function clipEdge(src, n, dst, axis, at, sign) {
+  let count = 0;
+  if (n === 0) return 0;
+  let px = src[(n - 1) * 2];
+  let py = src[(n - 1) * 2 + 1];
+  let pd = sign * ((axis === 0 ? px : py) - at);
+  for (let i = 0; i < n; i++) {
+    const x = src[i * 2];
+    const y = src[i * 2 + 1];
+    const d = sign * ((axis === 0 ? x : y) - at);
+    if (d >= 0) {
+      if (pd < 0) {
+        const t = pd / (pd - d);
+        dst[count * 2] = px + (x - px) * t;
+        dst[count * 2 + 1] = py + (y - py) * t;
+        count++;
+      }
+      dst[count * 2] = x;
+      dst[count * 2 + 1] = y;
+      count++;
+    } else if (pd >= 0) {
+      const t = pd / (pd - d);
+      dst[count * 2] = px + (x - px) * t;
+      dst[count * 2 + 1] = py + (y - py) * t;
+      count++;
+    }
+    px = x;
+    py = y;
+    pd = d;
+  }
+  return count;
+}
+export {
+  clipToRect,
+  signedArea,
+  trianglesArea,
+  triangulate
+};