@zylem/game-lib 0.3.14 → 0.3.16

package/dist/lib/entities/plane.js

@@ -0,0 +1,81 @@
+import { ColliderDesc as B } from "@dimforge/rapier3d-compat";
+import { Color as M, Vector3 as u, Vector2 as d, PlaneGeometry as C } from "three";
+import { GameEntity as D } from "./entity.js";
+import { EntityCollisionBuilder as E, EntityBuilder as P, EntityMeshBuilder as v } from "./builder.js";
+import { XZPlaneGeometry as z } from "../graphics/geometries/XZPlaneGeometry.js";
+import { createEntity as A } from "./create.js";
+const r = 4, p = {
+  tile: new d(10, 10),
+  repeat: new d(1, 1),
+  position: new u(0, 0, 0),
+  collision: {
+    static: !0
+  },
+  material: {
+    color: new M("#ffffff"),
+    shader: "standard"
+  },
+  subdivisions: r
+};
+class G extends E {
+  collider(e) {
+    const o = e.tile ?? new d(1, 1), s = e.subdivisions ?? r, t = new u(o.x, 1, o.y), i = e._builders?.meshBuilder?.heightData, h = new u(t.x, 1, t.z);
+    return B.heightfield(s, s, i, h);
+  }
+}
+class R extends v {
+  heightData = new Float32Array();
+  columnsRows = /* @__PURE__ */ new Map();
+  build(e) {
+    const o = e.tile ?? new d(1, 1), s = e.subdivisions ?? r, t = new u(o.x, 1, o.y), i = new z(t.x, t.z, s, s), h = new C(t.x, t.z, s, s), w = t.x / s, g = t.z / s, x = i.attributes.position.array, a = h.attributes.position.array, c = /* @__PURE__ */ new Map();
+    for (let n = 0; n < a.length; n += 3) {
+      let b = Math.floor(Math.abs(a[n] + t.x / 2) / w), m = Math.floor(Math.abs(a[n + 1] - t.z / 2) / g);
+      const y = Math.random() * 4;
+      a[n + 2] = y, x[n + 1] = y, c.get(m) || c.set(m, /* @__PURE__ */ new Map()), c.get(m).set(b, y);
+    }
+    return this.columnsRows = c, i;
+  }
+  postBuild() {
+    const e = [];
+    for (let o = 0; o <= r; ++o)
+      for (let s = 0; s <= r; ++s) {
+        const t = this.columnsRows.get(s);
+        if (!t)
+          continue;
+        const i = t.get(o);
+        e.push(i);
+      }
+    this.heightData = new Float32Array(e);
+  }
+}
+class S extends P {
+  createEntity(e) {
+    return new f(e);
+  }
+}
+const V = Symbol("Plane");
+class f extends D {
+  static type = V;
+  constructor(e) {
+    super(), this.options = { ...p, ...e };
+  }
+}
+async function U(...l) {
+  return A({
+    args: l,
+    defaultConfig: p,
+    EntityClass: f,
+    BuilderClass: S,
+    MeshBuilderClass: R,
+    CollisionBuilderClass: G,
+    entityType: f.type
+  });
+}
+export {
+  V as PLANE_TYPE,
+  S as PlaneBuilder,
+  G as PlaneCollisionBuilder,
+  R as PlaneMeshBuilder,
+  f as ZylemPlane,
+  U as plane
+};

package/dist/lib/entities/rect.js

@@ -0,0 +1,160 @@
+import { Vector2 as f, Group as D, CanvasTexture as R, LinearFilter as x, SpriteMaterial as V, Sprite as Y, ClampToEdgeWrapping as T, ShaderMaterial as y, Color as S, Mesh as z, PlaneGeometry as B, Vector3 as W } from "three";
+import { GameEntity as I } from "./entity.js";
+import { EntityBuilder as X } from "./builder.js";
+import { createEntity as q } from "./create.js";
+import { DebugDelegate as U } from "./delegates/debug.js";
+const k = {
+  position: void 0,
+  width: 120,
+  height: 48,
+  fillColor: "#FFFFFF",
+  strokeColor: null,
+  strokeWidth: 0,
+  radius: 0,
+  padding: 0,
+  stickToViewport: !0,
+  screenPosition: new f(24, 24),
+  zDistance: 1,
+  anchor: new f(0, 0)
+};
+class G extends X {
+  createEntity(t) {
+    return new _(t);
+  }
+}
+const O = Symbol("Rect");
+class _ extends I {
+  static type = O;
+  _sprite = null;
+  _mesh = null;
+  _texture = null;
+  _canvas = null;
+  _ctx = null;
+  _cameraRef = null;
+  _lastCanvasW = 0;
+  _lastCanvasH = 0;
+  constructor(t) {
+    super(), this.options = { ...k, ...t }, this.group = new D(), this.createSprite(), this.lifeCycleDelegate = {
+      setup: [this.rectSetup.bind(this)],
+      update: [this.rectUpdate.bind(this)]
+    };
+  }
+  createSprite() {
+    this._canvas = document.createElement("canvas"), this._ctx = this._canvas.getContext("2d"), this._texture = new R(this._canvas), this._texture.minFilter = x, this._texture.magFilter = x;
+    const t = new V({
+      map: this._texture,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1,
+      alphaTest: 0.5
+    });
+    this._sprite = new Y(t), this.group?.add(this._sprite), this.redrawRect();
+  }
+  redrawRect() {
+    if (!this._canvas || !this._ctx)
+      return;
+    const t = Math.max(2, Math.floor(this.options.width ?? 120)), e = Math.max(2, Math.floor(this.options.height ?? 48)), s = this.options.padding ?? 0, i = this.options.strokeWidth ?? 0, a = t + s * 2 + i, r = e + s * 2 + i, o = Math.max(2, a), n = Math.max(2, r), h = o !== this._lastCanvasW || n !== this._lastCanvasH;
+    this._canvas.width = o, this._canvas.height = n, this._lastCanvasW = o, this._lastCanvasH = n, this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
+    const u = Math.max(0, this.options.radius ?? 0), d = Math.floor(s + i / 2), m = Math.floor(s + i / 2), g = Math.floor(t), p = Math.floor(e);
+    if (this._ctx.beginPath(), u > 0 ? this.roundedRectPath(this._ctx, d, m, g, p, u) : this._ctx.rect(d, m, g, p), this.options.fillColor && (this._ctx.fillStyle = this.toCssColor(this.options.fillColor), this._ctx.fill()), this.options.strokeColor && i > 0 && (this._ctx.lineWidth = i, this._ctx.strokeStyle = this.toCssColor(this.options.strokeColor), this._ctx.stroke()), this._texture) {
+      if (h && (this._texture.dispose(), this._texture = new R(this._canvas), this._texture.minFilter = x, this._texture.magFilter = x, this._texture.wrapS = T, this._texture.wrapT = T, this._sprite && this._sprite.material instanceof y)) {
+        const c = this._sprite.material;
+        c.uniforms?.tDiffuse && (c.uniforms.tDiffuse.value = this._texture), c.uniforms?.iResolution && c.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1);
+      }
+      this._texture.image = this._canvas, this._texture.needsUpdate = !0, this._sprite && this._sprite.material && (this._sprite.material.map = this._texture, this._sprite.material.needsUpdate = !0);
+    }
+  }
+  roundedRectPath(t, e, s, i, a, r) {
+    const o = Math.min(r, Math.floor(Math.min(i, a) / 2));
+    t.moveTo(e + o, s), t.lineTo(e + i - o, s), t.quadraticCurveTo(e + i, s, e + i, s + o), t.lineTo(e + i, s + a - o), t.quadraticCurveTo(e + i, s + a, e + i - o, s + a), t.lineTo(e + o, s + a), t.quadraticCurveTo(e, s + a, e, s + a - o), t.lineTo(e, s + o), t.quadraticCurveTo(e, s, e + o, s);
+  }
+  toCssColor(t) {
+    return typeof t == "string" ? t : `#${(t instanceof S ? t : new S(t)).getHexString()}`;
+  }
+  rectSetup(t) {
+    if (this._cameraRef = t.camera, this.options.stickToViewport && this._cameraRef && this._cameraRef.camera.add(this.group), this.materials?.length && this._sprite) {
+      const e = this.materials[0];
+      e instanceof y && (e.transparent = !0, e.depthTest = !1, e.depthWrite = !1, this._texture && (e.uniforms?.tDiffuse && (e.uniforms.tDiffuse.value = this._texture), e.uniforms?.iResolution && this._canvas && e.uniforms.iResolution.value.set(this._canvas.width, this._canvas.height, 1)), this._mesh = new z(new B(1, 1), e), this.group?.add(this._mesh), this._sprite.visible = !1);
+    }
+  }
+  rectUpdate(t) {
+    if (this._sprite) {
+      if (this._cameraRef && this.options.bounds) {
+        this._cameraRef.renderer.domElement;
+        const e = this.computeScreenBoundsFromOptions(this.options.bounds);
+        if (e) {
+          const { x: s, y: i, width: a, height: r } = e, o = Math.max(2, Math.floor(a)), n = Math.max(2, Math.floor(r)), h = o !== (this.options.width ?? 0) || n !== (this.options.height ?? 0);
+          this.options.screenPosition = new f(Math.floor(s), Math.floor(i)), this.options.width = o, this.options.height = n, this.options.anchor = new f(0, 0), h && this.redrawRect();
+        }
+      }
+      this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+    }
+  }
+  updateStickyTransform() {
+    if (!this._sprite || !this._cameraRef)
+      return;
+    const t = this._cameraRef.camera, e = this._cameraRef.renderer.domElement, s = e.clientWidth, i = e.clientHeight, a = (this.options.screenPosition ?? new f(24, 24)).x, r = (this.options.screenPosition ?? new f(24, 24)).y, o = Math.max(1e-3, this.options.zDistance ?? 1);
+    let n = 1, h = 1;
+    if (t.isPerspectiveCamera) {
+      const l = t, w = Math.tan(l.fov * Math.PI / 180 / 2) * o;
+      n = w * l.aspect, h = w;
+    } else if (t.isOrthographicCamera) {
+      const l = t;
+      n = (l.right - l.left) / 2, h = (l.top - l.bottom) / 2;
+    }
+    const u = a / s * 2 - 1, d = 1 - r / i * 2, m = u * n, g = d * h;
+    let p = 1, c = 1;
+    if (this._canvas) {
+      const w = h * 2 / i, C = this._canvas.height;
+      c = Math.max(1e-4, C * w);
+      const P = this._canvas.width / this._canvas.height;
+      p = c * P, this._sprite.scale.set(p, c, 1), this._mesh && this._mesh.scale.set(p, c, 1);
+    }
+    const M = this.options.anchor ?? new f(0, 0), H = Math.min(100, Math.max(0, M.x)) / 100, b = Math.min(100, Math.max(0, M.y)) / 100, E = (0.5 - H) * p, F = (b - 0.5) * c;
+    this.group?.position.set(m + E, g + F, -o);
+  }
+  worldToScreen(t) {
+    if (!this._cameraRef)
+      return { x: 0, y: 0 };
+    const e = this._cameraRef.camera, s = this._cameraRef.renderer.domElement, i = t.clone().project(e), a = (i.x + 1) / 2 * s.clientWidth, r = (1 - i.y) / 2 * s.clientHeight;
+    return { x: a, y: r };
+  }
+  computeScreenBoundsFromOptions(t) {
+    if (!this._cameraRef)
+      return null;
+    if (this._cameraRef.renderer.domElement, t.screen)
+      return { ...t.screen };
+    if (t.world) {
+      const { left: e, right: s, top: i, bottom: a, z: r = 0 } = t.world, o = this.worldToScreen(new W(e, i, r)), n = this.worldToScreen(new W(s, a, r)), h = Math.min(o.x, n.x), u = Math.min(o.y, n.y), d = Math.abs(n.x - o.x), m = Math.abs(n.y - o.y);
+      return { x: h, y: u, width: d, height: m };
+    }
+    return null;
+  }
+  updateRect(t) {
+    this.options = { ...this.options, ...t }, this.redrawRect(), this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  buildInfo() {
+    return {
+      ...new U(this).buildDebugInfo(),
+      type: String(_.type),
+      width: this.options.width ?? 0,
+      height: this.options.height ?? 0,
+      sticky: this.options.stickToViewport
+    };
+  }
+}
+async function K(...v) {
+  return q({
+    args: v,
+    defaultConfig: { ...k },
+    EntityClass: _,
+    BuilderClass: G,
+    entityType: _.type
+  });
+}
+export {
+  O as RECT_TYPE,
+  G as RectBuilder,
+  _ as ZylemRect,
+  K as rect
+};

package/dist/lib/entities/sphere.js

@@ -0,0 +1,68 @@
+import { ColliderDesc as l } from "@dimforge/rapier3d-compat";
+import { Color as n, Vector3 as a, SphereGeometry as d } from "three";
+import { GameEntity as u } from "./entity.js";
+import { EntityCollisionBuilder as c, EntityBuilder as p, EntityMeshBuilder as f } from "./builder.js";
+import { DebugDelegate as m } from "./delegates/debug.js";
+import { createEntity as y } from "./create.js";
+const o = {
+  radius: 1,
+  position: new a(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new n("#ffffff"),
+    shader: "standard"
+  }
+};
+class h extends c {
+  collider(e) {
+    const t = e.radius ?? 1;
+    return l.ball(t);
+  }
+}
+class C extends f {
+  build(e) {
+    const t = e.radius ?? 1;
+    return new d(t);
+  }
+}
+class E extends p {
+  createEntity(e) {
+    return new r(e);
+  }
+}
+const B = Symbol("Sphere");
+class r extends u {
+  static type = B;
+  constructor(e) {
+    super(), this.options = { ...o, ...e };
+  }
+  buildInfo() {
+    const t = new m(this).buildDebugInfo(), i = this.options.radius ?? 1;
+    return {
+      ...t,
+      type: String(r.type),
+      radius: i.toFixed(2)
+    };
+  }
+}
+async function I(...s) {
+  return y({
+    args: s,
+    defaultConfig: o,
+    EntityClass: r,
+    BuilderClass: E,
+    MeshBuilderClass: C,
+    CollisionBuilderClass: h,
+    entityType: r.type
+  });
+}
+export {
+  B as SPHERE_TYPE,
+  E as SphereBuilder,
+  h as SphereCollisionBuilder,
+  C as SphereMeshBuilder,
+  r as ZylemSphere,
+  I as sphere
+};

package/dist/lib/entities/sprite.js

@@ -0,0 +1,118 @@
+import { ColliderDesc as h } from "@dimforge/rapier3d-compat";
+import { Color as d, Vector3 as c, TextureLoader as f, SpriteMaterial as y, Sprite as A, Group as x, Quaternion as S, Euler as I } from "three";
+import { GameEntity as w } from "./entity.js";
+import { EntityCollisionBuilder as z, EntityBuilder as E } from "./builder.js";
+import { createEntity as g } from "./create.js";
+const l = {
+  size: new c(1, 1, 1),
+  position: new c(0, 0, 0),
+  collision: {
+    static: !1
+  },
+  material: {
+    color: new d("#ffffff"),
+    shader: "standard"
+  },
+  images: [],
+  animations: []
+};
+class C extends z {
+  collider(t) {
+    const i = t.collisionSize || t.size || new c(1, 1, 1), e = { x: i.x / 2, y: i.y / 2, z: i.z / 2 };
+    return h.cuboid(e.x, e.y, e.z);
+  }
+}
+class T extends E {
+  createEntity(t) {
+    return new p(t);
+  }
+}
+const b = Symbol("Sprite");
+class p extends w {
+  static type = b;
+  sprites = [];
+  spriteMap = /* @__PURE__ */ new Map();
+  currentSpriteIndex = 0;
+  animations = /* @__PURE__ */ new Map();
+  currentAnimation = null;
+  currentAnimationFrame = "";
+  currentAnimationIndex = 0;
+  currentAnimationTime = 0;
+  constructor(t) {
+    super(), this.options = { ...l, ...t }, this.createSpritesFromImages(t?.images || []), this.createAnimations(t?.animations || []), this.lifeCycleDelegate = {
+      update: [this.spriteUpdate.bind(this)],
+      destroy: [this.spriteDestroy.bind(this)]
+    };
+  }
+  createSpritesFromImages(t) {
+    const i = new f();
+    t.forEach((e, n) => {
+      const r = i.load(e.file), s = new y({
+        map: r,
+        transparent: !0
+      }), a = new A(s);
+      a.position.normalize(), this.sprites.push(a), this.spriteMap.set(e.name, n);
+    }), this.group = new x(), this.group.add(...this.sprites);
+  }
+  createAnimations(t) {
+    t.forEach((i) => {
+      const { name: e, frames: n, loop: r = !1, speed: s = 1 } = i, a = {
+        frames: n.map((u, m) => ({
+          key: u,
+          index: m,
+          time: (typeof s == "number" ? s : s[m]) * (m + 1),
+          duration: typeof s == "number" ? s : s[m]
+        })),
+        loop: r
+      };
+      this.animations.set(e, a);
+    });
+  }
+  setSprite(t) {
+    const e = this.spriteMap.get(t) ?? 0;
+    this.currentSpriteIndex = e, this.sprites.forEach((n, r) => {
+      n.visible = this.currentSpriteIndex === r;
+    });
+  }
+  setAnimation(t, i) {
+    const e = this.animations.get(t);
+    if (!e)
+      return;
+    const { loop: n, frames: r } = e, s = r[this.currentAnimationIndex];
+    t === this.currentAnimation ? (this.currentAnimationFrame = s.key, this.currentAnimationTime += i, this.setSprite(this.currentAnimationFrame)) : this.currentAnimation = t, this.currentAnimationTime > s.time && this.currentAnimationIndex++, this.currentAnimationIndex >= r.length && (n ? (this.currentAnimationIndex = 0, this.currentAnimationTime = 0) : this.currentAnimationTime = r[this.currentAnimationIndex].time);
+  }
+  async spriteUpdate(t) {
+    this.sprites.forEach((i) => {
+      if (i.material) {
+        const e = this.body?.rotation();
+        if (e) {
+          const n = new S(e.x, e.y, e.z, e.w), r = new I().setFromQuaternion(n, "XYZ");
+          i.material.rotation = r.z;
+        }
+        i.scale.set(this.options.size?.x ?? 1, this.options.size?.y ?? 1, this.options.size?.z ?? 1);
+      }
+    });
+  }
+  async spriteDestroy(t) {
+    this.sprites.forEach((i) => {
+      i.removeFromParent();
+    }), this.group?.remove(...this.sprites), this.group?.removeFromParent();
+  }
+}
+async function P(...o) {
+  return g({
+    args: o,
+    defaultConfig: l,
+    EntityClass: p,
+    BuilderClass: T,
+    CollisionBuilderClass: C,
+    entityType: p.type
+  });
+}
+export {
+  b as SPRITE_TYPE,
+  T as SpriteBuilder,
+  C as SpriteCollisionBuilder,
+  p as ZylemSprite,
+  P as sprite
+};

package/dist/lib/entities/text.js

@@ -0,0 +1,111 @@
+import { Vector2 as u, Group as H, CanvasTexture as w, LinearFilter as l, SpriteMaterial as k, Sprite as M, ClampToEdgeWrapping as C, Color as v } from "three";
+import { GameEntity as R } from "./entity.js";
+import { EntityBuilder as W } from "./builder.js";
+import { createEntity as E } from "./create.js";
+import { DebugDelegate as D } from "./delegates/debug.js";
+const x = {
+  position: void 0,
+  text: "",
+  fontFamily: 'Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',
+  fontSize: 18,
+  fontColor: "#FFFFFF",
+  backgroundColor: null,
+  padding: 4,
+  stickToViewport: !0,
+  screenPosition: new u(24, 24),
+  zDistance: 1
+};
+class P extends W {
+  createEntity(t) {
+    return new o(t);
+  }
+}
+const z = Symbol("Text");
+class o extends R {
+  static type = z;
+  _sprite = null;
+  _texture = null;
+  _canvas = null;
+  _ctx = null;
+  _cameraRef = null;
+  _lastCanvasW = 0;
+  _lastCanvasH = 0;
+  constructor(t) {
+    super(), this.options = { ...x, ...t }, this.group = new H(), this.createSprite(), this.lifeCycleDelegate = {
+      setup: [this.textSetup.bind(this)],
+      update: [this.textUpdate.bind(this)]
+    };
+  }
+  createSprite() {
+    this._canvas = document.createElement("canvas"), this._ctx = this._canvas.getContext("2d"), this._texture = new w(this._canvas), this._texture.minFilter = l, this._texture.magFilter = l;
+    const t = new k({
+      map: this._texture,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1,
+      alphaTest: 0.5
+    });
+    this._sprite = new M(t), this.group?.add(this._sprite), this.redrawText(this.options.text ?? "");
+  }
+  redrawText(t) {
+    if (!this._canvas || !this._ctx)
+      return;
+    const e = this.options.fontSize ?? 18, r = this.options.fontFamily ?? x.fontFamily, a = this.options.padding ?? 4;
+    this._ctx.font = `${e}px ${r}`;
+    const p = this._ctx.measureText(t), _ = Math.ceil(p.width), h = Math.ceil(e * 1.4), n = Math.max(2, _ + a * 2), s = Math.max(2, h + a * 2), f = n !== this._lastCanvasW || s !== this._lastCanvasH;
+    this._canvas.width = n, this._canvas.height = s, this._lastCanvasW = n, this._lastCanvasH = s, this._ctx.font = `${e}px ${r}`, this._ctx.textBaseline = "top", this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height), this.options.backgroundColor && (this._ctx.fillStyle = this.toCssColor(this.options.backgroundColor), this._ctx.fillRect(0, 0, this._canvas.width, this._canvas.height)), this._ctx.fillStyle = this.toCssColor(this.options.fontColor ?? "#FFFFFF"), this._ctx.fillText(t, a, a), this._texture && (f && (this._texture.dispose(), this._texture = new w(this._canvas), this._texture.minFilter = l, this._texture.magFilter = l, this._texture.wrapS = C, this._texture.wrapT = C), this._texture.image = this._canvas, this._texture.needsUpdate = !0, this._sprite && this._sprite.material && (this._sprite.material.map = this._texture, this._sprite.material.needsUpdate = !0));
+  }
+  toCssColor(t) {
+    return typeof t == "string" ? t : `#${(t instanceof v ? t : new v(t)).getHexString()}`;
+  }
+  textSetup(t) {
+    this._cameraRef = t.camera, this.options.stickToViewport && this._cameraRef && this._cameraRef.camera.add(this.group);
+  }
+  textUpdate(t) {
+    this._sprite && this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  updateStickyTransform() {
+    if (!this._sprite || !this._cameraRef)
+      return;
+    const t = this._cameraRef.camera, e = this._cameraRef.renderer.domElement, r = e.clientWidth, a = e.clientHeight, p = (this.options.screenPosition ?? new u(24, 24)).x, _ = (this.options.screenPosition ?? new u(24, 24)).y, h = Math.max(1e-3, this.options.zDistance ?? 1);
+    let n = 1, s = 1;
+    if (t.isPerspectiveCamera) {
+      const i = t, c = Math.tan(i.fov * Math.PI / 180 / 2) * h;
+      n = c * i.aspect, s = c;
+    } else if (t.isOrthographicCamera) {
+      const i = t;
+      n = (i.right - i.left) / 2, s = (i.top - i.bottom) / 2;
+    }
+    const f = p / r * 2 - 1, y = 1 - _ / a * 2, T = f * n, F = y * s;
+    if (this.group?.position.set(T, F, -h), this._canvas) {
+      const c = s * 2 / a, m = this._canvas.height, g = Math.max(1e-4, m * c), S = this._canvas.width / this._canvas.height, b = g * S;
+      this._sprite.scale.set(b, g, 1);
+    }
+  }
+  updateText(t) {
+    this.options.text = t, this.redrawText(t), this.options.stickToViewport && this._cameraRef && this.updateStickyTransform();
+  }
+  buildInfo() {
+    return {
+      ...new D(this).buildDebugInfo(),
+      type: String(o.type),
+      text: this.options.text ?? "",
+      sticky: this.options.stickToViewport
+    };
+  }
+}
+async function X(...d) {
+  return E({
+    args: d,
+    defaultConfig: { ...x },
+    EntityClass: o,
+    BuilderClass: P,
+    entityType: o.type
+  });
+}
+export {
+  z as TEXT_TYPE,
+  P as TextBuilder,
+  o as ZylemText,
+  X as text
+};

package/dist/lib/entities/zone.js

@@ -0,0 +1,103 @@
+import { ColliderDesc as a, ActiveCollisionTypes as h } from "@dimforge/rapier3d-compat";
+import { Vector3 as l } from "three";
+import { GameEntity as u } from "./entity.js";
+import { EntityCollisionBuilder as c, EntityBuilder as p } from "./builder.js";
+import { createEntity as E } from "./create.js";
+import { state as o } from "../game/game-state.js";
+const d = {
+  size: new l(1, 1, 1),
+  position: new l(0, 0, 0),
+  collision: {
+    static: !0
+  },
+  material: {
+    shader: "standard"
+  }
+};
+class f extends c {
+  collider(e) {
+    const t = e.size || new l(1, 1, 1), i = { x: t.x / 2, y: t.y / 2, z: t.z / 2 };
+    let s = a.cuboid(i.x, i.y, i.z);
+    return s.setSensor(!0), s.activeCollisionTypes = h.KINEMATIC_FIXED, s;
+  }
+}
+class x extends p {
+  createEntity(e) {
+    return new r(e);
+  }
+}
+const Z = Symbol("Zone");
+class r extends u {
+  static type = Z;
+  _enteredZone = /* @__PURE__ */ new Map();
+  _exitedZone = /* @__PURE__ */ new Map();
+  _zoneEntities = /* @__PURE__ */ new Map();
+  constructor(e) {
+    super(), this.options = { ...d, ...e };
+  }
+  handlePostCollision({ delta: e }) {
+    return this._enteredZone.forEach((t, i) => {
+      this.exited(e, i);
+    }), this._enteredZone.size > 0;
+  }
+  handleIntersectionEvent({ other: e, delta: t }) {
+    this._enteredZone.get(e.uuid) ? this.held(t, e) : (this.entered(e), this._zoneEntities.set(e.uuid, e));
+  }
+  onEnter(e) {
+    return this.options.onEnter = e, this;
+  }
+  onHeld(e) {
+    return this.options.onHeld = e, this;
+  }
+  onExit(e) {
+    return this.options.onExit = e, this;
+  }
+  entered(e) {
+    this._enteredZone.set(e.uuid, 1), this.options.onEnter && this.options.onEnter({
+      self: this,
+      visitor: e,
+      globals: o.globals
+    });
+  }
+  exited(e, t) {
+    const i = this._exitedZone.get(t);
+    if (i && i > 1 + e) {
+      this._exitedZone.delete(t), this._enteredZone.delete(t);
+      const s = this._zoneEntities.get(t);
+      this.options.onExit && this.options.onExit({
+        self: this,
+        visitor: s,
+        globals: o.globals
+      });
+      return;
+    }
+    this._exitedZone.set(t, 1 + e);
+  }
+  held(e, t) {
+    const i = this._enteredZone.get(t.uuid) ?? 0;
+    this._enteredZone.set(t.uuid, i + e), this._exitedZone.set(t.uuid, 1), this.options.onHeld && this.options.onHeld({
+      delta: e,
+      self: this,
+      visitor: t,
+      globals: o.globals,
+      heldTime: i
+    });
+  }
+}
+async function b(...n) {
+  return E({
+    args: n,
+    defaultConfig: d,
+    EntityClass: r,
+    BuilderClass: x,
+    CollisionBuilderClass: f,
+    entityType: r.type
+  });
+}
+export {
+  Z as ZONE_TYPE,
+  x as ZoneBuilder,
+  f as ZoneCollisionBuilder,
+  r as ZylemZone,
+  b as zone
+};

package/dist/lib/game/game-state.js

@@ -0,0 +1,17 @@
+import { proxy as a } from "valtio/vanilla";
+const o = a({
+  id: "",
+  globals: {},
+  time: 0
+});
+function r(t, l) {
+  o.globals[t] = l;
+}
+function i(t) {
+  return t !== void 0 ? o.globals[t] : o.globals;
+}
+export {
+  i as getGlobalState,
+  r as setGlobalState,
+  o as state
+};