@zylem/game-lib 0.3.15 → 0.3.17

package/dist/actions.js

@@ -0,0 +1,10 @@
+import * as o from "./lib/actions/behaviors/actions.js";
+import { makeMoveable as a } from "./lib/actions/capabilities/moveable.js";
+import { makeRotatable as t } from "./lib/actions/capabilities/rotatable.js";
+import { makeTransformable as p } from "./lib/actions/capabilities/transformable.js";
+export {
+  o as actions,
+  a as makeMoveable,
+  t as makeRotatable,
+  p as makeTransformable
+};

package/dist/behaviors.d.ts

@@ -0,0 +1,3 @@
+export { boundary2d } from './lib/actions/behaviors/boundaries/boundary';
+export { ricochet2DInBounds } from './lib/actions/behaviors/ricochet/ricochet-2d-in-bounds';
+export { ricochet2DCollision } from './lib/actions/behaviors/ricochet/ricochet-2d-collision';

package/dist/behaviors.js

@@ -0,0 +1,8 @@
+import { boundary2d as e } from "./lib/actions/behaviors/boundaries/boundary.js";
+import { ricochet2DInBounds as c } from "./lib/actions/behaviors/ricochet/ricochet-2d-in-bounds.js";
+import { ricochet2DCollision as n } from "./lib/actions/behaviors/ricochet/ricochet-2d-collision.js";
+export {
+  e as boundary2d,
+  n as ricochet2DCollision,
+  c as ricochet2DInBounds
+};

package/dist/camera.d.ts

@@ -0,0 +1,3 @@
+export { camera } from './lib/camera/camera';
+export type { PerspectiveType } from './lib/camera/perspective';
+export { Perspectives } from './lib/camera/perspective';

package/dist/camera.js

@@ -0,0 +1,6 @@
+import { camera as o } from "./lib/camera/camera.js";
+import { Perspectives as p } from "./lib/camera/perspective.js";
+export {
+  p as Perspectives,
+  o as camera
+};

package/dist/core.d.ts

@@ -0,0 +1,5 @@
+export { game } from './lib/game/game';
+export type { ZylemGameConfig } from './lib/game/game-interfaces';
+export { vessel } from './lib/core/vessel';
+export type { Vect3 } from './lib/core/utility/vector';
+export { globalChange, globalChanges, variableChange, variableChanges } from './lib/actions/global-change';

package/dist/core.js

@@ -0,0 +1,11 @@
+import { game as o } from "./lib/game/game.js";
+import { vessel as g } from "./lib/core/vessel.js";
+import { globalChange as b, globalChanges as h, variableChange as m, variableChanges as n } from "./lib/actions/global-change.js";
+export {
+  o as game,
+  b as globalChange,
+  h as globalChanges,
+  m as variableChange,
+  n as variableChanges,
+  g as vessel
+};

package/dist/entities.d.ts

@@ -0,0 +1,8 @@
+export { box, ZylemBox } from './lib/entities/box';
+export { sphere } from './lib/entities/sphere';
+export { sprite } from './lib/entities/sprite';
+export { plane } from './lib/entities/plane';
+export { zone } from './lib/entities/zone';
+export { actor } from './lib/entities/actor';
+export { text } from './lib/entities/text';
+export { rect } from './lib/entities/rect';

package/dist/entities.js

@@ -0,0 +1,19 @@
+import { ZylemBox as e, box as t } from "./lib/entities/box.js";
+import { sphere as x } from "./lib/entities/sphere.js";
+import { sprite as f } from "./lib/entities/sprite.js";
+import { plane as c } from "./lib/entities/plane.js";
+import { zone as n } from "./lib/entities/zone.js";
+import { actor as b } from "./lib/entities/actor.js";
+import { text as i } from "./lib/entities/text.js";
+import { rect as z } from "./lib/entities/rect.js";
+export {
+  e as ZylemBox,
+  b as actor,
+  t as box,
+  c as plane,
+  z as rect,
+  x as sphere,
+  f as sprite,
+  i as text,
+  n as zone
+};

package/dist/lib/actions/behaviors/actions.js

@@ -0,0 +1,35 @@
+function s(t, e) {
+  setTimeout(e, t);
+}
+const c = /* @__PURE__ */ (() => {
+  let t = !1;
+  return (e, n) => {
+    e && !t ? (t = !0, n()) : e || (t = !1);
+  };
+})(), u = /* @__PURE__ */ (() => {
+  let t = !1;
+  return (e, n) => {
+    !e && t ? (t = !1, n()) : e && (t = !0);
+  };
+})(), f = /* @__PURE__ */ (() => {
+  let t = -1 / 0, e = !1;
+  return ({ timer: n, immediate: o = !0 }, l, r) => {
+    let i = Date.now();
+    !e && !o && (e = !0, t = i);
+    const a = i - t;
+    a >= n && (t = i, l()), r({ delta: a });
+  };
+})(), m = /* @__PURE__ */ (() => {
+  let t = 0;
+  return (e, n) => {
+    const o = Date.now();
+    o - t >= e && (t = o, n());
+  };
+})();
+export {
+  c as actionOnPress,
+  u as actionOnRelease,
+  f as actionWithCooldown,
+  m as actionWithThrottle,
+  s as wait
+};

package/dist/lib/actions/behaviors/boundaries/boundary.d.ts

@@ -27,7 +27,7 @@ export interface BoundaryOptions {
  * @param options.stopMovement Whether to stop the entity's movement when it hits a boundary
  * @returns A behavior callback with type 'update' and a handler function
  */
-export declare function boundary(options?: Partial<BoundaryOptions>): {
+export declare function boundary2d(options?: Partial<BoundaryOptions>): {
     type: BehaviorCallbackType;
     handler: (ctx: UpdateContext<MoveableEntity>) => void;
 };

package/dist/lib/actions/behaviors/boundaries/boundary.js

@@ -0,0 +1,40 @@
+const y = {
+  boundaries: {
+    top: 0,
+    bottom: 0,
+    left: 0,
+    right: 0
+  },
+  stopMovement: !0
+};
+function d(i = {}) {
+  return {
+    type: "update",
+    handler: (n) => {
+      a(n, i);
+    }
+  };
+}
+function a(i, n) {
+  const { me: r } = i, { boundaries: s, onBoundary: u } = {
+    ...y,
+    ...n
+  }, e = r.getPosition();
+  if (!e)
+    return;
+  let t = { top: !1, bottom: !1, left: !1, right: !1 };
+  if (e.x <= s.left ? t.left = !0 : e.x >= s.right && (t.right = !0), e.y <= s.bottom ? t.bottom = !0 : e.y >= s.top && (t.top = !0), (n.stopMovement ?? !0) && t) {
+    const o = r.getVelocity() ?? { x: 0, y: 0 };
+    let { x: f, y: l } = o;
+    (o?.y < 0 && t.bottom || o?.y > 0 && t.top) && (l = 0), (o?.x < 0 && t.left || o?.x > 0 && t.right) && (f = 0), r.moveXY(f, l);
+  }
+  u && t && u({
+    me: r,
+    boundary: t,
+    position: { x: e.x, y: e.y, z: e.z },
+    updateContext: i
+  });
+}
+export {
+  d as boundary2d
+};

package/dist/lib/actions/behaviors/ricochet/ricochet-2d-collision.js

@@ -0,0 +1,100 @@
+import { matchesCollisionSelector as T } from "../../../collision/utils.js";
+import { clamp as E } from "./ricochet.js";
+function tt(O = {}, b) {
+  return {
+    type: "collision",
+    handler: (D) => {
+      Z(D, O, b);
+    }
+  };
+}
+function Z(O, b, D) {
+  const { entity: K, other: y } = O, f = K;
+  if (y.collider?.isSensor())
+    return;
+  const { minSpeed: C = 2, maxSpeed: H = 20, separation: U = 0, collisionWith: L = void 0 } = {
+    ...b
+  }, I = b?.reflectionMode ?? "angled", W = b?.maxAngleDeg ?? 60, _ = b?.speedUpFactor ?? 1.05, j = b?.minOffsetForAngle ?? 0.15, G = b?.centerRetentionFactor ?? 0.5;
+  if (!T(y, L))
+    return;
+  const i = f.getPosition(), X = y.body?.translation(), e = f.getVelocity();
+  if (!i || !X || !e)
+    return;
+  let c = e.x, o = e.y, Y = i.x, P = i.y;
+  const p = i.x - X.x, m = i.y - X.y;
+  let n = null, s = null;
+  const u = y.collider?.shape;
+  if (u && (u.halfExtents && (n = Math.abs(u.halfExtents.x ?? u.halfExtents[0] ?? null), s = Math.abs(u.halfExtents.y ?? u.halfExtents[1] ?? null)), (n == null || s == null) && typeof u.radius == "number" && (n = n ?? Math.abs(u.radius), s = s ?? Math.abs(u.radius))), (n == null || s == null) && typeof y.collider?.halfExtents == "function") {
+    const t = y.collider.halfExtents();
+    t && (n = n ?? Math.abs(t.x), s = s ?? Math.abs(t.y));
+  }
+  if ((n == null || s == null) && typeof y.collider?.radius == "function") {
+    const t = y.collider.radius();
+    typeof t == "number" && (n = n ?? Math.abs(t), s = s ?? Math.abs(t));
+  }
+  let q = 0, z = 0;
+  n && s ? (q = E(p / n, -1, 1), z = E(m / s, -1, 1)) : (q = Math.sign(p), z = Math.sign(m));
+  let J = Math.abs(m) >= Math.abs(p), a = null, l = null;
+  const M = f.collider?.shape;
+  if (M && (M.halfExtents && (a = Math.abs(M.halfExtents.x ?? M.halfExtents[0] ?? null), l = Math.abs(M.halfExtents.y ?? M.halfExtents[1] ?? null)), (a == null || l == null) && typeof M.radius == "number" && (a = a ?? Math.abs(M.radius), l = l ?? Math.abs(M.radius))), (a == null || l == null) && typeof f.collider?.halfExtents == "function") {
+    const t = f.collider.halfExtents();
+    t && (a = a ?? Math.abs(t.x), l = l ?? Math.abs(t.y));
+  }
+  if ((a == null || l == null) && typeof f.collider?.radius == "function") {
+    const t = f.collider.radius();
+    typeof t == "number" && (a = a ?? Math.abs(t), l = l ?? Math.abs(t));
+  }
+  if (n != null && s != null && a != null && l != null) {
+    const t = a + n - Math.abs(p), r = l + s - Math.abs(m);
+    !Number.isNaN(t) && !Number.isNaN(r) && (J = r <= t);
+  }
+  let F = !1;
+  if (J) {
+    const t = (s ?? 0) + (l ?? 0) + U;
+    if (P = X.y + (m > 0 ? t : -t), Y = i.x, n != null && s != null && n > s && I === "angled") {
+      const v = W * Math.PI / 180, g = Math.max(0, Math.min(1, j)), N = E(q, -1, 1), V = Math.abs(N), S = Math.sqrt(e.x * e.x + e.y * e.y), h = E(S * _, C, H);
+      if (V > g) {
+        const d = (V - g) / (1 - g), x = Math.sign(N) * (d * v), A = Math.cos(x), w = Math.sin(x), B = Math.abs(h * A), Q = h * w;
+        o = m > 0 ? B : -B, c = Q;
+      } else {
+        const d = e.x * G, x = Math.max(0, h * h - d * d), A = Math.sqrt(x);
+        o = m > 0 ? A : -A, c = d;
+      }
+      F = !0;
+    } else
+      o = m > 0 ? Math.abs(e.y) : -Math.abs(e.y), I === "simple" && (F = !0);
+  } else {
+    const t = (n ?? 0) + (a ?? 0) + U;
+    if (Y = X.x + (p > 0 ? t : -t), P = i.y, I === "angled") {
+      const r = W * Math.PI / 180, v = Math.max(0, Math.min(1, j)), g = E(z, -1, 1), N = Math.abs(g), V = Math.sqrt(e.x * e.x + e.y * e.y), S = E(V * _, C, H);
+      if (N > v) {
+        const h = (N - v) / (1 - v), d = Math.sign(g) * (h * r), x = Math.cos(d), A = Math.sin(d), w = Math.abs(S * x), B = S * A;
+        c = p > 0 ? w : -w, o = B;
+      } else {
+        const h = e.y * G, d = Math.max(0, S * S - h * h), x = Math.sqrt(d);
+        c = p > 0 ? x : -x, o = h;
+      }
+      F = !0;
+    } else
+      c = p > 0 ? Math.abs(e.x) : -Math.abs(e.x), o = e.y, F = !0;
+  }
+  if (!F) {
+    const t = Math.abs(c), r = Math.abs(o), v = Math.sign(q) * Math.abs(q) * t, g = Math.sign(z) * Math.abs(z) * r;
+    c += v, o += g;
+  }
+  const R = Math.sqrt(c * c + o * o);
+  if (R > 0) {
+    const t = E(R, C, H);
+    if (t !== R) {
+      const r = t / R;
+      c *= r, o *= r;
+    }
+  }
+  (Y !== i.x || P !== i.y) && (f.setPosition(Y, P, i.z), f.moveXY(c, o), D && f.getVelocity() && D({
+    position: { x: Y, y: P, z: i.z },
+    ...O
+  }));
+}
+export {
+  tt as ricochet2DCollision
+};

package/dist/lib/actions/behaviors/ricochet/ricochet-2d-in-bounds.js

@@ -0,0 +1,37 @@
+import { clamp as g } from "./ricochet.js";
+function w(a = {}, u) {
+  return {
+    type: "update",
+    handler: (y) => {
+      M(y, a, u);
+    }
+  };
+}
+function M(a, u, y) {
+  const { me: r } = a, { restitution: d = 0, minSpeed: b = 2, maxSpeed: x = 20, boundaries: e = { top: 5, bottom: -5, left: -6.5, right: 6.5 }, separation: p = 0 } = { ...u }, t = r.getPosition(), o = r.getVelocity();
+  if (!t || !o)
+    return;
+  let i = o.x, n = o.y, c = t.x, l = t.y, s = null;
+  t.x <= e.left ? (i = Math.abs(o.x), c = e.left + p, s = "left") : t.x >= e.right && (i = -Math.abs(o.x), c = e.right - p, s = "right"), t.y <= e.bottom ? (n = Math.abs(o.y), l = e.bottom + p, s = "bottom") : t.y >= e.top && (n = -Math.abs(o.y), l = e.top - p, s = "top");
+  const h = Math.sqrt(i * i + n * n);
+  if (h > 0) {
+    const f = g(h, b, x);
+    if (f !== h) {
+      const m = f / h;
+      i *= m, n *= m;
+    }
+  }
+  if (d && (i *= d, n *= d), (c !== t.x || l !== t.y) && (r.setPosition(c, l, t.z), r.moveXY(i, n), y && s)) {
+    const f = r.getVelocity();
+    f && y({
+      boundary: s,
+      position: { x: c, y: l, z: t.z },
+      velocityBefore: o,
+      velocityAfter: f,
+      ...a
+    });
+  }
+}
+export {
+  w as ricochet2DInBounds
+};

package/dist/lib/actions/behaviors/ricochet/ricochet.d.ts

@@ -39,3 +39,5 @@ export interface Ricochet2DCollisionOptions {
 export type Ricochet2DCallback = (event: RicochetEvent) => void;
 export type Ricochet2DCollisionCallback = (event: RicochetCollisionEvent) => void;
 export declare function clamp(value: number, min: number, max: number): number;
+export { ricochet2DInBounds } from './ricochet-2d-in-bounds';
+export { ricochet2DCollision } from './ricochet-2d-collision';

package/dist/lib/actions/behaviors/ricochet/ricochet.js

@@ -0,0 +1,6 @@
+function m(t, a, n) {
+  return Math.max(a, Math.min(n, t));
+}
+export {
+  m as clamp
+};

package/dist/lib/actions/capabilities/moveable.js

@@ -0,0 +1,108 @@
+import { Vector3 as l } from "three";
+function b(o, e) {
+  if (!o.body)
+    return;
+  const n = o.body.linvel(), r = new l(e, n.y, n.z);
+  o.body.setLinvel(r, !0);
+}
+function y(o, e) {
+  if (!o.body)
+    return;
+  const n = o.body.linvel(), r = new l(n.x, e, n.z);
+  o.body.setLinvel(r, !0);
+}
+function m(o, e) {
+  if (!o.body)
+    return;
+  const n = o.body.linvel(), r = new l(n.x, n.y, e);
+  o.body.setLinvel(r, !0);
+}
+function w(o, e, n) {
+  if (!o.body)
+    return;
+  const r = o.body.linvel(), c = new l(e, n, r.z);
+  o.body.setLinvel(c, !0);
+}
+function V(o, e, n) {
+  if (!o.body)
+    return;
+  const r = o.body.linvel(), c = new l(e, r.y, n);
+  o.body.setLinvel(c, !0);
+}
+function P(o, e) {
+  if (!o.body)
+    return;
+  const n = o.body.linvel(), r = new l(n.x + e.x, n.y + e.y, n.z + e.z);
+  o.body.setLinvel(r, !0);
+}
+function p(o) {
+  o.body && (o.body.setLinvel(new l(0, 0, 0), !0), o.body.setLinearDamping(5));
+}
+function x(o, e, n) {
+  const r = Math.sin(-n) * e, c = Math.cos(-n) * e;
+  w(o, r, c);
+}
+function u(o) {
+  return o.body ? o.body.translation() : null;
+}
+function X(o) {
+  return o.body ? o.body.linvel() : null;
+}
+function f(o, e, n, r) {
+  o.body && o.body.setTranslation({ x: e, y: n, z: r }, !0);
+}
+function z(o, e) {
+  if (!o.body)
+    return;
+  const { y: n, z: r } = o.body.translation();
+  o.body.setTranslation({ x: e, y: n, z: r }, !0);
+}
+function L(o, e) {
+  if (!o.body)
+    return;
+  const { x: n, z: r } = o.body.translation();
+  o.body.setTranslation({ x: n, y: e, z: r }, !0);
+}
+function Y(o, e) {
+  if (!o.body)
+    return;
+  const { x: n, y: r } = o.body.translation();
+  o.body.setTranslation({ x: n, y: r, z: e }, !0);
+}
+function g(o, e, n) {
+  const r = u(o);
+  if (!r)
+    return;
+  const { x: c, y: t } = r, i = c > e ? -e : c < -e ? e : c, s = t > n ? -n : t < -n ? n : t;
+  (i !== c || s !== t) && f(o, i, s, 0);
+}
+function T(o, e, n, r) {
+  const c = u(o);
+  if (!c)
+    return;
+  const { x: t, y: i, z: s } = c, a = t > e ? -e : t < -e ? e : t, d = i > n ? -n : i < -n ? n : i, v = s > r ? -r : s < -r ? r : s;
+  (a !== t || d !== i || v !== s) && f(o, a, d, v);
+}
+function A(o) {
+  const e = o;
+  return e.moveX = (n) => b(o, n), e.moveY = (n) => y(o, n), e.moveZ = (n) => m(o, n), e.moveXY = (n, r) => w(o, n, r), e.moveXZ = (n, r) => V(o, n, r), e.move = (n) => P(o, n), e.resetVelocity = () => p(o), e.moveForwardXY = (n, r) => x(o, n, r), e.getPosition = () => u(o), e.getVelocity = () => X(o), e.setPosition = (n, r, c) => f(o, n, r, c), e.setPositionX = (n) => z(o, n), e.setPositionY = (n) => L(o, n), e.setPositionZ = (n) => Y(o, n), e.wrapAroundXY = (n, r) => g(o, n, r), e.wrapAround3D = (n, r, c) => T(o, n, r, c), e;
+}
+export {
+  u as getPosition,
+  X as getVelocity,
+  A as makeMoveable,
+  P as move,
+  x as moveForwardXY,
+  b as moveX,
+  w as moveXY,
+  V as moveXZ,
+  y as moveY,
+  m as moveZ,
+  p as resetVelocity,
+  f as setPosition,
+  z as setPositionX,
+  L as setPositionY,
+  Y as setPositionZ,
+  T as wrapAround3D,
+  g as wrapAroundXY
+};

package/dist/lib/actions/capabilities/rotatable.js

@@ -0,0 +1,82 @@
+import { Vector3 as g, Euler as i, MathUtils as a, Quaternion as l } from "three";
+function b(o, t) {
+  if (!o.body)
+    return;
+  const e = Math.atan2(-t.x, t.z);
+  c(o, e);
+}
+function c(o, t) {
+  f(o, new g(0, -t, 0));
+}
+function f(o, t) {
+  if (!o.group)
+    return;
+  const e = new i(t.x, t.y, t.z);
+  o.group.setRotationFromEuler(e);
+}
+function h(o, t) {
+  s(o, t);
+}
+function D(o, t) {
+  u(o, t);
+}
+function s(o, t) {
+  if (!o.body)
+    return;
+  const e = t / 2, r = Math.cos(e), n = Math.sin(e);
+  o.body.setRotation({ w: r, x: 0, y: n, z: 0 }, !0);
+}
+function w(o, t) {
+  o.body && s(o, a.degToRad(t));
+}
+function R(o, t) {
+  if (!o.body)
+    return;
+  const e = t / 2, r = Math.cos(e), n = Math.sin(e);
+  o.body.setRotation({ w: r, x: n, y: 0, z: 0 }, !0);
+}
+function x(o, t) {
+  o.body && R(o, a.degToRad(t));
+}
+function u(o, t) {
+  if (!o.body)
+    return;
+  const e = t / 2, r = Math.cos(e), n = Math.sin(e);
+  o.body.setRotation({ w: r, x: 0, y: 0, z: n }, !0);
+}
+function z(o, t) {
+  o.body && u(o, a.degToRad(t));
+}
+function d(o, t, e, r) {
+  if (!o.body)
+    return;
+  const n = new l().setFromEuler(new i(t, e, r));
+  o.body.setRotation({ w: n.w, x: n.x, y: n.y, z: n.z }, !0);
+}
+function E(o, t, e, r) {
+  o.body && d(o, a.degToRad(t), a.degToRad(e), a.degToRad(r));
+}
+function M(o) {
+  return o.body ? o.body.rotation() : null;
+}
+function m(o) {
+  const t = o;
+  return t.rotateInDirection = (e) => b(o, e), t.rotateYEuler = (e) => c(o, e), t.rotateEuler = (e) => f(o, e), t.rotateY = (e) => h(o, e), t.rotateZ = (e) => D(o, e), t.setRotationY = (e) => s(o, e), t.setRotationX = (e) => R(o, e), t.setRotationZ = (e) => u(o, e), t.setRotationDegreesY = (e) => w(o, e), t.setRotationDegreesX = (e) => x(o, e), t.setRotationDegreesZ = (e) => z(o, e), t.setRotationDegrees = (e, r, n) => E(o, e, r, n), t.setRotation = (e, r, n) => d(o, e, r, n), t.getRotation = () => M(o), t;
+}
+export {
+  M as getRotation,
+  m as makeRotatable,
+  f as rotateEuler,
+  b as rotateInDirection,
+  h as rotateY,
+  c as rotateYEuler,
+  D as rotateZ,
+  d as setRotation,
+  E as setRotationDegrees,
+  x as setRotationDegreesX,
+  w as setRotationDegreesY,
+  z as setRotationDegreesZ,
+  R as setRotationX,
+  s as setRotationY,
+  u as setRotationZ
+};

package/dist/lib/actions/capabilities/transformable.js

@@ -0,0 +1,9 @@
+import { makeMoveable as e } from "./moveable.js";
+import { makeRotatable as a } from "./rotatable.js";
+function i(t) {
+  const o = e(t);
+  return a(o);
+}
+export {
+  i as makeTransformable
+};

package/dist/lib/actions/global-change.js

@@ -0,0 +1,40 @@
+function v(r, l) {
+  let n;
+  return (a) => {
+    const e = a.globals?.[r];
+    n !== e && (n === void 0 && e === void 0 || l(e, a), n = e);
+  };
+}
+function d(r, l) {
+  let n = new Array(r.length).fill(void 0);
+  return (a) => {
+    const e = r.map((t) => a.globals?.[t]);
+    if (e.some((t, o) => n[o] !== t)) {
+      const t = n.every((i) => i === void 0), o = e.every((i) => i === void 0);
+      t && o || l(e, a), n = e;
+    }
+  };
+}
+function f(r, l) {
+  let n;
+  return (a) => {
+    const e = a.stage?.getVariable?.(r) ?? void 0;
+    n !== e && (n === void 0 && e === void 0 || l(e, a), n = e);
+  };
+}
+function g(r, l) {
+  let n = new Array(r.length).fill(void 0);
+  return (a) => {
+    const e = (o) => a.stage?.getVariable?.(o), s = r.map(e);
+    if (s.some((o, i) => n[i] !== o)) {
+      const o = n.every((u) => u === void 0), i = s.every((u) => u === void 0);
+      o && i || l(s, a), n = s;
+    }
+  };
+}
+export {
+  v as globalChange,
+  d as globalChanges,
+  f as variableChange,
+  g as variableChanges
+};

package/dist/lib/camera/camera.js

@@ -0,0 +1,19 @@
+import { Vector2 as c, Vector3 as a } from "three";
+import { ZylemCamera as m } from "./zylem-camera.js";
+class o {
+  cameraRef;
+  constructor(r) {
+    this.cameraRef = r;
+  }
+}
+function w(e) {
+  const r = e.screenResolution || new c(window.innerWidth, window.innerHeight);
+  let n = 10;
+  e.perspective === "fixed-2d" && (n = e.zoom || 10);
+  const t = new m(e.perspective || "third-person", r, n);
+  return t.move(e.position || new a(0, 0, 0)), t.camera.lookAt(e.target || new a(0, 0, 0)), new o(t);
+}
+export {
+  o as CameraWrapper,
+  w as camera
+};

package/dist/lib/camera/fixed-2d.js

@@ -0,0 +1,30 @@
+class c {
+  screenResolution = null;
+  renderer = null;
+  scene = null;
+  cameraRef = null;
+  constructor() {
+  }
+  /**
+   * Setup the fixed 2D camera controller
+   */
+  setup(e) {
+    const { screenResolution: s, renderer: r, scene: t, camera: n } = e;
+    this.screenResolution = s, this.renderer = r, this.scene = t, this.cameraRef = n, this.cameraRef.camera.position.set(0, 0, 10), this.cameraRef.camera.lookAt(0, 0, 0);
+  }
+  /**
+   * Update the fixed 2D camera
+   * Fixed cameras don't need to update position/rotation automatically
+   */
+  update(e) {
+  }
+  /**
+   * Handle resize events for 2D camera
+   */
+  resize(e, s) {
+    this.screenResolution && this.screenResolution.set(e, s);
+  }
+}
+export {
+  c as Fixed2DCamera
+};

package/dist/lib/camera/perspective.js

@@ -0,0 +1,10 @@
+const e = {
+  FirstPerson: "first-person",
+  ThirdPerson: "third-person",
+  Isometric: "isometric",
+  Flat2D: "flat-2d",
+  Fixed2D: "fixed-2d"
+};
+export {
+  e as Perspectives
+};

package/dist/lib/camera/third-person.js

@@ -0,0 +1,42 @@
+import { Vector3 as a } from "three";
+class c {
+  distance;
+  screenResolution = null;
+  renderer = null;
+  scene = null;
+  cameraRef = null;
+  constructor() {
+    this.distance = new a(0, 5, 8);
+  }
+  /**
+   * Setup the third person camera controller
+   */
+  setup(e) {
+    const { screenResolution: t, renderer: s, scene: r, camera: i } = e;
+    this.screenResolution = t, this.renderer = s, this.scene = r, this.cameraRef = i;
+  }
+  /**
+   * Update the third person camera
+   */
+  update(e) {
+    if (!this.cameraRef.target)
+      return;
+    const t = this.cameraRef.target.group.position.clone().add(this.distance);
+    this.cameraRef.camera.position.lerp(t, 0.1), this.cameraRef.camera.lookAt(this.cameraRef.target.group.position);
+  }
+  /**
+   * Handle resize events
+   */
+  resize(e, t) {
+    this.screenResolution && this.screenResolution.set(e, t);
+  }
+  /**
+   * Set the distance from the target
+   */
+  setDistance(e) {
+    this.distance = e;
+  }
+}
+export {
+  c as ThirdPersonCamera
+};