cubeforge 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,27 +1,2377 @@
-// Components
-export { Game } from './components/Game';
-export { World } from './components/World';
-export { Entity } from './components/Entity';
-export { Transform } from './components/Transform';
-export { Sprite } from './components/Sprite';
-export { RigidBody } from './components/RigidBody';
-export { BoxCollider } from './components/BoxCollider';
-export { Script } from './components/Script';
-export { Camera2D } from './components/Camera2D';
-export { Animation } from './components/Animation';
-export { SquashStretch } from './components/SquashStretch';
-export { ParticleEmitter } from './components/ParticleEmitter';
-export { MovingPlatform } from './components/MovingPlatform';
-export { Checkpoint } from './components/Checkpoint';
-export { Tilemap } from './components/Tilemap';
-export { ParallaxLayer } from './components/ParallaxLayer';
-export { ScreenFlash } from './components/ScreenFlash';
-// Hooks
-export { useGame } from './hooks/useGame';
-export { useEntity } from './hooks/useEntity';
-export { useInput } from './hooks/useInput';
-export { useEvents, useEvent } from './hooks/useEvents';
-export { usePlatformerController } from './hooks/usePlatformerController';
-export { useTopDownMovement } from './hooks/useTopDownMovement';
-export { createAtlas } from './components/spriteAtlas';
-export { Ease, tween } from '@cubeforge/core';
+// src/components/Game.tsx
+import { useEffect, useRef, useState } from "react";
+// ../core/src/ecs/world.ts
+class ECSWorld {
+  nextId = 0;
+  entities = new Set;
+  components = new Map;
+  systems = [];
+  queryCache = new Map;
+  dirtyTypes = new Set;
+  dirtyAll = false;
+  createEntity() {
+    const id = this.nextId++;
+    this.entities.add(id);
+    this.components.set(id, new Map);
+    this.dirtyAll = true;
+    return id;
+  }
+  destroyEntity(id) {
+    const comps = this.components.get(id);
+    if (comps) {
+      for (const type of comps.keys()) {
+        this.dirtyTypes.add(type);
+      }
+    }
+    this.entities.delete(id);
+    this.components.delete(id);
+    this.dirtyAll = true;
+  }
+  hasEntity(id) {
+    return this.entities.has(id);
+  }
+  addComponent(id, component) {
+    this.components.get(id)?.set(component.type, component);
+    this.dirtyTypes.add(component.type);
+  }
+  removeComponent(id, type) {
+    this.components.get(id)?.delete(type);
+    this.dirtyTypes.add(type);
+  }
+  getComponent(id, type) {
+    return this.components.get(id)?.get(type);
+  }
+  hasComponent(id, type) {
+    return this.components.get(id)?.has(type) ?? false;
+  }
+  query(...types) {
+    const key = types.slice().sort().join("\x00");
+    const cached = this.queryCache.get(key);
+    if (cached)
+      return cached;
+    const result = [];
+    for (const id of this.entities) {
+      const comps = this.components.get(id);
+      let match = true;
+      for (const t of types) {
+        if (!comps.has(t)) {
+          match = false;
+          break;
+        }
+      }
+      if (match)
+        result.push(id);
+    }
+    this.queryCache.set(key, result);
+    return result;
+  }
+  queryOne(...types) {
+    for (const id of this.entities) {
+      const comps = this.components.get(id);
+      let match = true;
+      for (const t of types) {
+        if (!comps.has(t)) {
+          match = false;
+          break;
+        }
+      }
+      if (match)
+        return id;
+    }
+    return;
+  }
+  addSystem(system) {
+    this.systems.push(system);
+  }
+  removeSystem(system) {
+    const idx = this.systems.indexOf(system);
+    if (idx !== -1)
+      this.systems.splice(idx, 1);
+  }
+  update(dt) {
+    if (this.dirtyAll) {
+      this.queryCache.clear();
+    } else if (this.dirtyTypes.size > 0) {
+      for (const key of this.queryCache.keys()) {
+        if (key === "") {
+          this.queryCache.delete(key);
+          continue;
+        }
+        const keyTypes = key.split("\x00");
+        if (keyTypes.some((t) => this.dirtyTypes.has(t))) {
+          this.queryCache.delete(key);
+        }
+      }
+    }
+    this.dirtyAll = false;
+    this.dirtyTypes.clear();
+    for (const system of this.systems) {
+      system.update(this, dt);
+    }
+  }
+  clear() {
+    this.entities.clear();
+    this.components.clear();
+    this.queryCache.clear();
+    this.dirtyTypes.clear();
+    this.dirtyAll = false;
+    this.nextId = 0;
+  }
+  get entityCount() {
+    return this.entities.size;
+  }
+}
+// ../core/src/loop/gameLoop.ts
+class GameLoop {
+  onTick;
+  rafId = 0;
+  lastTime = 0;
+  running = false;
+  paused = false;
+  hitPauseTimer = 0;
+  constructor(onTick) {
+    this.onTick = onTick;
+  }
+  hitPause(duration) {
+    this.hitPauseTimer = duration;
+  }
+  start() {
+    if (this.running)
+      return;
+    this.running = true;
+    this.paused = false;
+    this.lastTime = performance.now();
+    this.rafId = requestAnimationFrame(this.frame);
+  }
+  stop() {
+    this.running = false;
+    cancelAnimationFrame(this.rafId);
+  }
+  pause() {
+    if (!this.running)
+      return;
+    this.running = false;
+    this.paused = true;
+    cancelAnimationFrame(this.rafId);
+  }
+  resume() {
+    if (!this.paused)
+      return;
+    this.paused = false;
+    this.running = true;
+    this.lastTime = performance.now();
+    this.rafId = requestAnimationFrame(this.frame);
+  }
+  get isRunning() {
+    return this.running;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  frame = (time) => {
+    if (!this.running)
+      return;
+    const dt = Math.min((time - this.lastTime) / 1000, 0.1);
+    this.lastTime = time;
+    if (this.hitPauseTimer > 0) {
+      this.hitPauseTimer -= dt;
+    } else {
+      this.onTick(dt);
+    }
+    this.rafId = requestAnimationFrame(this.frame);
+  };
+}
+// ../core/src/events/eventBus.ts
+class EventBus {
+  listeners = new Map;
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set);
+    }
+    this.listeners.get(event).add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  emit(event, data) {
+    this.listeners.get(event)?.forEach((l) => l(data));
+  }
+  once(event, listener) {
+    const wrapper = (data) => {
+      listener(data);
+      this.off(event, wrapper);
+    };
+    return this.on(event, wrapper);
+  }
+  clear(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+}
+// ../core/src/assets/assetManager.ts
+class AssetManager {
+  images = new Map;
+  audio = new Map;
+  audioCtx = null;
+  activeSources = new Map;
+  getAudioContext() {
+    if (!this.audioCtx) {
+      this.audioCtx = new AudioContext;
+    }
+    return this.audioCtx;
+  }
+  async loadImage(src) {
+    if (this.images.has(src))
+      return this.images.get(src);
+    const img = new Image;
+    img.src = src;
+    try {
+      await new Promise((resolve, reject) => {
+        img.onload = () => resolve();
+        img.onerror = () => reject(new Error(`Failed to load image: ${src}`));
+      });
+    } catch (err) {
+      console.warn(`[Cubeforge] Failed to load image: ${src}`);
+      throw err;
+    }
+    this.images.set(src, img);
+    return img;
+  }
+  getImage(src) {
+    return this.images.get(src);
+  }
+  async loadAudio(src) {
+    if (this.audio.has(src))
+      return this.audio.get(src);
+    const ctx = this.getAudioContext();
+    try {
+      const response = await fetch(src);
+      const arrayBuffer = await response.arrayBuffer();
+      const audioBuffer = await ctx.decodeAudioData(arrayBuffer);
+      this.audio.set(src, audioBuffer);
+      return audioBuffer;
+    } catch (err) {
+      console.warn(`[Cubeforge] Failed to load audio: ${src}`);
+      throw err;
+    }
+  }
+  trackSource(src, source) {
+    let set = this.activeSources.get(src);
+    if (!set) {
+      set = new Set;
+      this.activeSources.set(src, set);
+    }
+    set.add(source);
+    source.onended = () => {
+      set.delete(source);
+    };
+  }
+  playAudio(src, volume = 1) {
+    const buffer = this.audio.get(src);
+    if (!buffer)
+      return;
+    const ctx = this.getAudioContext();
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    const gainNode = ctx.createGain();
+    gainNode.gain.value = volume;
+    source.connect(gainNode);
+    gainNode.connect(ctx.destination);
+    this.trackSource(src, source);
+    source.start();
+  }
+  playLoopAudio(src, volume = 1) {
+    const buffer = this.audio.get(src);
+    if (!buffer)
+      return null;
+    const ctx = this.getAudioContext();
+    const source = ctx.createBufferSource();
+    source.buffer = buffer;
+    source.loop = true;
+    const gainNode = ctx.createGain();
+    gainNode.gain.value = volume;
+    source.connect(gainNode);
+    gainNode.connect(ctx.destination);
+    this.trackSource(src, source);
+    source.start();
+    return source;
+  }
+  stopAudio(src) {
+    const set = this.activeSources.get(src);
+    if (!set)
+      return;
+    for (const source of set) {
+      try {
+        source.stop();
+      } catch {}
+    }
+    set.clear();
+  }
+  stopAll() {
+    for (const [src] of this.activeSources) {
+      this.stopAudio(src);
+    }
+    this.activeSources.clear();
+  }
+  preloadImages(srcs) {
+    return Promise.all(srcs.map((src) => this.loadImage(src)));
+  }
+  preloadAudio(srcs) {
+    return Promise.all(srcs.map((src) => this.loadAudio(src)));
+  }
+}
+// ../core/src/components/transform.ts
+function createTransform(x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1) {
+  return { type: "Transform", x, y, rotation, scaleX, scaleY };
+}
+// ../core/src/components/tag.ts
+function createTag(...tags) {
+  return { type: "Tag", tags };
+}
+// ../core/src/components/script.ts
+function createScript(update) {
+  return { type: "Script", update };
+}
+// ../core/src/systems/scriptSystem.ts
+class ScriptSystem {
+  input;
+  constructor(input) {
+    this.input = input;
+  }
+  update(world, dt) {
+    const entities = world.query("Script");
+    for (const id of entities) {
+      const script = world.getComponent(id, "Script");
+      try {
+        script.update(id, world, this.input, dt);
+      } catch (err) {
+        console.error(`[Cubeforge] Script update error on entity ${id}:`, err);
+      }
+    }
+  }
+}
+// ../core/src/tween.ts
+var Ease = {
+  linear: (t) => t,
+  easeInQuad: (t) => t * t,
+  easeOutQuad: (t) => t * (2 - t),
+  easeInOutQuad: (t) => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t,
+  easeOutBack: (t) => {
+    const c1 = 1.70158;
+    const c3 = c1 + 1;
+    return 1 + c3 * Math.pow(t - 1, 3) + c1 * Math.pow(t - 1, 2);
+  }
+};
+function tween(from, to, duration, ease = Ease.linear, onUpdate, onComplete) {
+  let elapsed = 0;
+  let stopped = false;
+  let complete = false;
+  return {
+    get isComplete() {
+      return complete;
+    },
+    stop() {
+      stopped = true;
+    },
+    update(dt) {
+      if (stopped || complete)
+        return;
+      elapsed = Math.min(elapsed + dt, duration);
+      const t = duration > 0 ? elapsed / duration : 1;
+      onUpdate(from + (to - from) * ease(t));
+      if (elapsed >= duration) {
+        complete = true;
+        onComplete?.();
+      }
+    }
+  };
+}
+// ../core/src/plugin.ts
+function definePlugin(plugin) {
+  return plugin;
+}
+// ../input/src/keyboard.ts
+class Keyboard {
+  held = new Set;
+  justPressed = new Set;
+  justReleased = new Set;
+  target = null;
+  onKeyDown = (e) => {
+    if (!this.held.has(e.code)) {
+      this.justPressed.add(e.code);
+    }
+    this.held.add(e.code);
+    if (!this.held.has(e.key)) {
+      this.justPressed.add(e.key);
+    }
+    this.held.add(e.key);
+  };
+  onKeyUp = (e) => {
+    this.held.delete(e.code);
+    this.held.delete(e.key);
+    this.justReleased.add(e.code);
+    this.justReleased.add(e.key);
+  };
+  attach(target = window) {
+    this.target = target;
+    target.addEventListener("keydown", this.onKeyDown);
+    target.addEventListener("keyup", this.onKeyUp);
+  }
+  detach() {
+    if (!this.target)
+      return;
+    this.target.removeEventListener("keydown", this.onKeyDown);
+    this.target.removeEventListener("keyup", this.onKeyUp);
+    this.target = null;
+  }
+  isDown(key) {
+    return this.held.has(key);
+  }
+  isPressed(key) {
+    return this.justPressed.has(key);
+  }
+  isReleased(key) {
+    return this.justReleased.has(key);
+  }
+  flush() {
+    this.justPressed.clear();
+    this.justReleased.clear();
+  }
+}
+// ../input/src/mouse.ts
+class Mouse {
+  x = 0;
+  y = 0;
+  dx = 0;
+  dy = 0;
+  held = new Set;
+  justPressed = new Set;
+  justReleased = new Set;
+  target = null;
+  onMouseMove = (e) => {
+    if (!this.target)
+      return;
+    const rect2 = this.target.getBoundingClientRect();
+    this.dx = e.clientX - rect2.left - this.x;
+    this.dy = e.clientY - rect2.top - this.y;
+    this.x = e.clientX - rect2.left;
+    this.y = e.clientY - rect2.top;
+  };
+  onMouseDown = (e) => {
+    if (!this.held.has(e.button)) {
+      this.justPressed.add(e.button);
+    }
+    this.held.add(e.button);
+  };
+  onMouseUp = (e) => {
+    this.held.delete(e.button);
+    this.justReleased.add(e.button);
+  };
+  onContextMenu = (e) => {
+    e.preventDefault();
+  };
+  attach(target) {
+    this.target = target;
+    target.addEventListener("mousemove", this.onMouseMove);
+    target.addEventListener("mousedown", this.onMouseDown);
+    target.addEventListener("mouseup", this.onMouseUp);
+    target.addEventListener("contextmenu", this.onContextMenu);
+  }
+  detach() {
+    if (!this.target)
+      return;
+    this.target.removeEventListener("mousemove", this.onMouseMove);
+    this.target.removeEventListener("mousedown", this.onMouseDown);
+    this.target.removeEventListener("mouseup", this.onMouseUp);
+    this.target.removeEventListener("contextmenu", this.onContextMenu);
+    this.target = null;
+  }
+  isDown(button = 0) {
+    return this.held.has(button);
+  }
+  isPressed(button = 0) {
+    return this.justPressed.has(button);
+  }
+  isReleased(button = 0) {
+    return this.justReleased.has(button);
+  }
+  flush() {
+    this.justPressed.clear();
+    this.justReleased.clear();
+    this.dx = 0;
+    this.dy = 0;
+  }
+}
+// ../input/src/inputManager.ts
+class InputManager {
+  keyboard = new Keyboard;
+  mouse = new Mouse;
+  attach(canvas) {
+    this.keyboard.attach(window);
+    this.mouse.attach(canvas);
+  }
+  detach() {
+    this.keyboard.detach();
+    this.mouse.detach();
+  }
+  flush() {
+    this.keyboard.flush();
+    this.mouse.flush();
+  }
+  isDown(key) {
+    return this.keyboard.isDown(key);
+  }
+  isPressed(key) {
+    return this.keyboard.isPressed(key);
+  }
+  isReleased(key) {
+    return this.keyboard.isReleased(key);
+  }
+}
+// ../renderer/src/canvas2d.ts
+class Canvas2DRenderer {
+  canvas;
+  ctx;
+  constructor(canvas) {
+    this.canvas = canvas;
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+      throw new Error("Could not get 2D context from canvas");
+    this.ctx = ctx;
+  }
+  clear(color) {
+    if (color) {
+      this.ctx.fillStyle = color;
+      this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+    } else {
+      this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    }
+  }
+  get width() {
+    return this.canvas.width;
+  }
+  get height() {
+    return this.canvas.height;
+  }
+}
+// ../renderer/src/components/sprite.ts
+function createSprite(opts) {
+  return {
+    type: "Sprite",
+    color: "#ffffff",
+    offsetX: 0,
+    offsetY: 0,
+    zIndex: 0,
+    visible: true,
+    flipX: false,
+    anchorX: 0.5,
+    anchorY: 0.5,
+    frameIndex: 0,
+    ...opts
+  };
+}
+// ../renderer/src/components/camera2d.ts
+function createCamera2D(opts) {
+  return {
+    type: "Camera2D",
+    x: 0,
+    y: 0,
+    zoom: 1,
+    smoothing: 0,
+    background: "#1a1a2e",
+    shakeIntensity: 0,
+    shakeDuration: 0,
+    shakeTimer: 0,
+    ...opts
+  };
+}
+// ../renderer/src/renderSystem.ts
+var imageCache = new Map;
+
+class RenderSystem {
+  renderer;
+  entityIds;
+  debug = false;
+  pendingShake = null;
+  frameTimes = [];
+  lastTimestamp = 0;
+  constructor(renderer, entityIds) {
+    this.renderer = renderer;
+    this.entityIds = entityIds;
+  }
+  setDebug(v) {
+    this.debug = v;
+  }
+  triggerShake(intensity, duration) {
+    this.pendingShake = { intensity, duration };
+  }
+  update(world2, dt) {
+    const { ctx, canvas } = this.renderer;
+    const now = performance.now();
+    if (this.lastTimestamp > 0) {
+      this.frameTimes.push(now - this.lastTimestamp);
+      if (this.frameTimes.length > 60)
+        this.frameTimes.shift();
+    }
+    this.lastTimestamp = now;
+    let camX = 0;
+    let camY = 0;
+    let zoom = 1;
+    let background = "#000000";
+    let shakeX = 0;
+    let shakeY = 0;
+    const camEntityId = world2.queryOne("Camera2D");
+    if (camEntityId !== undefined) {
+      const cam = world2.getComponent(camEntityId, "Camera2D");
+      background = cam.background;
+      if (this.pendingShake) {
+        cam.shakeIntensity = this.pendingShake.intensity;
+        cam.shakeDuration = this.pendingShake.duration;
+        cam.shakeTimer = this.pendingShake.duration;
+        this.pendingShake = null;
+      }
+      if (cam.followEntityId) {
+        const targetId = this.entityIds.get(cam.followEntityId);
+        if (targetId !== undefined) {
+          const targetTransform = world2.getComponent(targetId, "Transform");
+          if (targetTransform) {
+            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;
+              if (dx > halfW)
+                cam.x = targetTransform.x - halfW;
+              else if (dx < -halfW)
+                cam.x = targetTransform.x + halfW;
+              if (dy > halfH)
+                cam.y = targetTransform.y - halfH;
+              else if (dy < -halfH)
+                cam.y = targetTransform.y + halfH;
+            } else if (cam.smoothing > 0) {
+              cam.x += (targetTransform.x - cam.x) * (1 - cam.smoothing);
+              cam.y += (targetTransform.y - cam.y) * (1 - cam.smoothing);
+            } else {
+              cam.x = targetTransform.x;
+              cam.y = targetTransform.y;
+            }
+          }
+        }
+      }
+      if (cam.bounds) {
+        const halfW = canvas.width / (2 * cam.zoom);
+        const halfH = canvas.height / (2 * cam.zoom);
+        cam.x = Math.max(cam.bounds.x + halfW, Math.min(cam.bounds.x + cam.bounds.width - halfW, cam.x));
+        cam.y = Math.max(cam.bounds.y + halfH, Math.min(cam.bounds.y + cam.bounds.height - halfH, cam.y));
+      }
+      if (cam.shakeTimer > 0) {
+        cam.shakeTimer -= dt;
+        if (cam.shakeTimer < 0)
+          cam.shakeTimer = 0;
+        const progress = cam.shakeDuration > 0 ? cam.shakeTimer / cam.shakeDuration : 0;
+        shakeX = (Math.random() * 2 - 1) * cam.shakeIntensity * progress;
+        shakeY = (Math.random() * 2 - 1) * cam.shakeIntensity * progress;
+      }
+      camX = cam.x;
+      camY = cam.y;
+      zoom = cam.zoom;
+    }
+    for (const id of world2.query("AnimationState", "Sprite")) {
+      const anim = world2.getComponent(id, "AnimationState");
+      const sprite = world2.getComponent(id, "Sprite");
+      if (!anim.playing || anim.frames.length === 0)
+        continue;
+      anim.timer += dt;
+      const frameDuration = 1 / anim.fps;
+      while (anim.timer >= frameDuration) {
+        anim.timer -= frameDuration;
+        anim.currentIndex++;
+        if (anim.currentIndex >= anim.frames.length) {
+          anim.currentIndex = anim.loop ? 0 : anim.frames.length - 1;
+        }
+      }
+      sprite.frameIndex = anim.frames[anim.currentIndex];
+    }
+    for (const id of world2.query("SquashStretch", "RigidBody")) {
+      const ss = world2.getComponent(id, "SquashStretch");
+      const rb = world2.getComponent(id, "RigidBody");
+      const speed = Math.sqrt(rb.vx * rb.vx + rb.vy * rb.vy);
+      const targetScaleX = rb.vy < -100 ? 1 + ss.intensity * 0.4 : speed > 50 ? 1 - ss.intensity * 0.3 : 1;
+      const targetScaleY = rb.vy < -100 ? 1 - ss.intensity * 0.4 : speed > 50 ? 1 + ss.intensity * 0.3 : 1;
+      ss.currentScaleX += (targetScaleX - ss.currentScaleX) * ss.recovery * dt;
+      ss.currentScaleY += (targetScaleY - ss.currentScaleY) * ss.recovery * dt;
+    }
+    this.renderer.clear(background);
+    const parallaxEntities = world2.query("ParallaxLayer");
+    parallaxEntities.sort((a, b) => {
+      const za = world2.getComponent(a, "ParallaxLayer").zIndex;
+      const zb = world2.getComponent(b, "ParallaxLayer").zIndex;
+      return za - zb;
+    });
+    for (const id of parallaxEntities) {
+      const layer = world2.getComponent(id, "ParallaxLayer");
+      let img = imageCache.get(layer.src);
+      if (!img) {
+        img = new Image;
+        img.src = layer.src;
+        img.onload = () => {
+          layer.imageWidth = img.naturalWidth;
+          layer.imageHeight = img.naturalHeight;
+        };
+        imageCache.set(layer.src, img);
+      }
+      if (!img.complete || img.naturalWidth === 0)
+        continue;
+      if (layer.imageWidth === 0)
+        layer.imageWidth = img.naturalWidth;
+      if (layer.imageHeight === 0)
+        layer.imageHeight = img.naturalHeight;
+      const imgW = layer.imageWidth;
+      const imgH = layer.imageHeight;
+      const drawX = layer.offsetX - camX * layer.speedX;
+      const drawY = layer.offsetY - camY * layer.speedY;
+      ctx.save();
+      if (layer.repeatX || layer.repeatY) {
+        const pattern = ctx.createPattern(img, layer.repeatX && layer.repeatY ? "repeat" : layer.repeatX ? "repeat-x" : "repeat-y");
+        if (pattern) {
+          const offsetX = (drawX % imgW + imgW) % imgW;
+          const offsetY = (drawY % imgH + imgH) % imgH;
+          const matrix = new DOMMatrix;
+          matrix.translateSelf(offsetX, offsetY);
+          pattern.setTransform(matrix);
+          ctx.fillStyle = pattern;
+          ctx.fillRect(0, 0, canvas.width, canvas.height);
+        }
+      } else {
+        ctx.drawImage(img, drawX, drawY, imgW, imgH);
+      }
+      ctx.restore();
+    }
+    ctx.save();
+    ctx.translate(canvas.width / 2 - camX * zoom + shakeX, canvas.height / 2 - camY * zoom + shakeY);
+    ctx.scale(zoom, zoom);
+    const renderables = world2.query("Transform", "Sprite");
+    renderables.sort((a, b) => {
+      const za = world2.getComponent(a, "Sprite").zIndex;
+      const zb = world2.getComponent(b, "Sprite").zIndex;
+      return za - zb;
+    });
+    for (const id of renderables) {
+      const transform2 = world2.getComponent(id, "Transform");
+      const sprite = world2.getComponent(id, "Sprite");
+      if (!sprite.visible)
+        continue;
+      const ss = world2.getComponent(id, "SquashStretch");
+      const scaleXMod = ss ? ss.currentScaleX : 1;
+      const scaleYMod = ss ? ss.currentScaleY : 1;
+      ctx.save();
+      ctx.translate(transform2.x, transform2.y);
+      ctx.rotate(transform2.rotation);
+      ctx.scale(transform2.scaleX * (sprite.flipX ? -1 : 1) * scaleXMod, transform2.scaleY * scaleYMod);
+      const drawX = -sprite.anchorX * sprite.width + sprite.offsetX;
+      const drawY = -sprite.anchorY * sprite.height + sprite.offsetY;
+      if (sprite.image && sprite.image.complete && sprite.image.naturalWidth > 0) {
+        if (sprite.frameWidth && sprite.frameHeight) {
+          const cols = sprite.frameColumns ?? Math.floor(sprite.image.naturalWidth / sprite.frameWidth);
+          const col = sprite.frameIndex % cols;
+          const row = Math.floor(sprite.frameIndex / cols);
+          const sx = col * sprite.frameWidth;
+          const sy = row * sprite.frameHeight;
+          ctx.drawImage(sprite.image, sx, sy, sprite.frameWidth, sprite.frameHeight, drawX, drawY, sprite.width, sprite.height);
+        } else if (sprite.frame) {
+          const { sx, sy, sw, sh } = sprite.frame;
+          ctx.drawImage(sprite.image, sx, sy, sw, sh, drawX, drawY, sprite.width, sprite.height);
+        } else {
+          ctx.drawImage(sprite.image, drawX, drawY, sprite.width, sprite.height);
+        }
+      } else {
+        ctx.fillStyle = sprite.color;
+        ctx.fillRect(drawX, drawY, sprite.width, sprite.height);
+      }
+      ctx.restore();
+    }
+    for (const id of world2.query("Transform", "ParticlePool")) {
+      const t = world2.getComponent(id, "Transform");
+      const pool = world2.getComponent(id, "ParticlePool");
+      pool.particles = pool.particles.filter((p) => {
+        p.life -= dt;
+        p.x += p.vx * dt;
+        p.y += p.vy * dt;
+        p.vy += p.gravity * dt;
+        return p.life > 0;
+      });
+      if (pool.active && pool.particles.length < pool.maxParticles) {
+        pool.timer += dt;
+        const spawnCount = Math.floor(pool.timer * pool.rate);
+        pool.timer -= spawnCount / pool.rate;
+        for (let i = 0;i < spawnCount && pool.particles.length < pool.maxParticles; i++) {
+          const angle = pool.angle + (Math.random() - 0.5) * pool.spread;
+          const speed = pool.speed * (0.5 + Math.random() * 0.5);
+          pool.particles.push({
+            x: t.x,
+            y: t.y,
+            vx: Math.cos(angle) * speed,
+            vy: Math.sin(angle) * speed,
+            life: pool.particleLife,
+            maxLife: pool.particleLife,
+            size: pool.particleSize,
+            color: pool.color,
+            gravity: pool.gravity
+          });
+        }
+      }
+      for (const p of pool.particles) {
+        const alpha = p.life / p.maxLife;
+        ctx.globalAlpha = alpha;
+        ctx.fillStyle = p.color;
+        ctx.fillRect(p.x - p.size / 2, p.y - p.size / 2, p.size, p.size);
+      }
+      ctx.globalAlpha = 1;
+    }
+    if (this.debug) {
+      ctx.lineWidth = 1;
+      for (const id of world2.query("Transform", "BoxCollider")) {
+        const t = world2.getComponent(id, "Transform");
+        const c = world2.getComponent(id, "BoxCollider");
+        ctx.strokeStyle = c.isTrigger ? "rgba(255,200,0,0.6)" : "rgba(0,255,0,0.6)";
+        ctx.strokeRect(t.x + c.offsetX - c.width / 2, t.y + c.offsetY - c.height / 2, c.width, c.height);
+      }
+    }
+    ctx.restore();
+    if (this.debug && this.frameTimes.length > 0) {
+      const avgMs = this.frameTimes.reduce((a, b) => a + b, 0) / this.frameTimes.length;
+      const fps = Math.round(1000 / avgMs);
+      ctx.save();
+      ctx.fillStyle = "rgba(0,0,0,0.5)";
+      ctx.fillRect(4, 4, 64, 20);
+      ctx.fillStyle = "#00ff00";
+      ctx.font = "12px monospace";
+      ctx.fillText(`FPS: ${fps}`, 8, 19);
+      ctx.restore();
+    }
+  }
+}
+// ../physics/src/components/rigidbody.ts
+function createRigidBody(opts) {
+  return {
+    type: "RigidBody",
+    vx: 0,
+    vy: 0,
+    mass: 1,
+    gravityScale: 1,
+    isStatic: false,
+    onGround: false,
+    isNearGround: false,
+    bounce: 0,
+    friction: 0.85,
+    ...opts
+  };
+}
+// ../physics/src/components/boxCollider.ts
+function createBoxCollider(width, height, opts) {
+  return {
+    type: "BoxCollider",
+    width,
+    height,
+    offsetX: 0,
+    offsetY: 0,
+    isTrigger: false,
+    layer: "default",
+    slope: 0,
+    ...opts
+  };
+}
+// ../physics/src/physicsSystem.ts
+function getAABB(transform2, collider) {
+  return {
+    cx: transform2.x + collider.offsetX,
+    cy: transform2.y + collider.offsetY,
+    hw: collider.width / 2,
+    hh: collider.height / 2
+  };
+}
+function getOverlap(a, b) {
+  const dx = a.cx - b.cx;
+  const dy = a.cy - b.cy;
+  const ox = a.hw + b.hw - Math.abs(dx);
+  const oy = a.hh + b.hh - Math.abs(dy);
+  if (ox <= 0 || oy <= 0)
+    return null;
+  return {
+    x: dx >= 0 ? ox : -ox,
+    y: dy >= 0 ? oy : -oy
+  };
+}
+function getSlopeSurfaceY(st, sc, worldX) {
+  const hw = sc.width / 2;
+  const hh = sc.height / 2;
+  const cx = st.x + sc.offsetX;
+  const cy = st.y + sc.offsetY;
+  const left = cx - hw;
+  const right = cx + hw;
+  if (worldX < left || worldX > right)
+    return null;
+  const dx = worldX - left;
+  const angleRad = sc.slope * (Math.PI / 180);
+  return cy - hh + dx * Math.tan(angleRad);
+}
+
+class PhysicsSystem {
+  gravity;
+  events;
+  accumulator = 0;
+  FIXED_DT = 1 / 60;
+  constructor(gravity, events) {
+    this.gravity = gravity;
+    this.events = events;
+  }
+  setGravity(g) {
+    this.gravity = g;
+  }
+  update(world2, dt) {
+    this.accumulator += dt;
+    if (this.accumulator > 5 * this.FIXED_DT) {
+      this.accumulator = 5 * this.FIXED_DT;
+    }
+    while (this.accumulator >= this.FIXED_DT) {
+      this.step(world2, this.FIXED_DT);
+      this.accumulator -= this.FIXED_DT;
+    }
+  }
+  getCells(cx, cy, hw, hh) {
+    const CELL = 128;
+    const x0 = Math.floor((cx - hw) / CELL);
+    const x1 = Math.floor((cx + hw) / CELL);
+    const y0 = Math.floor((cy - hh) / CELL);
+    const y1 = Math.floor((cy + hh) / CELL);
+    const cells = [];
+    for (let x = x0;x <= x1; x++)
+      for (let y = y0;y <= y1; y++)
+        cells.push(`${x},${y}`);
+    return cells;
+  }
+  step(world2, dt) {
+    const all = world2.query("Transform", "RigidBody", "BoxCollider");
+    const dynamics = [];
+    const statics = [];
+    for (const id of all) {
+      const rb = world2.getComponent(id, "RigidBody");
+      if (rb.isStatic)
+        statics.push(id);
+      else
+        dynamics.push(id);
+    }
+    const staticGrid = new Map;
+    for (const sid of statics) {
+      const st = world2.getComponent(sid, "Transform");
+      const sc = world2.getComponent(sid, "BoxCollider");
+      const aabb = getAABB(st, sc);
+      for (const cell of this.getCells(aabb.cx, aabb.cy, aabb.hw, aabb.hh)) {
+        let bucket = staticGrid.get(cell);
+        if (!bucket) {
+          bucket = [];
+          staticGrid.set(cell, bucket);
+        }
+        bucket.push(sid);
+      }
+    }
+    for (const id of dynamics) {
+      const rb = world2.getComponent(id, "RigidBody");
+      rb.onGround = false;
+      rb.isNearGround = false;
+      rb.vy += this.gravity * rb.gravityScale * dt;
+    }
+    for (const id of dynamics) {
+      const transform2 = world2.getComponent(id, "Transform");
+      const rb = world2.getComponent(id, "RigidBody");
+      const col = world2.getComponent(id, "BoxCollider");
+      transform2.x += rb.vx * dt;
+      if (!col.isTrigger) {
+        const dynAABB = getAABB(transform2, col);
+        const candidateCells = this.getCells(dynAABB.cx, dynAABB.cy, dynAABB.hw, dynAABB.hh);
+        const checked = new Set;
+        for (const cell of candidateCells) {
+          const bucket = staticGrid.get(cell);
+          if (!bucket)
+            continue;
+          for (const sid of bucket) {
+            if (checked.has(sid))
+              continue;
+            checked.add(sid);
+            const st = world2.getComponent(sid, "Transform");
+            const sc = world2.getComponent(sid, "BoxCollider");
+            if (sc.isTrigger)
+              continue;
+            if (sc.slope !== 0)
+              continue;
+            const ov = getOverlap(getAABB(transform2, col), getAABB(st, sc));
+            if (!ov)
+              continue;
+            if (Math.abs(ov.x) < Math.abs(ov.y)) {
+              transform2.x += ov.x;
+              rb.vx = rb.bounce > 0 ? -rb.vx * rb.bounce : 0;
+            }
+          }
+        }
+      }
+    }
+    for (const id of dynamics) {
+      const transform2 = world2.getComponent(id, "Transform");
+      const rb = world2.getComponent(id, "RigidBody");
+      const col = world2.getComponent(id, "BoxCollider");
+      transform2.y += rb.vy * dt;
+      if (!col.isTrigger) {
+        const dynAABB = getAABB(transform2, col);
+        const candidateCells = this.getCells(dynAABB.cx, dynAABB.cy, dynAABB.hw, dynAABB.hh);
+        const checked = new Set;
+        for (const cell of candidateCells) {
+          const bucket = staticGrid.get(cell);
+          if (!bucket)
+            continue;
+          for (const sid of bucket) {
+            if (checked.has(sid))
+              continue;
+            checked.add(sid);
+            const st = world2.getComponent(sid, "Transform");
+            const sc = world2.getComponent(sid, "BoxCollider");
+            if (sc.isTrigger)
+              continue;
+            if (sc.slope !== 0) {
+              const ov2 = getOverlap(getAABB(transform2, col), getAABB(st, sc));
+              if (!ov2)
+                continue;
+              const entityBottom = transform2.y + col.offsetY + col.height / 2;
+              const entityCenterX = transform2.x + col.offsetX;
+              const surfaceY = getSlopeSurfaceY(st, sc, entityCenterX);
+              if (surfaceY !== null && entityBottom > surfaceY) {
+                transform2.y -= entityBottom - surfaceY;
+                rb.onGround = true;
+                if (rb.friction < 1)
+                  rb.vx *= rb.friction;
+                rb.vy = rb.bounce > 0 ? -rb.vy * rb.bounce : 0;
+              }
+              continue;
+            }
+            const ov = getOverlap(getAABB(transform2, col), getAABB(st, sc));
+            if (!ov)
+              continue;
+            if (Math.abs(ov.y) <= Math.abs(ov.x)) {
+              transform2.y += ov.y;
+              if (ov.y < 0) {
+                rb.onGround = true;
+                if (rb.friction < 1)
+                  rb.vx *= rb.friction;
+              }
+              rb.vy = rb.bounce > 0 ? -rb.vy * rb.bounce : 0;
+            }
+          }
+        }
+      }
+    }
+    for (let i = 0;i < dynamics.length; i++) {
+      for (let j = i + 1;j < dynamics.length; j++) {
+        const ia = dynamics[i];
+        const ib = dynamics[j];
+        const ta = world2.getComponent(ia, "Transform");
+        const tb = world2.getComponent(ib, "Transform");
+        const ca = world2.getComponent(ia, "BoxCollider");
+        const cb = world2.getComponent(ib, "BoxCollider");
+        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 });
+          continue;
+        }
+        const rba = world2.getComponent(ia, "RigidBody");
+        const rbb = world2.getComponent(ib, "RigidBody");
+        if (Math.abs(ov.y) <= Math.abs(ov.x)) {
+          if (ov.y > 0) {
+            if (rbb.vy > 0) {
+              rba.vy += rbb.vy * 0.3;
+              rbb.vy = 0;
+            }
+            rbb.onGround = true;
+          } else {
+            if (rba.vy > 0) {
+              rbb.vy += rba.vy * 0.3;
+              rba.vy = 0;
+            }
+            rba.onGround = true;
+          }
+        }
+        ta.x += ov.x / 2;
+        ta.y += ov.y / 2;
+        tb.x -= ov.x / 2;
+        tb.y -= ov.y / 2;
+        this.events?.emit("collision", { a: ia, b: ib });
+      }
+    }
+    for (const id of dynamics) {
+      const rb = world2.getComponent(id, "RigidBody");
+      if (rb.onGround) {
+        rb.isNearGround = true;
+        continue;
+      }
+      const transform2 = world2.getComponent(id, "Transform");
+      const col = world2.getComponent(id, "BoxCollider");
+      const probeAABB = {
+        cx: transform2.x + col.offsetX,
+        cy: transform2.y + col.offsetY + 2,
+        hw: col.width / 2,
+        hh: col.height / 2
+      };
+      const candidateCells = this.getCells(probeAABB.cx, probeAABB.cy, probeAABB.hw, probeAABB.hh);
+      const checked = new Set;
+      outer:
+        for (const cell of candidateCells) {
+          const bucket = staticGrid.get(cell);
+          if (!bucket)
+            continue;
+          for (const sid of bucket) {
+            if (checked.has(sid))
+              continue;
+            checked.add(sid);
+            const st = world2.getComponent(sid, "Transform");
+            const sc = world2.getComponent(sid, "BoxCollider");
+            if (sc.isTrigger)
+              continue;
+            const ov = getOverlap(probeAABB, getAABB(st, sc));
+            if (ov && Math.abs(ov.y) <= Math.abs(ov.x) && ov.y < 0) {
+              rb.isNearGround = true;
+              break outer;
+            }
+          }
+        }
+    }
+  }
+}
+// src/context.ts
+import { createContext } from "react";
+var EngineContext = createContext(null);
+var EntityContext = createContext(null);
+
+// src/systems/debugSystem.ts
+class DebugSystem {
+  renderer;
+  frameCount = 0;
+  lastFpsTime = 0;
+  fps = 0;
+  constructor(renderer) {
+    this.renderer = renderer;
+  }
+  update(world2, dt) {
+    const { ctx, canvas } = this.renderer;
+    this.frameCount++;
+    this.lastFpsTime += dt;
+    if (this.lastFpsTime >= 0.5) {
+      this.fps = Math.round(this.frameCount / this.lastFpsTime);
+      this.frameCount = 0;
+      this.lastFpsTime = 0;
+    }
+    const camId = world2.queryOne("Camera2D");
+    let camX = 0, camY = 0, zoom = 1;
+    if (camId !== undefined) {
+      const cam = world2.getComponent(camId, "Camera2D");
+      camX = cam.x;
+      camY = cam.y;
+      zoom = cam.zoom;
+    }
+    ctx.save();
+    ctx.translate(canvas.width / 2 - camX * zoom, canvas.height / 2 - camY * zoom);
+    ctx.scale(zoom, zoom);
+    const lw = 1 / zoom;
+    for (const id of world2.query("Transform", "BoxCollider")) {
+      const t = world2.getComponent(id, "Transform");
+      const c = world2.getComponent(id, "BoxCollider");
+      ctx.strokeStyle = c.isTrigger ? "rgba(255,200,0,0.85)" : "rgba(0,255,120,0.85)";
+      ctx.lineWidth = lw;
+      ctx.strokeRect(t.x + c.offsetX - c.width / 2, t.y + c.offsetY - c.height / 2, c.width, c.height);
+      ctx.fillStyle = "rgba(255,255,255,0.5)";
+      ctx.font = `${10 / zoom}px monospace`;
+      ctx.fillText(String(id), t.x + c.offsetX - c.width / 2 + lw, t.y + c.offsetY - c.height / 2 - lw * 2);
+    }
+    if (camId !== undefined) {
+      const camFull = world2.getComponent(camId, "Camera2D");
+      if (camFull.bounds) {
+        const b = camFull.bounds;
+        ctx.strokeStyle = "rgba(0, 255, 255, 0.4)";
+        ctx.lineWidth = 1 / zoom;
+        ctx.setLineDash([8 / zoom, 4 / zoom]);
+        ctx.strokeRect(b.x, b.y, b.width, b.height);
+        ctx.setLineDash([]);
+      }
+    }
+    ctx.restore();
+    const GRID_SIZE = 128;
+    ctx.save();
+    ctx.strokeStyle = "rgba(255, 255, 255, 0.04)";
+    ctx.lineWidth = 1;
+    ctx.setLineDash([]);
+    const offsetX = camX - canvas.width / (2 * zoom);
+    const offsetY = camY - canvas.height / (2 * zoom);
+    const visibleW = canvas.width / zoom;
+    const visibleH = canvas.height / zoom;
+    const startCol = Math.floor(offsetX / GRID_SIZE);
+    const endCol = Math.ceil((offsetX + visibleW) / GRID_SIZE);
+    const startRow = Math.floor(offsetY / GRID_SIZE);
+    const endRow = Math.ceil((offsetY + visibleH) / GRID_SIZE);
+    ctx.translate(canvas.width / 2 - camX * zoom, canvas.height / 2 - camY * zoom);
+    ctx.scale(zoom, zoom);
+    for (let col = startCol;col <= endCol; col++) {
+      const wx = col * GRID_SIZE;
+      ctx.beginPath();
+      ctx.moveTo(wx, startRow * GRID_SIZE);
+      ctx.lineTo(wx, endRow * GRID_SIZE);
+      ctx.stroke();
+    }
+    for (let row = startRow;row <= endRow; row++) {
+      const wy = row * GRID_SIZE;
+      ctx.beginPath();
+      ctx.moveTo(startCol * GRID_SIZE, wy);
+      ctx.lineTo(endCol * GRID_SIZE, wy);
+      ctx.stroke();
+    }
+    ctx.restore();
+    const entityCount = world2.entityCount;
+    const physicsCount = world2.query("RigidBody", "BoxCollider").length;
+    const renderCount = world2.query("Transform", "Sprite").length;
+    ctx.save();
+    ctx.fillStyle = "rgba(0,0,0,0.65)";
+    ctx.fillRect(8, 8, 184, 84);
+    ctx.fillStyle = "#00ff88";
+    ctx.font = "11px monospace";
+    ctx.fillText(`FPS         ${this.fps}`, 16, 26);
+    ctx.fillText(`Entities    ${entityCount}`, 16, 42);
+    ctx.fillText(`Physics     ${physicsCount}`, 16, 58);
+    ctx.fillText(`Renderables ${renderCount}`, 16, 74);
+    ctx.restore();
+  }
+}
+
+// src/components/Game.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function Game({
+  width = 800,
+  height = 600,
+  gravity = 980,
+  debug = false,
+  scale = "none",
+  onReady,
+  plugins,
+  style,
+  className,
+  children
+}) {
+  const canvasRef = useRef(null);
+  const wrapperRef = useRef(null);
+  const [engine, setEngine] = useState(null);
+  useEffect(() => {
+    const canvas = canvasRef.current;
+    const ecs = new ECSWorld;
+    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;
+    ecs.addSystem(new ScriptSystem(input));
+    ecs.addSystem(physics);
+    ecs.addSystem(renderSystem2);
+    if (debugSystem)
+      ecs.addSystem(debugSystem);
+    input.attach(canvas);
+    canvas.setAttribute("tabindex", "0");
+    if (width <= 0 || height <= 0) {
+      console.warn(`[Cubeforge] Invalid Game dimensions: ${width}x${height}. Width and height must be positive.`);
+    }
+    const loop = new GameLoop((dt) => {
+      ecs.update(dt);
+      input.flush();
+    });
+    const state = { ecs, input, renderer, physics, events, assets, loop, canvas, entityIds };
+    setEngine(state);
+    if (plugins) {
+      for (const plugin2 of plugins) {
+        for (const system of plugin2.systems) {
+          ecs.addSystem(system);
+        }
+        plugin2.onInit?.(state);
+      }
+    }
+    loop.start();
+    onReady?.({
+      pause: () => loop.pause(),
+      resume: () => loop.resume(),
+      reset: () => {
+        ecs.clear();
+        loop.stop();
+        loop.start();
+      }
+    });
+    let resizeObserver = null;
+    if (scale === "contain" && wrapperRef.current) {
+      const wrapper = wrapperRef.current;
+      const updateScale = () => {
+        const parentW = wrapper.parentElement?.clientWidth ?? width;
+        const parentH = wrapper.parentElement?.clientHeight ?? height;
+        const scaleX = parentW / width;
+        const scaleY = parentH / height;
+        const s = Math.min(scaleX, scaleY);
+        canvas.style.transform = `scale(${s})`;
+        canvas.style.transformOrigin = "top left";
+      };
+      updateScale();
+      resizeObserver = new ResizeObserver(updateScale);
+      if (wrapper.parentElement)
+        resizeObserver.observe(wrapper.parentElement);
+    }
+    return () => {
+      loop.stop();
+      input.detach();
+      ecs.clear();
+      resizeObserver?.disconnect();
+    };
+  }, []);
+  useEffect(() => {
+    engine?.physics.setGravity(gravity);
+  }, [gravity, engine]);
+  const canvasStyle = {
+    display: "block",
+    outline: "none",
+    imageRendering: scale === "pixel" ? "pixelated" : undefined,
+    ...style
+  };
+  const wrapperStyle = scale === "contain" ? { position: "relative", width, height, overflow: "visible" } : {};
+  return /* @__PURE__ */ jsxDEV(EngineContext.Provider, {
+    value: engine,
+    children: [
+      /* @__PURE__ */ jsxDEV("div", {
+        ref: wrapperRef,
+        style: wrapperStyle,
+        children: /* @__PURE__ */ jsxDEV("canvas", {
+          ref: canvasRef,
+          width,
+          height,
+          style: canvasStyle,
+          className
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      engine && children
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/World.tsx
+import { useEffect as useEffect2, useContext } from "react";
+import { jsxDEV as jsxDEV2, Fragment } from "react/jsx-dev-runtime";
+function World({ gravity, background = "#1a1a2e", children }) {
+  const engine = useContext(EngineContext);
+  useEffect2(() => {
+    if (!engine)
+      return;
+    if (gravity !== undefined)
+      engine.physics.setGravity(gravity);
+  }, [gravity, engine]);
+  useEffect2(() => {
+    if (!engine)
+      return;
+    const camId = engine.ecs.queryOne("Camera2D");
+    if (camId !== undefined) {
+      const cam = engine.ecs.getComponent(camId, "Camera2D");
+      if (cam)
+        cam.background = background;
+    } else {
+      engine.canvas.style.background = background;
+    }
+  }, [background, engine]);
+  return /* @__PURE__ */ jsxDEV2(Fragment, {
+    children
+  }, undefined, false, undefined, this);
+}
+// src/components/Entity.tsx
+import { useEffect as useEffect3, useContext as useContext2, useState as useState2 } from "react";
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+function Entity({ id, tags = [], children }) {
+  const engine = useContext2(EngineContext);
+  const [entityId, setEntityId] = useState2(null);
+  useEffect3(() => {
+    const eid = engine.ecs.createEntity();
+    if (id) {
+      if (engine.entityIds.has(id)) {
+        console.warn(`[Cubeforge] Duplicate entity ID "${id}". Entity IDs must be unique — the previous entity with this ID will be replaced.`);
+      }
+      engine.entityIds.set(id, eid);
+    }
+    if (tags.length > 0)
+      engine.ecs.addComponent(eid, createTag(...tags));
+    setEntityId(eid);
+    return () => {
+      engine.ecs.destroyEntity(eid);
+      if (id)
+        engine.entityIds.delete(id);
+    };
+  }, []);
+  if (entityId === null)
+    return null;
+  return /* @__PURE__ */ jsxDEV3(EntityContext.Provider, {
+    value: entityId,
+    children
+  }, undefined, false, undefined, this);
+}
+// src/components/Transform.tsx
+import { useEffect as useEffect4, useContext as useContext3 } from "react";
+function Transform({ x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1 }) {
+  const engine = useContext3(EngineContext);
+  const entityId = useContext3(EntityContext);
+  useEffect4(() => {
+    engine.ecs.addComponent(entityId, createTransform(x, y, rotation, scaleX, scaleY));
+    return () => engine.ecs.removeComponent(entityId, "Transform");
+  }, []);
+  useEffect4(() => {
+    const comp = engine.ecs.getComponent(entityId, "Transform");
+    if (comp) {
+      comp.x = x;
+      comp.y = y;
+      comp.rotation = rotation;
+      comp.scaleX = scaleX;
+      comp.scaleY = scaleY;
+    }
+  }, [x, y, rotation, scaleX, scaleY, engine, entityId]);
+  return null;
+}
+// src/components/Sprite.tsx
+import { useEffect as useEffect5, useContext as useContext4 } from "react";
+function Sprite({
+  width,
+  height,
+  color = "#ffffff",
+  src,
+  offsetX = 0,
+  offsetY = 0,
+  zIndex = 0,
+  visible = true,
+  flipX = false,
+  anchorX = 0.5,
+  anchorY = 0.5,
+  frameIndex = 0,
+  frameWidth,
+  frameHeight,
+  frameColumns,
+  atlas,
+  frame
+}) {
+  const resolvedFrameIndex = atlas && frame != null ? atlas[frame] ?? 0 : frameIndex;
+  const engine = useContext4(EngineContext);
+  const entityId = useContext4(EntityContext);
+  useEffect5(() => {
+    const comp = createSprite({
+      width,
+      height,
+      color,
+      src,
+      offsetX,
+      offsetY,
+      zIndex,
+      visible,
+      flipX,
+      anchorX,
+      anchorY,
+      frameIndex: resolvedFrameIndex,
+      frameWidth,
+      frameHeight,
+      frameColumns
+    });
+    engine.ecs.addComponent(entityId, comp);
+    if (src) {
+      engine.assets.loadImage(src).then((img) => {
+        const c = engine.ecs.getComponent(entityId, "Sprite");
+        if (c)
+          c.image = img;
+      }).catch(console.error);
+    }
+    return () => engine.ecs.removeComponent(entityId, "Sprite");
+  }, []);
+  useEffect5(() => {
+    const comp = engine.ecs.getComponent(entityId, "Sprite");
+    if (!comp)
+      return;
+    comp.color = color;
+    comp.visible = visible;
+    comp.flipX = flipX;
+    comp.zIndex = zIndex;
+    comp.frameIndex = resolvedFrameIndex;
+  }, [color, visible, flipX, zIndex, resolvedFrameIndex, engine, entityId]);
+  return null;
+}
+// src/components/RigidBody.tsx
+import { useEffect as useEffect6, useContext as useContext5 } from "react";
+function RigidBody({
+  mass = 1,
+  gravityScale = 1,
+  isStatic = false,
+  bounce = 0,
+  friction = 0.85,
+  vx = 0,
+  vy = 0
+}) {
+  const engine = useContext5(EngineContext);
+  const entityId = useContext5(EntityContext);
+  useEffect6(() => {
+    engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy }));
+    return () => engine.ecs.removeComponent(entityId, "RigidBody");
+  }, []);
+  return null;
+}
+// src/components/BoxCollider.tsx
+import { useEffect as useEffect7, useContext as useContext6 } from "react";
+function BoxCollider({
+  width,
+  height,
+  offsetX = 0,
+  offsetY = 0,
+  isTrigger = false,
+  layer = "default"
+}) {
+  const engine = useContext6(EngineContext);
+  const entityId = useContext6(EntityContext);
+  useEffect7(() => {
+    engine.ecs.addComponent(entityId, createBoxCollider(width, height, { offsetX, offsetY, isTrigger, layer }));
+    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.`);
+      }
+    }, 0);
+    return () => {
+      clearTimeout(checkId);
+      engine.ecs.removeComponent(entityId, "BoxCollider");
+    };
+  }, []);
+  return null;
+}
+// src/components/Script.tsx
+import { useEffect as useEffect8, useContext as useContext7 } from "react";
+function Script({ init, update }) {
+  const engine = useContext7(EngineContext);
+  const entityId = useContext7(EntityContext);
+  useEffect8(() => {
+    if (init) {
+      try {
+        init(entityId, engine.ecs);
+      } catch (err) {
+        console.error(`[Cubeforge] Script init error on entity ${entityId}:`, err);
+      }
+    }
+    engine.ecs.addComponent(entityId, createScript(update));
+    return () => engine.ecs.removeComponent(entityId, "Script");
+  }, []);
+  return null;
+}
+// src/components/Camera2D.tsx
+import { useEffect as useEffect9, useContext as useContext8 } from "react";
+function Camera2D({
+  followEntity,
+  zoom = 1,
+  smoothing = 0,
+  background = "#1a1a2e",
+  bounds,
+  deadZone
+}) {
+  const engine = useContext8(EngineContext);
+  useEffect9(() => {
+    const entityId = engine.ecs.createEntity();
+    engine.ecs.addComponent(entityId, createCamera2D({
+      followEntityId: followEntity,
+      zoom,
+      smoothing,
+      background,
+      bounds,
+      deadZone
+    }));
+    return () => engine.ecs.destroyEntity(entityId);
+  }, []);
+  useEffect9(() => {
+    const camId = engine.ecs.queryOne("Camera2D");
+    if (camId === undefined)
+      return;
+    const cam = engine.ecs.getComponent(camId, "Camera2D");
+    cam.followEntityId = followEntity;
+    cam.zoom = zoom;
+    cam.smoothing = smoothing;
+    cam.background = background;
+    cam.bounds = bounds;
+    cam.deadZone = deadZone;
+  }, [followEntity, zoom, smoothing, background, bounds, deadZone, engine]);
+  return null;
+}
+// src/components/Animation.tsx
+import { useEffect as useEffect10, useContext as useContext9 } from "react";
+function Animation({ frames, fps = 12, loop = true, playing = true }) {
+  const engine = useContext9(EngineContext);
+  const entityId = useContext9(EntityContext);
+  useEffect10(() => {
+    const state = {
+      type: "AnimationState",
+      frames,
+      fps,
+      loop,
+      playing,
+      currentIndex: 0,
+      timer: 0
+    };
+    engine.ecs.addComponent(entityId, state);
+    return () => {
+      engine.ecs.removeComponent(entityId, "AnimationState");
+    };
+  }, []);
+  useEffect10(() => {
+    const anim = engine.ecs.getComponent(entityId, "AnimationState");
+    if (!anim)
+      return;
+    anim.playing = playing;
+    anim.fps = fps;
+    anim.loop = loop;
+  }, [playing, fps, loop, engine, entityId]);
+  return null;
+}
+// src/components/SquashStretch.tsx
+import { useEffect as useEffect11, useContext as useContext10 } from "react";
+function SquashStretch({ intensity = 0.2, recovery = 8 }) {
+  const engine = useContext10(EngineContext);
+  const entityId = useContext10(EntityContext);
+  useEffect11(() => {
+    engine.ecs.addComponent(entityId, {
+      type: "SquashStretch",
+      intensity,
+      recovery,
+      currentScaleX: 1,
+      currentScaleY: 1
+    });
+    return () => engine.ecs.removeComponent(entityId, "SquashStretch");
+  }, []);
+  return null;
+}
+// src/components/ParticleEmitter.tsx
+import { useEffect as useEffect12, useContext as useContext11 } from "react";
+
+// src/components/particlePresets.ts
+var PARTICLE_PRESETS = {
+  explosion: {
+    rate: 60,
+    speed: 200,
+    spread: Math.PI * 2,
+    angle: 0,
+    particleLife: 0.5,
+    particleSize: 6,
+    color: "#ff6b35",
+    gravity: 300,
+    maxParticles: 80
+  },
+  spark: {
+    rate: 40,
+    speed: 150,
+    spread: Math.PI * 2,
+    angle: 0,
+    particleLife: 0.3,
+    particleSize: 3,
+    color: "#ffd54f",
+    gravity: 400,
+    maxParticles: 50
+  },
+  smoke: {
+    rate: 15,
+    speed: 30,
+    spread: 0.5,
+    angle: -Math.PI / 2,
+    particleLife: 1.2,
+    particleSize: 10,
+    color: "#90a4ae",
+    gravity: -20,
+    maxParticles: 40
+  },
+  coinPickup: {
+    rate: 30,
+    speed: 80,
+    spread: Math.PI * 2,
+    angle: -Math.PI / 2,
+    particleLife: 0.4,
+    particleSize: 4,
+    color: "#ffd700",
+    gravity: 200,
+    maxParticles: 20
+  },
+  jumpDust: {
+    rate: 25,
+    speed: 60,
+    spread: Math.PI,
+    angle: Math.PI / 2,
+    particleLife: 0.3,
+    particleSize: 5,
+    color: "#b0bec5",
+    gravity: 80,
+    maxParticles: 20
+  }
+};
+
+// src/components/ParticleEmitter.tsx
+function ParticleEmitter({
+  active = true,
+  preset,
+  rate,
+  speed,
+  spread,
+  angle,
+  particleLife,
+  particleSize,
+  color,
+  gravity,
+  maxParticles
+}) {
+  const presetConfig = preset ? PARTICLE_PRESETS[preset] : {};
+  const resolvedRate = rate ?? presetConfig.rate ?? 20;
+  const resolvedSpeed = speed ?? presetConfig.speed ?? 80;
+  const resolvedSpread = spread ?? presetConfig.spread ?? Math.PI;
+  const resolvedAngle = angle ?? presetConfig.angle ?? -Math.PI / 2;
+  const resolvedParticleLife = particleLife ?? presetConfig.particleLife ?? 0.8;
+  const resolvedParticleSize = particleSize ?? presetConfig.particleSize ?? 4;
+  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);
+  useEffect12(() => {
+    engine.ecs.addComponent(entityId, {
+      type: "ParticlePool",
+      particles: [],
+      maxParticles: resolvedMaxParticles,
+      active,
+      rate: resolvedRate,
+      timer: 0,
+      speed: resolvedSpeed,
+      spread: resolvedSpread,
+      angle: resolvedAngle,
+      particleLife: resolvedParticleLife,
+      particleSize: resolvedParticleSize,
+      color: resolvedColor,
+      gravity: resolvedGravity
+    });
+    return () => engine.ecs.removeComponent(entityId, "ParticlePool");
+  }, []);
+  useEffect12(() => {
+    const pool = engine.ecs.getComponent(entityId, "ParticlePool");
+    if (!pool)
+      return;
+    pool.active = active;
+  }, [active, engine, entityId]);
+  return null;
+}
+// src/components/MovingPlatform.tsx
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+var platformPhases = new Map;
+function MovingPlatform({
+  x1,
+  y1,
+  x2,
+  y2,
+  width = 120,
+  height = 18,
+  duration = 3,
+  color = "#37474f"
+}) {
+  return /* @__PURE__ */ jsxDEV4(Entity, {
+    children: [
+      /* @__PURE__ */ jsxDEV4(Transform, {
+        x: x1,
+        y: y1
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV4(Sprite, {
+        width,
+        height,
+        color,
+        zIndex: 5
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV4(RigidBody, {
+        isStatic: true
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV4(BoxCollider, {
+        width,
+        height
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV4(Script, {
+        init: () => {},
+        update: (id, world2, _input, dt) => {
+          if (!world2.hasEntity(id))
+            return;
+          const t = world2.getComponent(id, "Transform");
+          if (!t)
+            return;
+          const phase = (platformPhases.get(id) ?? 0) + dt * (Math.PI * 2) / duration;
+          platformPhases.set(id, phase);
+          const alpha = (Math.sin(phase) + 1) / 2;
+          t.x = x1 + (x2 - x1) * alpha;
+          t.y = y1 + (y2 - y1) * alpha;
+        }
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/Checkpoint.tsx
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function Checkpoint({
+  x,
+  y,
+  width = 24,
+  height = 48,
+  color = "#ffd54f",
+  onActivate
+}) {
+  return /* @__PURE__ */ jsxDEV5(Entity, {
+    tags: ["checkpoint"],
+    children: [
+      /* @__PURE__ */ jsxDEV5(Transform, {
+        x,
+        y
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(Sprite, {
+        width,
+        height,
+        color,
+        zIndex: 5
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(BoxCollider, {
+        width,
+        height,
+        isTrigger: true
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV5(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;
+            }
+          }
+        }
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/Tilemap.tsx
+import { useEffect as useEffect13, useState as useState3, useContext as useContext12 } from "react";
+import { jsxDEV as jsxDEV6, Fragment as Fragment2 } from "react/jsx-dev-runtime";
+var animatedTiles = new Map;
+function getProperty(props, name) {
+  return props?.find((p) => p.name === name)?.value;
+}
+function matchesLayerName(layer, name) {
+  return layer.name === name || layer.name.toLowerCase() === name.toLowerCase();
+}
+function isCollisionLayer(layer, collisionLayer) {
+  return matchesLayerName(layer, collisionLayer) || getProperty(layer.properties, "collision") === true;
+}
+function isTriggerLayer(layer, triggerLayer) {
+  return matchesLayerName(layer, triggerLayer) || getProperty(layer.properties, "trigger") === true;
+}
+function Tilemap({
+  src,
+  onSpawnObject,
+  layerFilter,
+  zIndex = 0,
+  collisionLayer = "collision",
+  triggerLayer: triggerLayerName = "triggers",
+  onTileProperty
+}) {
+  const engine = useContext12(EngineContext);
+  const [spawnedNodes, setSpawnedNodes] = useState3([]);
+  useEffect13(() => {
+    if (!engine)
+      return;
+    const createdEntities = [];
+    async function load() {
+      let mapData;
+      try {
+        const res = await fetch(src);
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}`);
+        mapData = await res.json();
+      } catch (err) {
+        console.warn(`[Cubeforge] Tilemap: failed to load "${src}":`, err);
+        return;
+      }
+      const { tilewidth, tileheight, tilesets } = mapData;
+      function resolveTileset(gid) {
+        let tileset = null;
+        for (let i = tilesets.length - 1;i >= 0; i--) {
+          if (gid >= tilesets[i].firstgid) {
+            tileset = tilesets[i];
+            break;
+          }
+        }
+        if (!tileset)
+          return null;
+        return { tileset, localId: gid - tileset.firstgid };
+      }
+      function getTileFrame(gid) {
+        const resolved = resolveTileset(gid);
+        if (!resolved)
+          return null;
+        const { tileset, localId } = resolved;
+        const col = localId % tileset.columns;
+        const row = Math.floor(localId / tileset.columns);
+        const sx = tileset.margin + col * (tileset.tilewidth + tileset.spacing);
+        const sy = tileset.margin + row * (tileset.tileheight + tileset.spacing);
+        const base = src.substring(0, src.lastIndexOf("/") + 1);
+        const imageSrc = tileset.image.startsWith("/") ? tileset.image : base + tileset.image;
+        return { imageSrc, sx, sy, sw: tileset.tilewidth, sh: tileset.tileheight };
+      }
+      function getTileData(gid) {
+        const resolved = resolveTileset(gid);
+        if (!resolved)
+          return null;
+        const { tileset, localId } = resolved;
+        return tileset.tiles?.find((t) => t.id === localId) ?? null;
+      }
+      function getFrameForLocalId(tileset, localId) {
+        const col = localId % tileset.columns;
+        const row = Math.floor(localId / tileset.columns);
+        const sx = tileset.margin + col * (tileset.tilewidth + tileset.spacing);
+        const sy = tileset.margin + row * (tileset.tileheight + tileset.spacing);
+        const base = src.substring(0, src.lastIndexOf("/") + 1);
+        const imageSrc = tileset.image.startsWith("/") ? tileset.image : base + tileset.image;
+        return { imageSrc, sx, sy, sw: tileset.tilewidth, sh: tileset.tileheight };
+      }
+      const objectNodes = [];
+      for (const layer of mapData.layers) {
+        if (layerFilter && !layerFilter(layer))
+          continue;
+        if (!layer.visible)
+          continue;
+        if (layer.type === "tilelayer" && layer.data) {
+          const collision = isCollisionLayer(layer, collisionLayer);
+          const trigger = !collision && isTriggerLayer(layer, triggerLayerName);
+          if (collision || trigger) {
+            for (let row = 0;row < mapData.height; row++) {
+              let col = 0;
+              while (col < mapData.width) {
+                const i = row * mapData.width + col;
+                const gid = layer.data[i];
+                if (gid === 0) {
+                  col++;
+                  continue;
+                }
+                let runLength = 1;
+                while (col + runLength < mapData.width && layer.data[row * mapData.width + col + runLength] !== 0) {
+                  runLength++;
+                }
+                const runWidth = runLength * tilewidth;
+                const x = col * tilewidth + runWidth / 2;
+                const y = row * tileheight + tileheight / 2;
+                const eid = engine.ecs.createEntity();
+                createdEntities.push(eid);
+                engine.ecs.addComponent(eid, createTransform(x, y));
+                if (collision) {
+                  engine.ecs.addComponent(eid, createRigidBody({ isStatic: true }));
+                  engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight));
+                } else {
+                  engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight, { isTrigger: true }));
+                }
+                col += runLength;
+              }
+            }
+          } else {
+            for (let i = 0;i < layer.data.length; i++) {
+              const gid = layer.data[i];
+              if (gid === 0)
+                continue;
+              const col = i % mapData.width;
+              const row = Math.floor(i / mapData.width);
+              const x = col * tilewidth + tilewidth / 2;
+              const y = row * tileheight + tileheight / 2;
+              const eid = engine.ecs.createEntity();
+              createdEntities.push(eid);
+              engine.ecs.addComponent(eid, createTransform(x, y));
+              const frame = getTileFrame(gid);
+              const sprite2 = createSprite({ width: tilewidth, height: tileheight, color: "#888", zIndex });
+              if (frame) {
+                sprite2.frame = { sx: frame.sx, sy: frame.sy, sw: frame.sw, sh: frame.sh };
+                engine.assets.loadImage(frame.imageSrc).then((img) => {
+                  const s = engine.ecs.getComponent(eid, "Sprite");
+                  if (s)
+                    s.image = img;
+                }).catch(() => {});
+              }
+              engine.ecs.addComponent(eid, sprite2);
+              const tileData = getTileData(gid);
+              if (tileData?.animation && tileData.animation.length > 0) {
+                const resolved = resolveTileset(gid);
+                const frames = tileData.animation.map((a) => a.tileid);
+                const durations = tileData.animation.map((a) => a.duration / 1000);
+                const state = { frames, durations, timer: 0, currentFrame: 0 };
+                animatedTiles.set(eid, state);
+                const firstFrameRegion = getFrameForLocalId(resolved.tileset, frames[0]);
+                engine.assets.loadImage(firstFrameRegion.imageSrc).then((img) => {
+                  const s = engine.ecs.getComponent(eid, "Sprite");
+                  if (s) {
+                    s.image = img;
+                    s.frame = {
+                      sx: firstFrameRegion.sx,
+                      sy: firstFrameRegion.sy,
+                      sw: firstFrameRegion.sw,
+                      sh: firstFrameRegion.sh
+                    };
+                  }
+                }).catch(() => {});
+                engine.ecs.addComponent(eid, createScript((_eid, world2, _input, dt) => {
+                  const animState = animatedTiles.get(_eid);
+                  if (!animState)
+                    return;
+                  animState.timer += dt;
+                  const currentDuration = animState.durations[animState.currentFrame];
+                  if (animState.timer >= currentDuration) {
+                    animState.timer -= currentDuration;
+                    animState.currentFrame = (animState.currentFrame + 1) % animState.frames.length;
+                    const nextLocalId = animState.frames[animState.currentFrame];
+                    const resolvedTs = resolveTileset(gid);
+                    if (!resolvedTs)
+                      return;
+                    const region = getFrameForLocalId(resolvedTs.tileset, nextLocalId);
+                    const s = world2.getComponent(_eid, "Sprite");
+                    if (s) {
+                      s.frame = { sx: region.sx, sy: region.sy, sw: region.sw, sh: region.sh };
+                    }
+                  }
+                }));
+              }
+              if (onTileProperty && tileData?.properties && tileData.properties.length > 0) {
+                const propsMap = {};
+                for (const p of tileData.properties) {
+                  propsMap[p.name] = p.value;
+                }
+                onTileProperty(gid, propsMap, x, y);
+              }
+            }
+          }
+        } else if (layer.type === "objectgroup" && layer.objects) {
+          if (onSpawnObject) {
+            for (const obj of layer.objects) {
+              const node = onSpawnObject(obj, layer);
+              if (node)
+                objectNodes.push(node);
+            }
+          }
+        }
+      }
+      setSpawnedNodes(objectNodes);
+    }
+    load();
+    return () => {
+      for (const eid of createdEntities) {
+        animatedTiles.delete(eid);
+        if (engine.ecs.hasEntity(eid))
+          engine.ecs.destroyEntity(eid);
+      }
+    };
+  }, [src]);
+  if (spawnedNodes.length === 0)
+    return null;
+  return /* @__PURE__ */ jsxDEV6(Fragment2, {
+    children: spawnedNodes
+  }, undefined, false, undefined, this);
+}
+// src/components/ParallaxLayer.tsx
+import { useEffect as useEffect14, useContext as useContext13 } from "react";
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
+function ParallaxLayerInner({
+  src,
+  speedX,
+  speedY,
+  repeatX,
+  repeatY,
+  zIndex,
+  offsetX,
+  offsetY
+}) {
+  const engine = useContext13(EngineContext);
+  const entityId = useContext13(EntityContext);
+  useEffect14(() => {
+    engine.ecs.addComponent(entityId, {
+      type: "ParallaxLayer",
+      src,
+      speedX,
+      speedY,
+      repeatX,
+      repeatY,
+      zIndex,
+      offsetX,
+      offsetY,
+      imageWidth: 0,
+      imageHeight: 0
+    });
+    return () => engine.ecs.removeComponent(entityId, "ParallaxLayer");
+  }, []);
+  useEffect14(() => {
+    const layer = engine.ecs.getComponent(entityId, "ParallaxLayer");
+    if (!layer)
+      return;
+    layer.src = src;
+    layer.speedX = speedX;
+    layer.speedY = speedY;
+    layer.repeatX = repeatX;
+    layer.repeatY = repeatY;
+    layer.zIndex = zIndex;
+    layer.offsetX = offsetX;
+    layer.offsetY = offsetY;
+  }, [src, speedX, speedY, repeatX, repeatY, zIndex, offsetX, offsetY, engine, entityId]);
+  return null;
+}
+function ParallaxLayer({
+  src,
+  speedX = 0.5,
+  speedY = 0,
+  repeatX = true,
+  repeatY = false,
+  zIndex = -10,
+  offsetX = 0,
+  offsetY = 0
+}) {
+  return /* @__PURE__ */ jsxDEV7(Entity, {
+    children: [
+      /* @__PURE__ */ jsxDEV7(Transform, {
+        x: 0,
+        y: 0
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV7(ParallaxLayerInner, {
+        src,
+        speedX,
+        speedY,
+        repeatX,
+        repeatY,
+        zIndex,
+        offsetX,
+        offsetY
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// src/components/ScreenFlash.tsx
+import { forwardRef, useImperativeHandle, useRef as useRef2 } from "react";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+var ScreenFlash = forwardRef((_, ref) => {
+  const divRef = useRef2(null);
+  useImperativeHandle(ref, () => ({
+    flash(color, duration) {
+      const el = divRef.current;
+      if (!el)
+        return;
+      el.style.backgroundColor = color;
+      el.style.opacity = "1";
+      el.style.transition = "none";
+      const durationMs = duration * 1000;
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          if (!divRef.current)
+            return;
+          divRef.current.style.transition = `opacity ${durationMs}ms linear`;
+          divRef.current.style.opacity = "0";
+        });
+      });
+    }
+  }));
+  return /* @__PURE__ */ jsxDEV8("div", {
+    ref: divRef,
+    style: {
+      position: "absolute",
+      inset: 0,
+      pointerEvents: "none",
+      zIndex: 9999,
+      opacity: 0,
+      backgroundColor: "transparent"
+    }
+  }, undefined, false, undefined, this);
+});
+ScreenFlash.displayName = "ScreenFlash";
+// src/hooks/useGame.ts
+import { useContext as useContext14 } from "react";
+function useGame() {
+  const engine = useContext14(EngineContext);
+  if (!engine)
+    throw new Error("useGame must be used inside <Game>");
+  return engine;
+}
+// src/hooks/useEntity.ts
+import { useContext as useContext15 } from "react";
+function useEntity() {
+  const id = useContext15(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";
+function useInput() {
+  const engine = useContext16(EngineContext);
+  if (!engine)
+    throw new Error("useInput must be used inside <Game>");
+  return engine.input;
+}
+// src/hooks/useEvents.ts
+import { useContext as useContext17, useEffect as useEffect15 } from "react";
+function useEvents() {
+  const engine = useContext17(EngineContext);
+  if (!engine)
+    throw new Error("useEvents must be used inside <Game>");
+  return engine.events;
+}
+function useEvent(event, handler) {
+  const events = useEvents();
+  useEffect15(() => {
+    return events.on(event, handler);
+  }, [events, event]);
+}
+// src/hooks/usePlatformerController.ts
+import { useContext as useContext18, useEffect as useEffect16 } from "react";
+function usePlatformerController(entityId, opts = {}) {
+  const engine = useContext18(EngineContext);
+  const {
+    speed = 200,
+    jumpForce = -500,
+    maxJumps = 1,
+    coyoteTime = 0.08,
+    jumpBuffer = 0.08
+  } = opts;
+  useEffect16(() => {
+    const state = { coyoteTimer: 0, jumpBuffer: 0, jumpsLeft: maxJumps };
+    const updateFn = (id, world2, input, dt) => {
+      if (!world2.hasEntity(id))
+        return;
+      const rb = world2.getComponent(id, "RigidBody");
+      if (!rb)
+        return;
+      if (rb.onGround) {
+        state.coyoteTimer = coyoteTime;
+        state.jumpsLeft = maxJumps;
+      } else
+        state.coyoteTimer = Math.max(0, state.coyoteTimer - dt);
+      const jumpPressed = input.isPressed("Space") || input.isPressed("ArrowUp") || input.isPressed("KeyW") || input.isPressed("w");
+      if (jumpPressed)
+        state.jumpBuffer = jumpBuffer;
+      else
+        state.jumpBuffer = Math.max(0, state.jumpBuffer - dt);
+      const left = input.isDown("ArrowLeft") || input.isDown("KeyA") || input.isDown("a");
+      const right = input.isDown("ArrowRight") || input.isDown("KeyD") || input.isDown("d");
+      if (left)
+        rb.vx = -speed;
+      else if (right)
+        rb.vx = speed;
+      else
+        rb.vx *= rb.onGround ? 0.6 : 0.92;
+      const sprite2 = world2.getComponent(id, "Sprite");
+      if (sprite2) {
+        if (left)
+          sprite2.flipX = true;
+        if (right)
+          sprite2.flipX = false;
+      }
+      const canJump = state.coyoteTimer > 0 || state.jumpsLeft > 0;
+      if (state.jumpBuffer > 0 && canJump) {
+        rb.vy = jumpForce;
+        state.jumpsLeft = Math.max(0, state.jumpsLeft - 1);
+        state.coyoteTimer = 0;
+        state.jumpBuffer = 0;
+      }
+      const jumpHeld = input.isDown("Space") || input.isDown("ArrowUp") || input.isDown("KeyW") || input.isDown("w");
+      if (!jumpHeld && rb.vy < -120)
+        rb.vy += 800 * dt;
+    };
+    engine.ecs.addComponent(entityId, createScript(updateFn));
+    return () => engine.ecs.removeComponent(entityId, "Script");
+  }, []);
+}
+// src/hooks/useTopDownMovement.ts
+import { useContext as useContext19, useEffect as useEffect17 } from "react";
+function useTopDownMovement(entityId, opts = {}) {
+  const engine = useContext19(EngineContext);
+  const { speed = 200, normalizeDiagonal = true } = opts;
+  useEffect17(() => {
+    const updateFn = (id, world2, input) => {
+      if (!world2.hasEntity(id))
+        return;
+      const rb = world2.getComponent(id, "RigidBody");
+      if (!rb)
+        return;
+      const left = input.isDown("ArrowLeft") || input.isDown("KeyA") || input.isDown("a") ? -1 : 0;
+      const right = input.isDown("ArrowRight") || input.isDown("KeyD") || input.isDown("d") ? 1 : 0;
+      const up = input.isDown("ArrowUp") || input.isDown("KeyW") || input.isDown("w") ? -1 : 0;
+      const down = input.isDown("ArrowDown") || input.isDown("KeyS") || input.isDown("s") ? 1 : 0;
+      let dx = left + right;
+      let dy = up + down;
+      if (normalizeDiagonal && dx !== 0 && dy !== 0) {
+        const len = Math.sqrt(dx * dx + dy * dy);
+        dx /= len;
+        dy /= len;
+      }
+      rb.vx = dx * speed;
+      rb.vy = dy * speed;
+    };
+    engine.ecs.addComponent(entityId, createScript(updateFn));
+    return () => engine.ecs.removeComponent(entityId, "Script");
+  }, []);
+}
+// src/components/spriteAtlas.ts
+function createAtlas(names, _columns) {
+  const atlas = {};
+  names.forEach((name, i) => {
+    atlas[name] = i;
+  });
+  return atlas;
+}
+export {
+  useTopDownMovement,
+  usePlatformerController,
+  useInput,
+  useGame,
+  useEvents,
+  useEvent,
+  useEntity,
+  tween,
+  definePlugin,
+  createAtlas,
+  World,
+  Transform,
+  Tilemap,
+  SquashStretch,
+  Sprite,
+  Script,
+  ScreenFlash,
+  RigidBody,
+  ParticleEmitter,
+  ParallaxLayer,
+  MovingPlatform,
+  Game,
+  Entity,
+  Ease,
+  Checkpoint,
+  Camera2D,
+  BoxCollider,
+  Animation
+};