cubeforge 0.0.6 → 0.0.7

package/dist/index.js

@@ -114,6 +114,23 @@ class ECSWorld {
     }
     return;
   }
+  findByTag(tag) {
+    for (const id of this.query("Tag")) {
+      const t = this.getComponent(id, "Tag");
+      if (t?.tags.includes(tag))
+        return id;
+    }
+    return;
+  }
+  findAllByTag(tag) {
+    const result = [];
+    for (const id of this.query("Tag")) {
+      const t = this.getComponent(id, "Tag");
+      if (t?.tags.includes(tag))
+        result.push(id);
+    }
+    return result;
+  }
   setDeterministicSeed(seed) {
     this._rngState = seed >>> 0;
     this._deterministic = true;
@@ -194,6 +211,16 @@ class ECSWorld {
     return this.componentIndex.size;
   }
 }
+// ../core/src/ecs/worldQueries.ts
+function findByTag(world, tag) {
+  const results = [];
+  for (const id of world.query("Tag")) {
+    const t = world.getComponent(id, "Tag");
+    if (t?.tags.includes(tag))
+      results.push(id);
+  }
+  return results;
+}
 // ../core/src/loop/gameLoop.ts
 class GameLoop {
   onTick;
@@ -605,6 +632,24 @@ class InputManager {
     return this.keyboard.isReleased(key);
   }
 }
+// ../input/src/inputMap.ts
+function createInputMap(bindings) {
+  const normalized = {};
+  for (const [action, keys] of Object.entries(bindings)) {
+    normalized[action] = Array.isArray(keys) ? keys : [keys];
+  }
+  return {
+    isActionDown(input, action) {
+      return (normalized[action] ?? []).some((k) => input.isDown(k));
+    },
+    isActionPressed(input, action) {
+      return (normalized[action] ?? []).some((k) => input.isPressed(k));
+    },
+    isActionReleased(input, action) {
+      return (normalized[action] ?? []).some((k) => input.isReleased(k));
+    }
+  };
+}
 // ../renderer/src/canvas2d.ts
 class Canvas2DRenderer {
   canvas;
@@ -656,6 +701,8 @@ function createCamera2D(opts) {
     zoom: 1,
     smoothing: 0,
     background: "#1a1a2e",
+    followOffsetX: 0,
+    followOffsetY: 0,
     shakeIntensity: 0,
     shakeDuration: 0,
     shakeTimer: 0,
@@ -712,25 +759,27 @@ class RenderSystem {
         if (targetId !== undefined) {
           const targetTransform = world2.getComponent(targetId, "Transform");
           if (targetTransform) {
+            const tx = targetTransform.x + (cam.followOffsetX ?? 0);
+            const ty = targetTransform.y + (cam.followOffsetY ?? 0);
             if (cam.deadZone) {
               const halfW = cam.deadZone.w / 2;
               const halfH = cam.deadZone.h / 2;
-              const dx = targetTransform.x - cam.x;
-              const dy = targetTransform.y - cam.y;
+              const dx = tx - cam.x;
+              const dy = ty - cam.y;
               if (dx > halfW)
-                cam.x = targetTransform.x - halfW;
+                cam.x = tx - halfW;
               else if (dx < -halfW)
-                cam.x = targetTransform.x + halfW;
+                cam.x = tx + halfW;
               if (dy > halfH)
-                cam.y = targetTransform.y - halfH;
+                cam.y = ty - halfH;
               else if (dy < -halfH)
-                cam.y = targetTransform.y + halfH;
+                cam.y = ty + halfH;
             } else if (cam.smoothing > 0) {
-              cam.x += (targetTransform.x - cam.x) * (1 - cam.smoothing);
-              cam.y += (targetTransform.y - cam.y) * (1 - cam.smoothing);
+              cam.x += (tx - cam.x) * (1 - cam.smoothing);
+              cam.y += (ty - cam.y) * (1 - cam.smoothing);
             } else {
-              cam.x = targetTransform.x;
-              cam.y = targetTransform.y;
+              cam.x = tx;
+              cam.y = ty;
             }
           }
         }
@@ -764,7 +813,16 @@ class RenderSystem {
         anim.timer -= frameDuration;
         anim.currentIndex++;
         if (anim.currentIndex >= anim.frames.length) {
-          anim.currentIndex = anim.loop ? 0 : anim.frames.length - 1;
+          if (anim.loop) {
+            anim.currentIndex = 0;
+          } else {
+            anim.currentIndex = anim.frames.length - 1;
+            anim.playing = false;
+            if (anim.onComplete && !anim._completed) {
+              anim._completed = true;
+              anim.onComplete();
+            }
+          }
         }
       }
       sprite.frameIndex = anim.frames[anim.currentIndex];
@@ -958,6 +1016,8 @@ function createRigidBody(opts) {
     isNearGround: false,
     bounce: 0,
     friction: 0.85,
+    lockX: false,
+    lockY: false,
     ...opts
   };
 }
@@ -971,7 +1031,22 @@ function createBoxCollider(width, height, opts) {
     offsetY: 0,
     isTrigger: false,
     layer: "default",
+    mask: "*",
     slope: 0,
+    oneWay: false,
+    ...opts
+  };
+}
+// ../physics/src/components/circleCollider.ts
+function createCircleCollider(radius, opts) {
+  return {
+    type: "CircleCollider",
+    radius,
+    offsetX: 0,
+    offsetY: 0,
+    isTrigger: false,
+    layer: "default",
+    mask: "*",
     ...opts
   };
 }
@@ -1009,12 +1084,27 @@ function getSlopeSurfaceY(st, sc, worldX) {
   const angleRad = sc.slope * (Math.PI / 180);
   return cy - hh + dx * Math.tan(angleRad);
 }
+function maskAllows(mask, layer) {
+  if (mask === "*")
+    return true;
+  return Array.isArray(mask) && mask.includes(layer);
+}
+function canInteract(a, b) {
+  return maskAllows(a.mask, b.layer) && maskAllows(b.mask, a.layer);
+}
+function pairKey(a, b) {
+  return a < b ? `${a}:${b}` : `${b}:${a}`;
+}
 
 class PhysicsSystem {
   gravity;
   events;
   accumulator = 0;
   FIXED_DT = 1 / 60;
+  activeTriggerPairs = new Map;
+  activeCollisionPairs = new Map;
+  activeCirclePairs = new Map;
+  staticPrevPos = new Map;
   constructor(gravity, events) {
     this.gravity = gravity;
     this.events = events;
@@ -1055,6 +1145,30 @@ class PhysicsSystem {
       else
         dynamics.push(id);
     }
+    for (const [key, [a, b]] of this.activeTriggerPairs) {
+      if (!world2.hasEntity(a) || !world2.hasEntity(b)) {
+        this.events?.emit("triggerExit", { a, b });
+        this.activeTriggerPairs.delete(key);
+      }
+    }
+    for (const [key, [a, b]] of this.activeCollisionPairs) {
+      if (!world2.hasEntity(a) || !world2.hasEntity(b)) {
+        this.events?.emit("collisionExit", { a, b });
+        this.activeCollisionPairs.delete(key);
+      }
+    }
+    const staticDelta = new Map;
+    for (const sid of statics) {
+      const st = world2.getComponent(sid, "Transform");
+      const prev = this.staticPrevPos.get(sid);
+      if (prev)
+        staticDelta.set(sid, { dx: st.x - prev.x, dy: st.y - prev.y });
+      this.staticPrevPos.set(sid, { x: st.x, y: st.y });
+    }
+    for (const sid of this.staticPrevPos.keys()) {
+      if (!world2.hasEntity(sid))
+        this.staticPrevPos.delete(sid);
+    }
     const staticGrid = new Map;
     for (const sid of statics) {
       const st = world2.getComponent(sid, "Transform");
@@ -1073,7 +1187,12 @@ class PhysicsSystem {
       const rb = world2.getComponent(id, "RigidBody");
       rb.onGround = false;
       rb.isNearGround = false;
-      rb.vy += this.gravity * rb.gravityScale * dt;
+      if (!rb.lockY)
+        rb.vy += this.gravity * rb.gravityScale * dt;
+      if (rb.lockX)
+        rb.vx = 0;
+      if (rb.lockY)
+        rb.vy = 0;
     }
     for (const id of dynamics) {
       const transform2 = world2.getComponent(id, "Transform");
@@ -1098,6 +1217,8 @@ class PhysicsSystem {
               continue;
             if (sc.slope !== 0)
               continue;
+            if (!canInteract(col, sc))
+              continue;
             const ov = getOverlap(getAABB(transform2, col), getAABB(st, sc));
             if (!ov)
               continue;
@@ -1130,6 +1251,8 @@ class PhysicsSystem {
             const sc = world2.getComponent(sid, "BoxCollider");
             if (sc.isTrigger)
               continue;
+            if (!canInteract(col, sc))
+              continue;
             if (sc.slope !== 0) {
               const ov2 = getOverlap(getAABB(transform2, col), getAABB(st, sc));
               if (!ov2)
@@ -1150,11 +1273,25 @@ class PhysicsSystem {
             if (!ov)
               continue;
             if (Math.abs(ov.y) <= Math.abs(ov.x)) {
+              if (sc.oneWay) {
+                if (ov.y >= 0)
+                  continue;
+                const platformTop = st.y + sc.offsetY - sc.height / 2;
+                const prevEntityBottom = transform2.y - rb.vy * dt + col.offsetY + col.height / 2;
+                if (prevEntityBottom > platformTop)
+                  continue;
+              }
               transform2.y += ov.y;
               if (ov.y < 0) {
                 rb.onGround = true;
                 if (rb.friction < 1)
                   rb.vx *= rb.friction;
+                const delta = staticDelta.get(sid);
+                if (delta) {
+                  transform2.x += delta.dx;
+                  if (delta.dy < 0)
+                    transform2.y += delta.dy;
+                }
               }
               rb.vy = rb.bounce > 0 ? -rb.vy * rb.bounce : 0;
             }
@@ -1162,6 +1299,7 @@ class PhysicsSystem {
         }
       }
     }
+    const currentCollisionPairs = new Map;
     for (let i = 0;i < dynamics.length; i++) {
       for (let j = i + 1;j < dynamics.length; j++) {
         const ia = dynamics[i];
@@ -1173,10 +1311,10 @@ class PhysicsSystem {
         const ov = getOverlap(getAABB(ta, ca), getAABB(tb, cb));
         if (!ov)
           continue;
-        if (ca.isTrigger || cb.isTrigger) {
-          this.events?.emit("trigger", { a: ia, b: ib });
+        if (!canInteract(ca, cb))
+          continue;
+        if (ca.isTrigger || cb.isTrigger)
           continue;
-        }
         const rba = world2.getComponent(ia, "RigidBody");
         const rbb = world2.getComponent(ib, "RigidBody");
         if (Math.abs(ov.y) <= Math.abs(ov.x)) {
@@ -1198,9 +1336,22 @@ class PhysicsSystem {
         ta.y += ov.y / 2;
         tb.x -= ov.x / 2;
         tb.y -= ov.y / 2;
-        this.events?.emit("collision", { a: ia, b: ib });
+        const key = pairKey(ia, ib);
+        currentCollisionPairs.set(key, [ia, ib]);
       }
     }
+    for (const [key, [a, b]] of currentCollisionPairs) {
+      if (!this.activeCollisionPairs.has(key)) {
+        this.events?.emit("collisionEnter", { a, b });
+      }
+      this.events?.emit("collision", { a, b });
+    }
+    for (const [key, [a, b]] of this.activeCollisionPairs) {
+      if (!currentCollisionPairs.has(key)) {
+        this.events?.emit("collisionExit", { a, b });
+      }
+    }
+    this.activeCollisionPairs = currentCollisionPairs;
     for (const id of dynamics) {
       const rb = world2.getComponent(id, "RigidBody");
       if (rb.onGround) {
@@ -1230,6 +1381,8 @@ class PhysicsSystem {
             const sc = world2.getComponent(sid, "BoxCollider");
             if (sc.isTrigger)
               continue;
+            if (!canInteract(col, sc))
+              continue;
             const ov = getOverlap(probeAABB, getAABB(st, sc));
             if (ov && Math.abs(ov.y) <= Math.abs(ov.x) && ov.y < 0) {
               rb.isNearGround = true;
@@ -1238,8 +1391,195 @@ class PhysicsSystem {
           }
         }
     }
+    const allWithCollider = world2.query("Transform", "BoxCollider");
+    const currentTriggerPairs = new Map;
+    for (let i = 0;i < allWithCollider.length; i++) {
+      for (let j = i + 1;j < allWithCollider.length; j++) {
+        const ia = allWithCollider[i];
+        const ib = allWithCollider[j];
+        const ca = world2.getComponent(ia, "BoxCollider");
+        const cb = world2.getComponent(ib, "BoxCollider");
+        if (!ca.isTrigger && !cb.isTrigger)
+          continue;
+        if (!canInteract(ca, cb))
+          continue;
+        const ta = world2.getComponent(ia, "Transform");
+        const tb = world2.getComponent(ib, "Transform");
+        const ov = getOverlap(getAABB(ta, ca), getAABB(tb, cb));
+        if (!ov)
+          continue;
+        const key = pairKey(ia, ib);
+        currentTriggerPairs.set(key, [ia, ib]);
+      }
+    }
+    for (const [key, [a, b]] of currentTriggerPairs) {
+      if (!this.activeTriggerPairs.has(key)) {
+        this.events?.emit("triggerEnter", { a, b });
+      }
+      this.events?.emit("trigger", { a, b });
+    }
+    for (const [key, [a, b]] of this.activeTriggerPairs) {
+      if (!currentTriggerPairs.has(key)) {
+        this.events?.emit("triggerExit", { a, b });
+      }
+    }
+    this.activeTriggerPairs = currentTriggerPairs;
+    const allCircles = world2.query("Transform", "CircleCollider");
+    if (allCircles.length > 0) {
+      const currentCirclePairs = new Map;
+      for (let i = 0;i < allCircles.length; i++) {
+        for (let j = i + 1;j < allCircles.length; j++) {
+          const ia = allCircles[i];
+          const ib = allCircles[j];
+          const ca = world2.getComponent(ia, "CircleCollider");
+          const cb = world2.getComponent(ib, "CircleCollider");
+          if (!maskAllows(ca.mask, cb.layer) || !maskAllows(cb.mask, ca.layer))
+            continue;
+          const ta = world2.getComponent(ia, "Transform");
+          const tb = world2.getComponent(ib, "Transform");
+          const dx = ta.x + ca.offsetX - (tb.x + cb.offsetX);
+          const dy = ta.y + ca.offsetY - (tb.y + cb.offsetY);
+          if (dx * dx + dy * dy < (ca.radius + cb.radius) ** 2) {
+            currentCirclePairs.set(pairKey(ia, ib), [ia, ib]);
+          }
+        }
+      }
+      const allBoxes = world2.query("Transform", "BoxCollider");
+      for (const cid of allCircles) {
+        const cc = world2.getComponent(cid, "CircleCollider");
+        const ct = world2.getComponent(cid, "Transform");
+        const cx = ct.x + cc.offsetX;
+        const cy = ct.y + cc.offsetY;
+        for (const bid of allBoxes) {
+          if (bid === cid)
+            continue;
+          const bc = world2.getComponent(bid, "BoxCollider");
+          if (!maskAllows(cc.mask, bc.layer) || !maskAllows(bc.mask, cc.layer))
+            continue;
+          const bt = world2.getComponent(bid, "Transform");
+          const bx = bt.x + bc.offsetX;
+          const by = bt.y + bc.offsetY;
+          const nearX = Math.max(bx - bc.width / 2, Math.min(cx, bx + bc.width / 2));
+          const nearY = Math.max(by - bc.height / 2, Math.min(cy, by + bc.height / 2));
+          const dx = cx - nearX;
+          const dy = cy - nearY;
+          if (dx * dx + dy * dy < cc.radius * cc.radius) {
+            currentCirclePairs.set(pairKey(cid, bid), [cid, bid]);
+          }
+        }
+      }
+      for (const [key, [a, b]] of currentCirclePairs) {
+        if (!this.activeCirclePairs.has(key)) {
+          this.events?.emit("circleEnter", { a, b });
+        }
+        this.events?.emit("circle", { a, b });
+      }
+      for (const [key, [a, b]] of this.activeCirclePairs) {
+        if (!currentCirclePairs.has(key)) {
+          this.events?.emit("circleExit", { a, b });
+        }
+      }
+      this.activeCirclePairs = currentCirclePairs;
+    }
   }
 }
+// ../physics/src/queries.ts
+function passesFilter(world2, id, col, opts) {
+  if (opts.exclude?.includes(id))
+    return false;
+  if (opts.layer && col.layer !== opts.layer)
+    return false;
+  if (opts.tag) {
+    const t = world2.getComponent(id, "Tag");
+    if (!t?.tags.includes(opts.tag))
+      return false;
+  }
+  return true;
+}
+function overlapBox(world2, cx, cy, hw, hh, opts = {}) {
+  const results = [];
+  for (const id of world2.query("Transform", "BoxCollider")) {
+    const t = world2.getComponent(id, "Transform");
+    const c = world2.getComponent(id, "BoxCollider");
+    if (!passesFilter(world2, id, c, opts))
+      continue;
+    const ecx = t.x + c.offsetX;
+    const ecy = t.y + c.offsetY;
+    const ehw = c.width / 2;
+    const ehh = c.height / 2;
+    if (Math.abs(ecx - cx) < hw + ehw && Math.abs(ecy - cy) < hh + ehh) {
+      results.push(id);
+    }
+  }
+  return results;
+}
+function raycast(world2, origin, direction, maxDistance, opts = {}) {
+  const len = Math.hypot(direction.x, direction.y);
+  if (len === 0)
+    return null;
+  const dx = direction.x / len;
+  const dy = direction.y / len;
+  let closest = null;
+  for (const id of world2.query("Transform", "BoxCollider")) {
+    const t = world2.getComponent(id, "Transform");
+    const c = world2.getComponent(id, "BoxCollider");
+    if (!opts.includeTriggers && c.isTrigger)
+      continue;
+    if (!passesFilter(world2, id, c, opts))
+      continue;
+    const cx = t.x + c.offsetX;
+    const cy = t.y + c.offsetY;
+    const hw = c.width / 2;
+    const hh = c.height / 2;
+    const left = cx - hw;
+    const right = cx + hw;
+    const top = cy - hh;
+    const bottom = cy + hh;
+    let tmin = -Infinity;
+    let tmax = Infinity;
+    if (dx !== 0) {
+      const t1 = (left - origin.x) / dx;
+      const t2 = (right - origin.x) / dx;
+      tmin = Math.max(tmin, Math.min(t1, t2));
+      tmax = Math.min(tmax, Math.max(t1, t2));
+    } else if (origin.x < left || origin.x > right) {
+      continue;
+    }
+    if (dy !== 0) {
+      const t1 = (top - origin.y) / dy;
+      const t2 = (bottom - origin.y) / dy;
+      tmin = Math.max(tmin, Math.min(t1, t2));
+      tmax = Math.min(tmax, Math.max(t1, t2));
+    } else if (origin.y < top || origin.y > bottom) {
+      continue;
+    }
+    if (tmax < 0 || tmin > tmax || tmin > maxDistance)
+      continue;
+    const dist = Math.max(0, tmin);
+    if (closest && dist >= closest.distance)
+      continue;
+    const hitX = origin.x + dx * tmin;
+    const hitY = origin.y + dy * tmin;
+    let nx = 0;
+    let ny = 0;
+    const edgeEps = 0.001;
+    if (Math.abs(hitX - left) < edgeEps)
+      nx = -1;
+    else if (Math.abs(hitX - right) < edgeEps)
+      nx = 1;
+    else if (Math.abs(hitY - top) < edgeEps)
+      ny = -1;
+    else if (Math.abs(hitY - bottom) < edgeEps)
+      ny = 1;
+    closest = {
+      entityId: id,
+      distance: dist,
+      point: { x: hitX, y: hitY },
+      normal: { x: nx, y: ny }
+    };
+  }
+  return closest;
+}
 // src/context.ts
 import { createContext } from "react";
 var EngineContext = createContext(null);
@@ -1657,6 +1997,7 @@ function Game({
   seed = 0,
   onReady,
   plugins,
+  renderer: CustomRenderer,
   style,
   className,
   children
@@ -1671,13 +2012,21 @@ function Game({
     if (deterministic)
       ecs.setDeterministicSeed(seed);
     const input = new InputManager;
-    const renderer = new Canvas2DRenderer(canvas);
     const events = new EventBus;
     const assets = new AssetManager;
     const physics = new PhysicsSystem(gravity, events);
     const entityIds = new Map;
-    const renderSystem2 = new RenderSystem(renderer, entityIds);
-    const debugSystem = debug ? new DebugSystem(renderer) : null;
+    let canvas2d2;
+    let builtinRenderSystem;
+    let renderSystem2;
+    if (CustomRenderer) {
+      renderSystem2 = new CustomRenderer(canvas, entityIds);
+    } else {
+      canvas2d2 = new Canvas2DRenderer(canvas);
+      builtinRenderSystem = new RenderSystem(canvas2d2, entityIds);
+      renderSystem2 = builtinRenderSystem;
+    }
+    const debugSystem = debug && canvas2d2 ? new DebugSystem(canvas2d2) : null;
     ecs.addSystem(new ScriptSystem(input));
     ecs.addSystem(physics);
     ecs.addSystem(renderSystem2);
@@ -1699,7 +2048,7 @@ function Game({
         handle.onFrame?.();
       }
     });
-    const state = { ecs, input, renderer, physics, events, assets, loop, canvas, entityIds };
+    const state = { ecs, input, renderer: canvas2d2, renderSystem: builtinRenderSystem, physics, events, assets, loop, canvas, entityIds };
     setEngine(state);
     if (plugins) {
       for (const plugin2 of plugins) {
@@ -1927,12 +2276,14 @@ function RigidBody({
   bounce = 0,
   friction = 0.85,
   vx = 0,
-  vy = 0
+  vy = 0,
+  lockX = false,
+  lockY = false
 }) {
   const engine = useContext5(EngineContext);
   const entityId = useContext5(EntityContext);
   useEffect7(() => {
-    engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy }));
+    engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, lockX, lockY }));
     return () => engine.ecs.removeComponent(entityId, "RigidBody");
   }, []);
   return null;
@@ -1945,12 +2296,14 @@ function BoxCollider({
   offsetX = 0,
   offsetY = 0,
   isTrigger = false,
-  layer = "default"
+  layer = "default",
+  mask = "*",
+  oneWay = false
 }) {
   const engine = useContext6(EngineContext);
   const entityId = useContext6(EntityContext);
   useEffect8(() => {
-    engine.ecs.addComponent(entityId, createBoxCollider(width, height, { offsetX, offsetY, isTrigger, layer }));
+    engine.ecs.addComponent(entityId, createBoxCollider(width, height, { offsetX, offsetY, isTrigger, layer, mask, oneWay }));
     const checkId = setTimeout(() => {
       if (engine.ecs.hasEntity(entityId) && !engine.ecs.hasComponent(entityId, "Transform")) {
         console.warn(`[Cubeforge] BoxCollider on entity ${entityId} has no Transform. Physics requires Transform.`);
@@ -1963,12 +2316,30 @@ function BoxCollider({
   }, []);
   return null;
 }
-// src/components/Script.tsx
+// src/components/CircleCollider.tsx
 import { useEffect as useEffect9, useContext as useContext7 } from "react";
-function Script({ init, update }) {
+function CircleCollider({
+  radius,
+  offsetX = 0,
+  offsetY = 0,
+  isTrigger = false,
+  layer = "default",
+  mask = "*"
+}) {
   const engine = useContext7(EngineContext);
   const entityId = useContext7(EntityContext);
   useEffect9(() => {
+    engine.ecs.addComponent(entityId, createCircleCollider(radius, { offsetX, offsetY, isTrigger, layer, mask }));
+    return () => engine.ecs.removeComponent(entityId, "CircleCollider");
+  }, []);
+  return null;
+}
+// src/components/Script.tsx
+import { useEffect as useEffect10, useContext as useContext8 } from "react";
+function Script({ init, update }) {
+  const engine = useContext8(EngineContext);
+  const entityId = useContext8(EntityContext);
+  useEffect10(() => {
     if (init) {
       try {
         init(entityId, engine.ecs);
@@ -1982,17 +2353,19 @@ function Script({ init, update }) {
   return null;
 }
 // src/components/Camera2D.tsx
-import { useEffect as useEffect10, useContext as useContext8 } from "react";
+import { useEffect as useEffect11, useContext as useContext9 } from "react";
 function Camera2D({
   followEntity,
   zoom = 1,
   smoothing = 0,
   background = "#1a1a2e",
   bounds,
-  deadZone
+  deadZone,
+  followOffsetX = 0,
+  followOffsetY = 0
 }) {
-  const engine = useContext8(EngineContext);
-  useEffect10(() => {
+  const engine = useContext9(EngineContext);
+  useEffect11(() => {
     const entityId = engine.ecs.createEntity();
     engine.ecs.addComponent(entityId, createCamera2D({
       followEntityId: followEntity,
@@ -2000,11 +2373,13 @@ function Camera2D({
       smoothing,
       background,
       bounds,
-      deadZone
+      deadZone,
+      followOffsetX,
+      followOffsetY
     }));
     return () => engine.ecs.destroyEntity(entityId);
   }, []);
-  useEffect10(() => {
+  useEffect11(() => {
     const camId = engine.ecs.queryOne("Camera2D");
     if (camId === undefined)
       return;
@@ -2015,15 +2390,17 @@ function Camera2D({
     cam.background = background;
     cam.bounds = bounds;
     cam.deadZone = deadZone;
-  }, [followEntity, zoom, smoothing, background, bounds, deadZone, engine]);
+    cam.followOffsetX = followOffsetX;
+    cam.followOffsetY = followOffsetY;
+  }, [followEntity, zoom, smoothing, background, bounds, deadZone, followOffsetX, followOffsetY, engine]);
   return null;
 }
 // src/components/Animation.tsx
-import { useEffect as useEffect11, useContext as useContext9 } from "react";
-function Animation({ frames, fps = 12, loop = true, playing = true }) {
-  const engine = useContext9(EngineContext);
-  const entityId = useContext9(EntityContext);
-  useEffect11(() => {
+import { useEffect as useEffect12, useContext as useContext10 } from "react";
+function Animation({ frames, fps = 12, loop = true, playing = true, onComplete }) {
+  const engine = useContext10(EngineContext);
+  const entityId = useContext10(EntityContext);
+  useEffect12(() => {
     const state = {
       type: "AnimationState",
       frames,
@@ -2031,29 +2408,39 @@ function Animation({ frames, fps = 12, loop = true, playing = true }) {
       loop,
       playing,
       currentIndex: 0,
-      timer: 0
+      timer: 0,
+      _completed: false,
+      onComplete
     };
     engine.ecs.addComponent(entityId, state);
     return () => {
       engine.ecs.removeComponent(entityId, "AnimationState");
     };
   }, []);
-  useEffect11(() => {
+  useEffect12(() => {
     const anim = engine.ecs.getComponent(entityId, "AnimationState");
     if (!anim)
       return;
+    const wasFramesChanged = anim.frames !== frames;
     anim.playing = playing;
     anim.fps = fps;
     anim.loop = loop;
-  }, [playing, fps, loop, engine, entityId]);
+    anim.onComplete = onComplete;
+    if (wasFramesChanged) {
+      anim.frames = frames;
+      anim.currentIndex = 0;
+      anim.timer = 0;
+      anim._completed = false;
+    }
+  }, [playing, fps, loop, frames, onComplete, engine, entityId]);
   return null;
 }
 // src/components/SquashStretch.tsx
-import { useEffect as useEffect12, useContext as useContext10 } from "react";
+import { useEffect as useEffect13, useContext as useContext11 } from "react";
 function SquashStretch({ intensity = 0.2, recovery = 8 }) {
-  const engine = useContext10(EngineContext);
-  const entityId = useContext10(EntityContext);
-  useEffect12(() => {
+  const engine = useContext11(EngineContext);
+  const entityId = useContext11(EntityContext);
+  useEffect13(() => {
     engine.ecs.addComponent(entityId, {
       type: "SquashStretch",
       intensity,
@@ -2066,7 +2453,7 @@ function SquashStretch({ intensity = 0.2, recovery = 8 }) {
   return null;
 }
 // src/components/ParticleEmitter.tsx
-import { useEffect as useEffect13, useContext as useContext11 } from "react";
+import { useEffect as useEffect14, useContext as useContext12 } from "react";
 
 // src/components/particlePresets.ts
 var PARTICLE_PRESETS = {
@@ -2151,9 +2538,9 @@ function ParticleEmitter({
   const resolvedColor = color ?? presetConfig.color ?? "#ffffff";
   const resolvedGravity = gravity ?? presetConfig.gravity ?? 200;
   const resolvedMaxParticles = maxParticles ?? presetConfig.maxParticles ?? 100;
-  const engine = useContext11(EngineContext);
-  const entityId = useContext11(EntityContext);
-  useEffect13(() => {
+  const engine = useContext12(EngineContext);
+  const entityId = useContext12(EntityContext);
+  useEffect14(() => {
     engine.ecs.addComponent(entityId, {
       type: "ParticlePool",
       particles: [],
@@ -2171,7 +2558,7 @@ function ParticleEmitter({
     });
     return () => engine.ecs.removeComponent(entityId, "ParticlePool");
   }, []);
-  useEffect13(() => {
+  useEffect14(() => {
     const pool = engine.ecs.getComponent(entityId, "ParticlePool");
     if (!pool)
       return;
@@ -2229,8 +2616,70 @@ function MovingPlatform({
     ]
   }, undefined, true, undefined, this);
 }
+// src/components/Checkpoint.tsx
+import { useState as useState4 } from "react";
+
+// src/hooks/useContact.ts
+import { useContext as useContext13, useEffect as useEffect15 } from "react";
+function useContactEvent(eventName, handler, opts) {
+  const engine = useContext13(EngineContext);
+  const entityId = useContext13(EntityContext);
+  if (!engine)
+    throw new Error(`${eventName} hook must be used inside <Game>`);
+  if (entityId === null)
+    throw new Error(`${eventName} hook must be used inside <Entity>`);
+  useEffect15(() => {
+    return engine.events.on(eventName, ({ a, b }) => {
+      const isA = a === entityId;
+      const isB = b === entityId;
+      if (!isA && !isB)
+        return;
+      const other = isA ? b : a;
+      if (opts?.tag) {
+        const tagComp = engine.ecs.getComponent(other, "Tag");
+        if (!tagComp?.tags.includes(opts.tag))
+          return;
+      }
+      if (opts?.layer) {
+        const col = engine.ecs.getComponent(other, "BoxCollider");
+        if (col?.layer !== opts.layer)
+          return;
+      }
+      handler(other);
+    });
+  }, [engine.events, engine.ecs, entityId, opts?.tag, opts?.layer]);
+}
+function useTriggerEnter(handler, opts) {
+  useContactEvent("triggerEnter", handler, opts);
+}
+function useTriggerExit(handler, opts) {
+  useContactEvent("triggerExit", handler, opts);
+}
+function useCollisionEnter(handler, opts) {
+  useContactEvent("collisionEnter", handler, opts);
+}
+function useCollisionExit(handler, opts) {
+  useContactEvent("collisionExit", handler, opts);
+}
+function useCircleEnter(handler, opts) {
+  useContactEvent("circleEnter", handler, opts);
+}
+function useCircleExit(handler, opts) {
+  useContactEvent("circleExit", handler, opts);
+}
+
 // src/components/Checkpoint.tsx
 import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+function CheckpointActivator({ onActivate }) {
+  const [used, setUsed] = useState4(false);
+  useTriggerEnter(() => {
+    if (used)
+      return;
+    setUsed(true);
+    onActivate?.();
+  }, { tag: "player" });
+  return null;
+}
 function Checkpoint({
   x,
   y,
@@ -2257,36 +2706,14 @@ function Checkpoint({
         height,
         isTrigger: true
       }, undefined, false, undefined, this),
-      /* @__PURE__ */ jsxDEV6(Script, {
-        init: () => {},
-        update: (id, world2) => {
-          if (!world2.hasEntity(id))
-            return;
-          const ct = world2.getComponent(id, "Transform");
-          if (!ct)
-            return;
-          for (const pid of world2.query("Tag")) {
-            const tag2 = world2.getComponent(pid, "Tag");
-            if (!tag2?.tags.includes("player"))
-              continue;
-            const pt = world2.getComponent(pid, "Transform");
-            if (!pt)
-              continue;
-            const dx = Math.abs(pt.x - ct.x);
-            const dy = Math.abs(pt.y - ct.y);
-            if (dx < width / 2 + 16 && dy < height / 2 + 20) {
-              onActivate?.();
-              world2.destroyEntity(id);
-              return;
-            }
-          }
-        }
+      /* @__PURE__ */ jsxDEV6(CheckpointActivator, {
+        onActivate
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
 }
 // src/components/Tilemap.tsx
-import { useEffect as useEffect14, useState as useState4, useContext as useContext12 } from "react";
+import { useEffect as useEffect16, useState as useState5, useContext as useContext14 } from "react";
 import { jsxDEV as jsxDEV7, Fragment as Fragment3 } from "react/jsx-dev-runtime";
 var animatedTiles = new Map;
 function getProperty(props, name) {
@@ -2310,9 +2737,9 @@ function Tilemap({
   triggerLayer: triggerLayerName = "triggers",
   onTileProperty
 }) {
-  const engine = useContext12(EngineContext);
-  const [spawnedNodes, setSpawnedNodes] = useState4([]);
-  useEffect14(() => {
+  const engine = useContext14(EngineContext);
+  const [spawnedNodes, setSpawnedNodes] = useState5([]);
+  useEffect16(() => {
     if (!engine)
       return;
     const createdEntities = [];
@@ -2508,7 +2935,7 @@ function Tilemap({
   }, undefined, false, undefined, this);
 }
 // src/components/ParallaxLayer.tsx
-import { useEffect as useEffect15, useContext as useContext13 } from "react";
+import { useEffect as useEffect17, useContext as useContext15 } from "react";
 import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
 function ParallaxLayerInner({
   src,
@@ -2520,9 +2947,9 @@ function ParallaxLayerInner({
   offsetX,
   offsetY
 }) {
-  const engine = useContext13(EngineContext);
-  const entityId = useContext13(EntityContext);
-  useEffect15(() => {
+  const engine = useContext15(EngineContext);
+  const entityId = useContext15(EntityContext);
+  useEffect17(() => {
     engine.ecs.addComponent(entityId, {
       type: "ParallaxLayer",
       src,
@@ -2538,7 +2965,7 @@ function ParallaxLayerInner({
     });
     return () => engine.ecs.removeComponent(entityId, "ParallaxLayer");
   }, []);
-  useEffect15(() => {
+  useEffect17(() => {
     const layer = engine.ecs.getComponent(entityId, "ParallaxLayer");
     if (!layer)
       return;
@@ -2620,47 +3047,111 @@ var ScreenFlash = forwardRef((_, ref) => {
 });
 ScreenFlash.displayName = "ScreenFlash";
 // src/hooks/useGame.ts
-import { useContext as useContext14 } from "react";
+import { useContext as useContext16 } from "react";
 function useGame() {
-  const engine = useContext14(EngineContext);
+  const engine = useContext16(EngineContext);
   if (!engine)
     throw new Error("useGame must be used inside <Game>");
   return engine;
 }
+// src/hooks/useCamera.ts
+import { useMemo } from "react";
+function useCamera() {
+  const engine = useGame();
+  return useMemo(() => ({
+    shake(intensity, duration) {
+      engine.renderSystem?.triggerShake(intensity, duration);
+    },
+    setFollowOffset(x, y) {
+      const camId = engine.ecs.queryOne("Camera2D");
+      if (camId === undefined)
+        return;
+      const cam = engine.ecs.getComponent(camId, "Camera2D");
+      if (cam) {
+        cam.followOffsetX = x;
+        cam.followOffsetY = y;
+      }
+    },
+    setPosition(x, y) {
+      const camId = engine.ecs.queryOne("Camera2D");
+      if (camId === undefined)
+        return;
+      const cam = engine.ecs.getComponent(camId, "Camera2D");
+      if (cam) {
+        cam.x = x;
+        cam.y = y;
+      }
+    },
+    setZoom(zoom) {
+      const camId = engine.ecs.queryOne("Camera2D");
+      if (camId === undefined)
+        return;
+      const cam = engine.ecs.getComponent(camId, "Camera2D");
+      if (cam)
+        cam.zoom = zoom;
+    }
+  }), [engine]);
+}
+// src/hooks/useSnapshot.ts
+import { useMemo as useMemo2 } from "react";
+function useSnapshot() {
+  const engine = useGame();
+  return useMemo2(() => ({
+    save: () => engine.ecs.getSnapshot(),
+    restore: (snapshot) => engine.ecs.restoreSnapshot(snapshot)
+  }), [engine]);
+}
 // src/hooks/useEntity.ts
-import { useContext as useContext15 } from "react";
+import { useContext as useContext17 } from "react";
 function useEntity() {
-  const id = useContext15(EntityContext);
+  const id = useContext17(EntityContext);
   if (id === null)
     throw new Error("useEntity must be used inside <Entity>");
   return id;
 }
 // src/hooks/useInput.ts
-import { useContext as useContext16 } from "react";
+import { useContext as useContext18 } from "react";
 function useInput() {
-  const engine = useContext16(EngineContext);
+  const engine = useContext18(EngineContext);
   if (!engine)
     throw new Error("useInput must be used inside <Game>");
   return engine.input;
 }
+// src/hooks/useInputMap.ts
+import { useMemo as useMemo3 } from "react";
+function useInputMap(bindings) {
+  const input = useInput();
+  const normalized = useMemo3(() => {
+    const out = {};
+    for (const [action, keys] of Object.entries(bindings)) {
+      out[action] = Array.isArray(keys) ? keys : [keys];
+    }
+    return out;
+  }, []);
+  return useMemo3(() => ({
+    isActionDown: (action) => (normalized[action] ?? []).some((k) => input.isDown(k)),
+    isActionPressed: (action) => (normalized[action] ?? []).some((k) => input.isPressed(k)),
+    isActionReleased: (action) => (normalized[action] ?? []).some((k) => input.isReleased(k))
+  }), [input, normalized]);
+}
 // src/hooks/useEvents.ts
-import { useContext as useContext17, useEffect as useEffect16 } from "react";
+import { useContext as useContext19, useEffect as useEffect18 } from "react";
 function useEvents() {
-  const engine = useContext17(EngineContext);
+  const engine = useContext19(EngineContext);
   if (!engine)
     throw new Error("useEvents must be used inside <Game>");
   return engine.events;
 }
 function useEvent(event, handler) {
   const events = useEvents();
-  useEffect16(() => {
+  useEffect18(() => {
     return events.on(event, handler);
   }, [events, event]);
 }
 // src/hooks/usePlatformerController.ts
-import { useContext as useContext18, useEffect as useEffect17 } from "react";
+import { useContext as useContext20, useEffect as useEffect19 } from "react";
 function usePlatformerController(entityId, opts = {}) {
-  const engine = useContext18(EngineContext);
+  const engine = useContext20(EngineContext);
   const {
     speed = 200,
     jumpForce = -500,
@@ -2668,7 +3159,7 @@ function usePlatformerController(entityId, opts = {}) {
     coyoteTime = 0.08,
     jumpBuffer = 0.08
   } = opts;
-  useEffect17(() => {
+  useEffect19(() => {
     const state = { coyoteTimer: 0, jumpBuffer: 0, jumpsLeft: maxJumps };
     const updateFn = (id, world2, input, dt) => {
       if (!world2.hasEntity(id))
@@ -2717,11 +3208,11 @@ function usePlatformerController(entityId, opts = {}) {
   }, []);
 }
 // src/hooks/useTopDownMovement.ts
-import { useContext as useContext19, useEffect as useEffect18 } from "react";
+import { useContext as useContext21, useEffect as useEffect20 } from "react";
 function useTopDownMovement(entityId, opts = {}) {
-  const engine = useContext19(EngineContext);
+  const engine = useContext21(EngineContext);
   const { speed = 200, normalizeDiagonal = true } = opts;
-  useEffect18(() => {
+  useEffect20(() => {
     const updateFn = (id, world2, input) => {
       if (!world2.hasEntity(id))
         return;
@@ -2755,15 +3246,28 @@ function createAtlas(names, _columns) {
   return atlas;
 }
 export {
+  useTriggerExit,
+  useTriggerEnter,
   useTopDownMovement,
+  useSnapshot,
   usePlatformerController,
+  useInputMap,
   useInput,
   useGame,
   useEvents,
   useEvent,
   useEntity,
+  useCollisionExit,
+  useCollisionEnter,
+  useCircleExit,
+  useCircleEnter,
+  useCamera,
   tween,
+  raycast,
+  overlapBox,
+  findByTag,
   definePlugin,
+  createInputMap,
   createAtlas,
   World,
   Transform,
@@ -2779,6 +3283,7 @@ export {
   Game,
   Entity,
   Ease,
+  CircleCollider,
   Checkpoint,
   Camera2D,
   BoxCollider,