@zylem/game-lib 0.6.2 → 0.6.4

package/dist/actions.js

@@ -1,113 +1,616 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+// src/lib/actions/action.ts
+var BaseAction = class {
+  duration;
+  done = false;
+  persistent = false;
+  elapsed = 0;
+  /** @param durationMs Duration in milliseconds */
+  constructor(durationMs) {
+    this.duration = durationMs / 1e3;
+  }
+  tick(entity, delta) {
+    if (this.done) return;
+    this.elapsed += delta;
+    const progress = this.duration > 0 ? Math.min(this.elapsed / this.duration, 1) : 1;
+    this.onTick(entity, delta, progress);
+    if (this.elapsed >= this.duration) {
+      this.done = true;
+    }
+  }
+  reset() {
+    this.elapsed = 0;
+    this.done = false;
+  }
 };
 
-// src/lib/actions/behaviors/actions.ts
-var actions_exports = {};
-__export(actions_exports, {
-  actionOnPress: () => actionOnPress,
-  actionOnRelease: () => actionOnRelease,
-  actionWithCooldown: () => actionWithCooldown,
-  actionWithThrottle: () => actionWithThrottle,
-  wait: () => wait
-});
-function wait(delay, callback) {
-  setTimeout(callback, delay);
-}
-var actionOnPress = /* @__PURE__ */ (() => {
-  let buttonPressed = false;
-  return (isPressed, callback) => {
-    if (isPressed && !buttonPressed) {
-      buttonPressed = true;
-      callback();
-    } else if (!isPressed) {
-      buttonPressed = false;
-    }
+// src/lib/actions/capabilities/velocity-intents.ts
+function setVelocityIntent(store, sourceId, vector, options = {}) {
+  const prev = store.velocityChannels[sourceId];
+  const mode = options.mode ?? prev?.mode ?? "replace";
+  const priority = options.priority ?? prev?.priority ?? 0;
+  const isAdditiveMerge = mode === "add" && prev?.mode === "add";
+  const x = vector.x == null ? prev?.x : isAdditiveMerge ? (prev?.x ?? 0) + vector.x : vector.x;
+  const y = vector.y == null ? prev?.y : isAdditiveMerge ? (prev?.y ?? 0) + vector.y : vector.y;
+  const z = vector.z == null ? prev?.z : isAdditiveMerge ? (prev?.z ?? 0) + vector.z : vector.z;
+  store.velocityChannels[sourceId] = {
+    x,
+    y,
+    z,
+    mode,
+    priority
   };
-})();
-var actionOnRelease = /* @__PURE__ */ (() => {
-  let buttonPressed = false;
-  return (isPressed, callback) => {
-    if (!isPressed && buttonPressed) {
-      buttonPressed = false;
-      callback();
-    } else if (isPressed) {
-      buttonPressed = true;
+  store.dirty.velocityChannels = true;
+}
+
+// src/lib/actions/interval-actions.ts
+function moveBy(opts) {
+  return new MoveByAction(opts);
+}
+var MoveByAction = class extends BaseAction {
+  dx;
+  dy;
+  dz;
+  constructor(opts) {
+    super(opts.duration);
+    this.dx = opts.x ?? 0;
+    this.dy = opts.y ?? 0;
+    this.dz = opts.z ?? 0;
+  }
+  onTick(entity, delta, _progress) {
+    if (this.duration <= 0) return;
+    const vx = this.dx / this.duration;
+    const vy = this.dy / this.duration;
+    const vz = this.dz / this.duration;
+    const store = entity.transformStore;
+    if (!store) return;
+    setVelocityIntent(store, "actions", { x: vx, y: vy, z: vz }, { mode: "add" });
+  }
+};
+function moveTo(opts) {
+  return new MoveToAction(opts);
+}
+var MoveToAction = class extends BaseAction {
+  targetX;
+  targetY;
+  targetZ;
+  dx = 0;
+  dy = 0;
+  dz = 0;
+  initialized = false;
+  constructor(opts) {
+    super(opts.duration);
+    this.targetX = opts.x;
+    this.targetY = opts.y;
+    this.targetZ = opts.z;
+  }
+  onTick(entity, delta, _progress) {
+    if (this.duration <= 0) return;
+    if (!this.initialized) {
+      const pos = entity.getPosition?.();
+      const cx = pos?.x ?? 0;
+      const cy = pos?.y ?? 0;
+      const cz = pos?.z ?? 0;
+      this.dx = this.targetX - cx;
+      this.dy = this.targetY - cy;
+      this.dz = this.targetZ - cz;
+      this.initialized = true;
     }
-  };
-})();
-var actionWithCooldown = /* @__PURE__ */ (() => {
-  let lastExecutionTime = -Infinity;
-  let flagImmediate = false;
-  return ({ timer, immediate = true }, callback, update) => {
-    let currentTime = Date.now();
-    if (!flagImmediate && !immediate) {
-      flagImmediate = true;
-      lastExecutionTime = currentTime;
+    const vx = this.dx / this.duration;
+    const vy = this.dy / this.duration;
+    const vz = this.dz / this.duration;
+    const store = entity.transformStore;
+    if (!store) return;
+    setVelocityIntent(store, "actions", { x: vx, y: vy, z: vz }, { mode: "add" });
+  }
+  reset() {
+    super.reset();
+    this.initialized = false;
+  }
+};
+function rotateBy(opts) {
+  return new RotateByAction(opts);
+}
+var RotateByAction = class extends BaseAction {
+  rx;
+  ry;
+  rz;
+  constructor(opts) {
+    super(opts.duration);
+    const toRad = Math.PI / 180;
+    this.rx = (opts.x ?? 0) * toRad;
+    this.ry = (opts.y ?? 0) * toRad;
+    this.rz = (opts.z ?? 0) * toRad;
+  }
+  onTick(entity, delta, _progress) {
+    if (this.duration <= 0) return;
+    const wx = this.rx / this.duration;
+    const wy = this.ry / this.duration;
+    const wz = this.rz / this.duration;
+    const store = entity.transformStore;
+    store.angularVelocity.x += wx;
+    store.angularVelocity.y += wy;
+    store.angularVelocity.z += wz;
+    store.dirty.angularVelocity = true;
+  }
+};
+function delay(ms) {
+  return new DelayAction(ms);
+}
+var DelayAction = class extends BaseAction {
+  constructor(ms) {
+    super(ms);
+  }
+  onTick() {
+  }
+};
+function callFunc(fn) {
+  return new CallFuncAction(fn);
+}
+var CallFuncAction = class extends BaseAction {
+  fn;
+  called = false;
+  constructor(fn) {
+    super(0);
+    this.fn = fn;
+  }
+  onTick() {
+    if (!this.called) {
+      this.fn();
+      this.called = true;
+    }
+  }
+  reset() {
+    super.reset();
+    this.called = false;
+  }
+};
+
+// src/lib/actions/persistent-actions.ts
+function throttle(opts) {
+  return new ThrottleAction(opts.duration);
+}
+var ThrottleAction = class {
+  duration;
+  done = false;
+  persistent = true;
+  ready = false;
+  elapsed = 0;
+  /** @param durationMs Duration in milliseconds */
+  constructor(durationMs) {
+    this.duration = durationMs / 1e3;
+  }
+  tick(_entity, delta) {
+    this.elapsed += delta;
+    if (this.elapsed >= this.duration) {
+      this.ready = true;
+    }
+  }
+  /** Consume the ready state and reset the timer */
+  consume() {
+    this.ready = false;
+    this.elapsed = 0;
+  }
+  reset() {
+    this.elapsed = 0;
+    this.ready = false;
+  }
+};
+function onPress() {
+  return new OnPressAction();
+}
+var OnPressAction = class {
+  duration = Infinity;
+  done = false;
+  persistent = true;
+  triggered = false;
+  wasPressed = false;
+  tick() {
+    this.triggered = false;
+  }
+  /**
+   * Feed the current pressed state. Sets `.triggered = true` on the
+   * frame where `isPressed` transitions from false to true.
+   */
+  check(isPressed) {
+    if (isPressed && !this.wasPressed) {
+      this.triggered = true;
+    }
+    this.wasPressed = isPressed;
+  }
+  reset() {
+    this.triggered = false;
+    this.wasPressed = false;
+  }
+};
+function onRelease() {
+  return new OnReleaseAction();
+}
+var OnReleaseAction = class {
+  duration = Infinity;
+  done = false;
+  persistent = true;
+  triggered = false;
+  wasPressed = false;
+  tick() {
+    this.triggered = false;
+  }
+  /**
+   * Feed the current pressed state. Sets `.triggered = true` on the
+   * frame where `isPressed` transitions from true to false.
+   */
+  check(isPressed) {
+    if (!isPressed && this.wasPressed) {
+      this.triggered = true;
+    }
+    this.wasPressed = isPressed;
+  }
+  reset() {
+    this.triggered = false;
+    this.wasPressed = false;
+  }
+};
+
+// src/lib/actions/composition.ts
+function sequence(...actions) {
+  return new SequenceAction(actions);
+}
+var SequenceAction = class {
+  duration;
+  done = false;
+  persistent = false;
+  actions;
+  currentIndex = 0;
+  constructor(actions) {
+    this.actions = actions;
+    this.duration = actions.reduce((sum, a) => sum + a.duration, 0);
+  }
+  tick(entity, delta) {
+    if (this.done || this.actions.length === 0) {
+      this.done = true;
+      return;
+    }
+    let remaining = delta;
+    while (remaining > 0 && this.currentIndex < this.actions.length) {
+      const current = this.actions[this.currentIndex];
+      current.tick(entity, remaining);
+      if (current.done) {
+        const actionDuration = current.duration;
+        const actionElapsed = current.elapsed ?? actionDuration;
+        const overflow = Math.max(0, actionElapsed - actionDuration);
+        remaining = overflow;
+        this.currentIndex++;
+      } else {
+        remaining = 0;
+      }
+    }
+    if (this.currentIndex >= this.actions.length) {
+      this.done = true;
+    }
+  }
+  reset() {
+    this.currentIndex = 0;
+    this.done = false;
+    for (const action of this.actions) {
+      action.reset();
+    }
+  }
+};
+function parallel(...actions) {
+  return new ParallelAction(actions);
+}
+var ParallelAction = class {
+  duration;
+  done = false;
+  persistent = false;
+  actions;
+  constructor(actions) {
+    this.actions = actions;
+    this.duration = Math.max(0, ...actions.map((a) => a.duration));
+  }
+  tick(entity, delta) {
+    if (this.done) return;
+    let allDone = true;
+    for (const action of this.actions) {
+      if (!action.done) {
+        action.tick(entity, delta);
+      }
+      if (!action.done) {
+        allDone = false;
+      }
+    }
+    if (allDone) {
+      this.done = true;
+    }
+  }
+  reset() {
+    this.done = false;
+    for (const action of this.actions) {
+      action.reset();
+    }
+  }
+};
+function repeat(action, times) {
+  return new RepeatAction(action, times);
+}
+var RepeatAction = class {
+  duration;
+  done = false;
+  persistent = false;
+  action;
+  totalTimes;
+  currentCount = 0;
+  constructor(action, times) {
+    this.action = action;
+    this.totalTimes = times;
+    this.duration = action.duration * times;
+  }
+  tick(entity, delta) {
+    if (this.done) return;
+    this.action.tick(entity, delta);
+    if (this.action.done) {
+      this.currentCount++;
+      if (this.currentCount >= this.totalTimes) {
+        this.done = true;
+      } else {
+        this.action.reset();
+      }
     }
-    const delta = currentTime - lastExecutionTime;
-    if (delta >= timer) {
-      lastExecutionTime = currentTime;
-      callback();
+  }
+  reset() {
+    this.currentCount = 0;
+    this.done = false;
+    this.action.reset();
+  }
+};
+function repeatForever(action) {
+  return new RepeatForeverAction(action);
+}
+var RepeatForeverAction = class {
+  duration = Infinity;
+  done = false;
+  persistent = false;
+  action;
+  constructor(action) {
+    this.action = action;
+  }
+  tick(entity, delta) {
+    this.action.tick(entity, delta);
+    if (this.action.done) {
+      this.action.reset();
+    }
+  }
+  reset() {
+    this.done = false;
+    this.action.reset();
+  }
+};
+
+// src/lib/actions/capabilities/transform-store.ts
+import { proxy } from "valtio";
+function createTransformStore(initial) {
+  const defaultState = {
+    position: { x: 0, y: 0, z: 0 },
+    rotation: { x: 0, y: 0, z: 0, w: 1 },
+    velocity: { x: 0, y: 0, z: 0 },
+    angularVelocity: { x: 0, y: 0, z: 0 },
+    velocityChannels: {},
+    dirty: {
+      position: false,
+      rotation: false,
+      velocity: false,
+      velocityX: false,
+      velocityY: false,
+      velocityZ: false,
+      velocityChannels: false,
+      angularVelocity: false
     }
-    update({ delta });
   };
-})();
-var actionWithThrottle = /* @__PURE__ */ (() => {
-  let lastExecutionTime = 0;
-  return (timer, callback) => {
-    const currentTime = Date.now();
-    const delta = currentTime - lastExecutionTime;
-    if (delta >= timer) {
-      lastExecutionTime = currentTime;
-      callback();
+  return proxy({
+    ...defaultState,
+    ...initial,
+    // Ensure dirty flags are properly initialized even if partial initial state
+    dirty: {
+      ...defaultState.dirty,
+      ...initial?.dirty
+    }
+  });
+}
+function resetTransformStore(store) {
+  store.position.x = 0;
+  store.position.y = 0;
+  store.position.z = 0;
+  store.rotation.x = 0;
+  store.rotation.y = 0;
+  store.rotation.z = 0;
+  store.rotation.w = 1;
+  store.velocity.x = 0;
+  store.velocity.y = 0;
+  store.velocity.z = 0;
+  store.angularVelocity.x = 0;
+  store.angularVelocity.y = 0;
+  store.angularVelocity.z = 0;
+  for (const sourceId of Object.keys(store.velocityChannels)) {
+    delete store.velocityChannels[sourceId];
+  }
+  store.dirty.position = false;
+  store.dirty.rotation = false;
+  store.dirty.velocity = false;
+  store.dirty.velocityX = false;
+  store.dirty.velocityY = false;
+  store.dirty.velocityZ = false;
+  store.dirty.velocityChannels = false;
+  store.dirty.angularVelocity = false;
+}
+
+// src/lib/actions/capabilities/apply-transform.ts
+function sortIntents(a, b) {
+  if (a.priority !== b.priority) return a.priority - b.priority;
+  return a.sourceId.localeCompare(b.sourceId);
+}
+function composeAxis(current, intents, axis) {
+  let touched = false;
+  let addSum = 0;
+  let hasReplace = false;
+  let replaceValue = current;
+  let replacePriority = Number.NEGATIVE_INFINITY;
+  for (const intent of intents) {
+    const axisValue = intent[axis];
+    if (axisValue == null) continue;
+    touched = true;
+    if (intent.mode === "add") {
+      addSum += axisValue;
+      continue;
+    }
+    if (!hasReplace || intent.priority >= replacePriority) {
+      hasReplace = true;
+      replacePriority = intent.priority;
+      replaceValue = axisValue;
     }
+  }
+  return {
+    touched,
+    value: (hasReplace ? replaceValue : 0) + addSum
+  };
+}
+function composeVelocity(current, intents) {
+  return {
+    x: composeAxis(current.x, intents, "x"),
+    y: composeAxis(current.y, intents, "y"),
+    z: composeAxis(current.z, intents, "z")
   };
-})();
+}
+function clearVelocityChannels(store) {
+  for (const sourceId in store.velocityChannels) {
+    delete store.velocityChannels[sourceId];
+  }
+  store.dirty.velocityChannels = false;
+}
+function applyTransformChanges(entity, store) {
+  if (!entity.body) return;
+  const hasPosition = store.dirty.position;
+  const hasRotation = store.dirty.rotation;
+  const hasAngularVelocity = store.dirty.angularVelocity;
+  const hasPerAxis = store.dirty.velocityX || store.dirty.velocityY || store.dirty.velocityZ;
+  const hasLegacyVelocity = store.dirty.velocity;
+  const hasChannels = store.dirty.velocityChannels;
+  if (!hasPosition && !hasRotation && !hasAngularVelocity && !hasPerAxis && !hasLegacyVelocity && !hasChannels) {
+    return;
+  }
+  const intents = [];
+  if (hasChannels) {
+    for (const sourceId in store.velocityChannels) {
+      const intent = store.velocityChannels[sourceId];
+      intents.push({
+        sourceId,
+        mode: intent.mode ?? "replace",
+        priority: intent.priority ?? 0,
+        x: intent.x,
+        y: intent.y,
+        z: intent.z
+      });
+    }
+  }
+  if (hasLegacyVelocity) {
+    intents.push({
+      sourceId: "__legacy_velocity__",
+      mode: "replace",
+      priority: -100,
+      x: store.velocity.x,
+      y: store.velocity.y,
+      z: store.velocity.z
+    });
+  } else if (hasPerAxis) {
+    intents.push({
+      sourceId: "__legacy_per_axis__",
+      mode: "replace",
+      priority: -100,
+      x: store.dirty.velocityX ? store.velocity.x : void 0,
+      y: store.dirty.velocityY ? store.velocity.y : void 0,
+      z: store.dirty.velocityZ ? store.velocity.z : void 0
+    });
+  }
+  if (intents.length > 0) {
+    const current = entity.body.linvel();
+    if (intents.length > 1) {
+      intents.sort(sortIntents);
+    }
+    const composed = composeVelocity(current, intents);
+    entity.body.setLinvel(
+      {
+        x: composed.x.touched ? composed.x.value : current.x,
+        y: composed.y.touched ? composed.y.value : current.y,
+        z: composed.z.touched ? composed.z.value : current.z
+      },
+      true
+    );
+  }
+  if (hasRotation) {
+    entity.body.setRotation(store.rotation, true);
+  }
+  if (hasAngularVelocity) {
+    entity.body.setAngvel(store.angularVelocity, true);
+  }
+  if (hasPosition) {
+    const current = entity.body.translation();
+    entity.body.setTranslation(
+      {
+        x: current.x + store.position.x,
+        y: current.y + store.position.y,
+        z: current.z + store.position.z
+      },
+      true
+    );
+  }
+  store.dirty.position = false;
+  store.dirty.rotation = false;
+  store.dirty.velocity = false;
+  store.dirty.velocityX = false;
+  store.dirty.velocityY = false;
+  store.dirty.velocityZ = false;
+  clearVelocityChannels(store);
+  store.dirty.angularVelocity = false;
+}
 
 // src/lib/actions/capabilities/moveable.ts
 import { Vector3 } from "three";
 function moveX(entity, delta) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(delta, currentVelocity.y, currentVelocity.z);
-  entity.body.setLinvel(newVelocity, true);
+  if (!entity.transformStore) return;
+  setVelocityIntent(entity.transformStore, "actions", { x: delta }, { mode: "replace" });
 }
 function moveY(entity, delta) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(currentVelocity.x, delta, currentVelocity.z);
-  entity.body.setLinvel(newVelocity, true);
+  if (!entity.transformStore) return;
+  setVelocityIntent(entity.transformStore, "actions", { y: delta }, { mode: "replace" });
 }
 function moveZ(entity, delta) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(currentVelocity.x, currentVelocity.y, delta);
-  entity.body.setLinvel(newVelocity, true);
+  if (!entity.transformStore) return;
+  setVelocityIntent(entity.transformStore, "actions", { z: delta }, { mode: "replace" });
 }
 function moveXY(entity, deltaX, deltaY) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(deltaX, deltaY, currentVelocity.z);
-  entity.body.setLinvel(newVelocity, true);
+  if (!entity.transformStore) return;
+  setVelocityIntent(
+    entity.transformStore,
+    "actions",
+    { x: deltaX, y: deltaY },
+    { mode: "replace" }
+  );
 }
 function moveXZ(entity, deltaX, deltaZ) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(deltaX, currentVelocity.y, deltaZ);
-  entity.body.setLinvel(newVelocity, true);
+  if (!entity.transformStore) return;
+  setVelocityIntent(
+    entity.transformStore,
+    "actions",
+    { x: deltaX, z: deltaZ },
+    { mode: "replace" }
+  );
 }
 function move(entity, vector) {
-  if (!entity.body) return;
-  const currentVelocity = entity.body.linvel();
-  const newVelocity = new Vector3(
-    currentVelocity.x + vector.x,
-    currentVelocity.y + vector.y,
-    currentVelocity.z + vector.z
+  if (!entity.transformStore) return;
+  setVelocityIntent(
+    entity.transformStore,
+    "actions",
+    { x: vector.x, y: vector.y, z: vector.z },
+    { mode: "add" }
   );
-  entity.body.setLinvel(newVelocity, true);
 }
 function resetVelocity(entity) {
   if (!entity.body) return;
@@ -167,29 +670,20 @@ function wrapAround3D(entity, boundsX, boundsY, boundsZ) {
     setPosition(entity, newX, newY, newZ);
   }
 }
-function makeMoveable(entity) {
-  const moveable = entity;
-  moveable.moveX = (delta) => moveX(entity, delta);
-  moveable.moveY = (delta) => moveY(entity, delta);
-  moveable.moveZ = (delta) => moveZ(entity, delta);
-  moveable.moveXY = (deltaX, deltaY) => moveXY(entity, deltaX, deltaY);
-  moveable.moveXZ = (deltaX, deltaZ) => moveXZ(entity, deltaX, deltaZ);
-  moveable.move = (vector) => move(entity, vector);
-  moveable.resetVelocity = () => resetVelocity(entity);
-  moveable.moveForwardXY = (delta, rotation2DAngle) => moveForwardXY(entity, delta, rotation2DAngle);
-  moveable.getPosition = () => getPosition(entity);
-  moveable.getVelocity = () => getVelocity(entity);
-  moveable.setPosition = (x, y, z) => setPosition(entity, x, y, z);
-  moveable.setPositionX = (x) => setPositionX(entity, x);
-  moveable.setPositionY = (y) => setPositionY(entity, y);
-  moveable.setPositionZ = (z) => setPositionZ(entity, z);
-  moveable.wrapAroundXY = (boundsX, boundsY) => wrapAroundXY(entity, boundsX, boundsY);
-  moveable.wrapAround3D = (boundsX, boundsY, boundsZ) => wrapAround3D(entity, boundsX, boundsY, boundsZ);
-  return moveable;
-}
 
 // src/lib/actions/capabilities/rotatable.ts
 import { Euler, Vector3 as Vector32, MathUtils, Quaternion } from "three";
+function syncImmediateRotation(entity) {
+  if (!entity.group || !entity.transformStore) return;
+  entity.group.setRotationFromQuaternion(
+    new Quaternion(
+      entity.transformStore.rotation.x,
+      entity.transformStore.rotation.y,
+      entity.transformStore.rotation.z,
+      entity.transformStore.rotation.w
+    )
+  );
+}
 function rotateInDirection(entity, moveVector) {
   if (!entity.body) return;
   const rotate = Math.atan2(-moveVector.x, moveVector.z);
@@ -199,53 +693,128 @@ function rotateYEuler(entity, amount) {
   rotateEuler(entity, new Vector32(0, -amount, 0));
 }
 function rotateEuler(entity, rotation) {
-  if (!entity.group) return;
-  const euler = new Euler(rotation.x, rotation.y, rotation.z);
-  entity.group.setRotationFromEuler(euler);
+  if (!entity.transformStore) return;
+  const quat = new Quaternion().setFromEuler(
+    new Euler(rotation.x, rotation.y, rotation.z)
+  );
+  entity.transformStore.rotation.w = quat.w;
+  entity.transformStore.rotation.x = quat.x;
+  entity.transformStore.rotation.y = quat.y;
+  entity.transformStore.rotation.z = quat.z;
+  entity.transformStore.dirty.rotation = true;
+  syncImmediateRotation(entity);
 }
 function rotateY(entity, delta) {
-  setRotationY(entity, delta);
+  if (!entity.transformStore) return;
+  const halfAngle = delta / 2;
+  const deltaW = Math.cos(halfAngle);
+  const deltaY = Math.sin(halfAngle);
+  const q = entity.transformStore.rotation;
+  const newW = q.w * deltaW - q.y * deltaY;
+  const newX = q.x * deltaW + q.z * deltaY;
+  const newY = q.y * deltaW + q.w * deltaY;
+  const newZ = q.z * deltaW - q.x * deltaY;
+  entity.transformStore.rotation.w = newW;
+  entity.transformStore.rotation.x = newX;
+  entity.transformStore.rotation.y = newY;
+  entity.transformStore.rotation.z = newZ;
+  entity.transformStore.dirty.rotation = true;
+  syncImmediateRotation(entity);
+}
+function rotateX(entity, delta) {
+  if (!entity.transformStore) return;
+  const halfAngle = delta / 2;
+  const deltaW = Math.cos(halfAngle);
+  const deltaX = Math.sin(halfAngle);
+  const q = entity.transformStore.rotation;
+  const newW = q.w * deltaW - q.x * deltaX;
+  const newX = q.x * deltaW + q.w * deltaX;
+  const newY = q.y * deltaW + q.z * deltaX;
+  const newZ = q.z * deltaW - q.y * deltaX;
+  entity.transformStore.rotation.w = newW;
+  entity.transformStore.rotation.x = newX;
+  entity.transformStore.rotation.y = newY;
+  entity.transformStore.rotation.z = newZ;
+  entity.transformStore.dirty.rotation = true;
+  syncImmediateRotation(entity);
 }
 function rotateZ(entity, delta) {
-  setRotationZ(entity, delta);
+  if (!entity.transformStore) return;
+  const halfAngle = delta / 2;
+  const deltaW = Math.cos(halfAngle);
+  const deltaZ = Math.sin(halfAngle);
+  const q = entity.transformStore.rotation;
+  const newW = q.w * deltaW - q.z * deltaZ;
+  const newX = q.x * deltaW - q.y * deltaZ;
+  const newY = q.y * deltaW + q.x * deltaZ;
+  const newZ = q.z * deltaW + q.w * deltaZ;
+  entity.transformStore.rotation.w = newW;
+  entity.transformStore.rotation.x = newX;
+  entity.transformStore.rotation.y = newY;
+  entity.transformStore.rotation.z = newZ;
+  entity.transformStore.dirty.rotation = true;
+  entity._rotation2DAngle = (entity._rotation2DAngle ?? 0) + delta;
+  syncImmediateRotation(entity);
 }
 function setRotationY(entity, y) {
-  if (!entity.body) return;
+  if (!entity.transformStore) return;
   const halfAngle = y / 2;
   const w = Math.cos(halfAngle);
   const yComponent = Math.sin(halfAngle);
-  entity.body.setRotation({ w, x: 0, y: yComponent, z: 0 }, true);
+  entity.transformStore.rotation.w = w;
+  entity.transformStore.rotation.x = 0;
+  entity.transformStore.rotation.y = yComponent;
+  entity.transformStore.rotation.z = 0;
+  entity.transformStore.dirty.rotation = true;
+  syncImmediateRotation(entity);
 }
 function setRotationDegreesY(entity, y) {
   if (!entity.body) return;
   setRotationY(entity, MathUtils.degToRad(y));
 }
 function setRotationX(entity, x) {
-  if (!entity.body) return;
+  if (!entity.transformStore) return;
   const halfAngle = x / 2;
   const w = Math.cos(halfAngle);
   const xComponent = Math.sin(halfAngle);
-  entity.body.setRotation({ w, x: xComponent, y: 0, z: 0 }, true);
+  entity.transformStore.rotation.w = w;
+  entity.transformStore.rotation.x = xComponent;
+  entity.transformStore.rotation.y = 0;
+  entity.transformStore.rotation.z = 0;
+  entity.transformStore.dirty.rotation = true;
+  syncImmediateRotation(entity);
 }
 function setRotationDegreesX(entity, x) {
   if (!entity.body) return;
   setRotationX(entity, MathUtils.degToRad(x));
 }
 function setRotationZ(entity, z) {
-  if (!entity.body) return;
+  if (!entity.transformStore) return;
   const halfAngle = z / 2;
   const w = Math.cos(halfAngle);
   const zComponent = Math.sin(halfAngle);
-  entity.body.setRotation({ w, x: 0, y: 0, z: zComponent }, true);
+  entity.transformStore.rotation.w = w;
+  entity.transformStore.rotation.x = 0;
+  entity.transformStore.rotation.y = 0;
+  entity.transformStore.rotation.z = zComponent;
+  entity.transformStore.dirty.rotation = true;
+  entity._rotation2DAngle = z;
+  syncImmediateRotation(entity);
 }
 function setRotationDegreesZ(entity, z) {
   if (!entity.body) return;
   setRotationZ(entity, MathUtils.degToRad(z));
 }
 function setRotation(entity, x, y, z) {
-  if (!entity.body) return;
+  if (!entity.transformStore) return;
   const quat = new Quaternion().setFromEuler(new Euler(x, y, z));
-  entity.body.setRotation({ w: quat.w, x: quat.x, y: quat.y, z: quat.z }, true);
+  entity.transformStore.rotation.w = quat.w;
+  entity.transformStore.rotation.x = quat.x;
+  entity.transformStore.rotation.y = quat.y;
+  entity.transformStore.rotation.z = quat.z;
+  entity.transformStore.dirty.rotation = true;
+  entity._rotation2DAngle = z;
+  syncImmediateRotation(entity);
 }
 function setRotationDegrees(entity, x, y, z) {
   if (!entity.body) return;
@@ -255,35 +824,113 @@ function getRotation(entity) {
   if (!entity.body) return null;
   return entity.body.rotation();
 }
-function makeRotatable(entity) {
-  const rotatableEntity = entity;
-  rotatableEntity.rotateInDirection = (moveVector) => rotateInDirection(entity, moveVector);
-  rotatableEntity.rotateYEuler = (amount) => rotateYEuler(entity, amount);
-  rotatableEntity.rotateEuler = (rotation) => rotateEuler(entity, rotation);
-  rotatableEntity.rotateY = (delta) => rotateY(entity, delta);
-  rotatableEntity.rotateZ = (delta) => rotateZ(entity, delta);
-  rotatableEntity.setRotationY = (y) => setRotationY(entity, y);
-  rotatableEntity.setRotationX = (x) => setRotationX(entity, x);
-  rotatableEntity.setRotationZ = (z) => setRotationZ(entity, z);
-  rotatableEntity.setRotationDegreesY = (y) => setRotationDegreesY(entity, y);
-  rotatableEntity.setRotationDegreesX = (x) => setRotationDegreesX(entity, x);
-  rotatableEntity.setRotationDegreesZ = (z) => setRotationDegreesZ(entity, z);
-  rotatableEntity.setRotationDegrees = (x, y, z) => setRotationDegrees(entity, x, y, z);
-  rotatableEntity.setRotation = (x, y, z) => setRotation(entity, x, y, z);
-  rotatableEntity.getRotation = () => getRotation(entity);
-  return rotatableEntity;
-}
 
-// src/lib/actions/capabilities/transformable.ts
-function makeTransformable(entity) {
-  const withMovement = makeMoveable(entity);
-  const withRotation = makeRotatable(withMovement);
-  return withRotation;
+// src/lib/actions/global-change.ts
+function globalChange(key, callback) {
+  let previousValue = void 0;
+  return (ctx) => {
+    const currentValue = ctx.globals?.[key];
+    if (previousValue !== currentValue) {
+      if (!(previousValue === void 0 && currentValue === void 0)) {
+        callback(currentValue, ctx);
+      }
+      previousValue = currentValue;
+    }
+  };
+}
+function globalChanges(keys, callback) {
+  let previousValues = new Array(keys.length).fill(void 0);
+  return (ctx) => {
+    const currentValues = keys.map((k) => ctx.globals?.[k]);
+    const hasAnyChange = currentValues.some((val, idx) => previousValues[idx] !== val);
+    if (hasAnyChange) {
+      const allPrevUndef = previousValues.every((v) => v === void 0);
+      const allCurrUndef = currentValues.every((v) => v === void 0);
+      if (!(allPrevUndef && allCurrUndef)) {
+        callback(currentValues, ctx);
+      }
+      previousValues = currentValues;
+    }
+  };
+}
+function variableChange(key, callback) {
+  let previousValue = void 0;
+  return (ctx) => {
+    const currentValue = ctx.stage?.getVariable?.(key) ?? void 0;
+    if (previousValue !== currentValue) {
+      if (!(previousValue === void 0 && currentValue === void 0)) {
+        callback(currentValue, ctx);
+      }
+      previousValue = currentValue;
+    }
+  };
+}
+function variableChanges(keys, callback) {
+  let previousValues = new Array(keys.length).fill(void 0);
+  return (ctx) => {
+    const reader = (k) => ctx.stage?.getVariable?.(k);
+    const currentValues = keys.map(reader);
+    const hasAnyChange = currentValues.some((val, idx) => previousValues[idx] !== val);
+    if (hasAnyChange) {
+      const allPrevUndef = previousValues.every((v) => v === void 0);
+      const allCurrUndef = currentValues.every((v) => v === void 0);
+      if (!(allPrevUndef && allCurrUndef)) {
+        callback(currentValues, ctx);
+      }
+      previousValues = currentValues;
+    }
+  };
 }
 export {
-  actions_exports as actions,
-  makeMoveable,
-  makeRotatable,
-  makeTransformable
+  applyTransformChanges,
+  callFunc,
+  createTransformStore,
+  delay,
+  getPosition,
+  getRotation,
+  getVelocity,
+  globalChange,
+  globalChanges,
+  move,
+  moveBy,
+  moveForwardXY,
+  moveTo,
+  moveX,
+  moveXY,
+  moveXZ,
+  moveY,
+  moveZ,
+  onPress,
+  onRelease,
+  parallel,
+  repeat,
+  repeatForever,
+  resetTransformStore,
+  resetVelocity,
+  rotateBy,
+  rotateEuler,
+  rotateInDirection,
+  rotateX,
+  rotateY,
+  rotateYEuler,
+  rotateZ,
+  sequence,
+  setPosition,
+  setPositionX,
+  setPositionY,
+  setPositionZ,
+  setRotation,
+  setRotationDegrees,
+  setRotationDegreesX,
+  setRotationDegreesY,
+  setRotationDegreesZ,
+  setRotationX,
+  setRotationY,
+  setRotationZ,
+  throttle,
+  variableChange,
+  variableChanges,
+  wrapAround3D,
+  wrapAroundXY
 };
 //# sourceMappingURL=actions.js.map