cubeforge 0.0.1

package/dist/components/Script.js

@@ -0,0 +1,20 @@
+import { useEffect, useContext } from 'react';
+import { createScript } from '@cubeforge/core';
+import { EngineContext, EntityContext } from '../context';
+export function Script({ init, update }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        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');
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    return null;
+}

package/dist/components/Sprite.d.ts

@@ -0,0 +1,22 @@
+import type { SpriteAtlas } from './spriteAtlas';
+interface SpriteProps {
+    width: number;
+    height: number;
+    color?: string;
+    src?: string;
+    offsetX?: number;
+    offsetY?: number;
+    zIndex?: number;
+    visible?: boolean;
+    flipX?: boolean;
+    anchorX?: number;
+    anchorY?: number;
+    frameIndex?: number;
+    frameWidth?: number;
+    frameHeight?: number;
+    frameColumns?: number;
+    atlas?: SpriteAtlas;
+    frame?: string;
+}
+export declare function Sprite({ width, height, color, src, offsetX, offsetY, zIndex, visible, flipX, anchorX, anchorY, frameIndex, frameWidth, frameHeight, frameColumns, atlas, frame, }: SpriteProps): null;
+export {};

package/dist/components/Sprite.js

@@ -0,0 +1,49 @@
+import { useEffect, useContext } from 'react';
+import { createSprite } from '@cubeforge/renderer';
+import { EngineContext, EntityContext } from '../context';
+export 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 = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        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');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync mutable props
+    useEffect(() => {
+        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;
+}

package/dist/components/SquashStretch.d.ts

@@ -0,0 +1,8 @@
+interface SquashStretchProps {
+    /** How much to squash/stretch (default 0.2) */
+    intensity?: number;
+    /** How fast it returns to 1.0 — lerp speed (default 8) */
+    recovery?: number;
+}
+export declare function SquashStretch({ intensity, recovery }: SquashStretchProps): null;
+export {};

package/dist/components/SquashStretch.js

@@ -0,0 +1,18 @@
+import { useEffect, useContext } from 'react';
+import { EngineContext, EntityContext } from '../context';
+export function SquashStretch({ intensity = 0.2, recovery = 8 }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        engine.ecs.addComponent(entityId, {
+            type: 'SquashStretch',
+            intensity,
+            recovery,
+            currentScaleX: 1,
+            currentScaleY: 1,
+        });
+        return () => engine.ecs.removeComponent(entityId, 'SquashStretch');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return null;
+}

package/dist/components/Tilemap.d.ts

@@ -0,0 +1,58 @@
+import React from 'react';
+interface TiledProperty {
+    name: string;
+    type: string;
+    value: string | number | boolean;
+}
+export interface TiledObject {
+    id: number;
+    name: string;
+    type: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    properties?: TiledProperty[];
+}
+export interface TiledLayer {
+    type: 'tilelayer' | 'objectgroup';
+    name: string;
+    visible: boolean;
+    opacity: number;
+    data?: number[];
+    objects?: TiledObject[];
+    properties?: TiledProperty[];
+}
+interface TilemapProps {
+    /** URL to the Tiled JSON file */
+    src: string;
+    /**
+     * Object layer spawner: called for each object in object layers.
+     * Return a React element or null.
+     */
+    onSpawnObject?: (obj: TiledObject, layer: TiledLayer) => React.ReactNode;
+    /**
+     * Layer filter: return false to skip rendering/processing a layer.
+     * Default: all layers rendered.
+     */
+    layerFilter?: (layer: TiledLayer) => boolean;
+    /** Z-index for tile sprites (default 0) */
+    zIndex?: number;
+    /**
+     * Name of the layer (or layers with property `collision: true`) that
+     * should create invisible solid colliders. Default: "collision".
+     */
+    collisionLayer?: string;
+    /**
+     * Name of the layer (or layers with property `trigger: true`) that
+     * should create trigger BoxColliders (no sprite). Default: "triggers".
+     */
+    triggerLayer?: string;
+    /**
+     * Called for every tile that has custom properties defined in the tileset.
+     * Receives the global tile ID, the property map, and the tile's world position.
+     */
+    onTileProperty?: (tileId: number, properties: Record<string, unknown>, x: number, y: number) => void;
+}
+export declare function Tilemap({ src, onSpawnObject, layerFilter, zIndex, collisionLayer, triggerLayer: triggerLayerName, onTileProperty, }: TilemapProps): React.ReactElement | null;
+export {};

package/dist/components/Tilemap.js

@@ -0,0 +1,245 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState, useContext } from 'react';
+import { createTransform, createScript } from '@cubeforge/core';
+import { createSprite } from '@cubeforge/renderer';
+import { createRigidBody, createBoxCollider } from '@cubeforge/physics';
+import { EngineContext } from '../context';
+const animatedTiles = new Map();
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+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);
+}
+export function Tilemap({ src, onSpawnObject, layerFilter, zIndex = 0, collisionLayer = 'collision', triggerLayer: triggerLayerName = 'triggers', onTileProperty, }) {
+    const engine = useContext(EngineContext);
+    const [spawnedNodes, setSpawnedNodes] = useState([]);
+    useEffect(() => {
+        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;
+            // Resolve the tileset for a given GID, plus the local tile id within it
+            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 };
+            }
+            // Build tileset image map: GID → { imageSrc, sx, sy, sw, sh }
+            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);
+                // Resolve image path relative to the map src
+                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 };
+            }
+            // Look up per-tile data (animation, properties) from the tileset
+            function getTileData(gid) {
+                const resolved = resolveTileset(gid);
+                if (!resolved)
+                    return null;
+                const { tileset, localId } = resolved;
+                return tileset.tiles?.find(t => t.id === localId) ?? null;
+            }
+            // Compute the frame region for a local tile id within a tileset
+            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) {
+                        // Merge adjacent filled tiles in each row into single wide colliders
+                        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;
+                                }
+                                // Start of a run — extend right while tiles are filled
+                                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) {
+                                    // Invisible solid collider spanning the entire run
+                                    engine.ecs.addComponent(eid, createRigidBody({ isStatic: true }));
+                                    engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight));
+                                }
+                                else {
+                                    // Invisible trigger collider spanning the entire run
+                                    engine.ecs.addComponent(eid, createBoxCollider(runWidth, tileheight, { isTrigger: true }));
+                                }
+                                col += runLength;
+                            }
+                        }
+                    }
+                    else {
+                        // Visual tiles — render per tile with sprites
+                        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);
+                            // Tile center position
+                            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));
+                            // Visual tile — load image and set frame
+                            const frame = getTileFrame(gid);
+                            const sprite = createSprite({ width: tilewidth, height: tileheight, color: '#888', zIndex });
+                            if (frame) {
+                                sprite.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, sprite);
+                            // Check for animated tile
+                            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); // ms → seconds
+                                const state = { frames, durations, timer: 0, currentFrame: 0 };
+                                animatedTiles.set(eid, state);
+                                // Pre-load first frame image (tileset image already loading above)
+                                // Set initial frame region from the first animation frame
+                                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, world, _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 = world.getComponent(_eid, 'Sprite');
+                                        if (s) {
+                                            s.frame = { sx: region.sx, sy: region.sy, sw: region.sw, sh: region.sh };
+                                        }
+                                    }
+                                }));
+                            }
+                            // Fire onTileProperty callback if tile has custom properties
+                            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);
+            }
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [src]);
+    if (spawnedNodes.length === 0)
+        return null;
+    return _jsx(_Fragment, { children: spawnedNodes });
+}

package/dist/components/Transform.d.ts

@@ -0,0 +1,9 @@
+interface TransformProps {
+    x?: number;
+    y?: number;
+    rotation?: number;
+    scaleX?: number;
+    scaleY?: number;
+}
+export declare function Transform({ x, y, rotation, scaleX, scaleY }: TransformProps): null;
+export {};

package/dist/components/Transform.js

@@ -0,0 +1,24 @@
+import { useEffect, useContext } from 'react';
+import { createTransform } from '@cubeforge/core';
+import { EngineContext, EntityContext } from '../context';
+export function Transform({ x = 0, y = 0, rotation = 0, scaleX = 1, scaleY = 1 }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        engine.ecs.addComponent(entityId, createTransform(x, y, rotation, scaleX, scaleY));
+        return () => engine.ecs.removeComponent(entityId, 'Transform');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync prop changes to component data
+    useEffect(() => {
+        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;
+}

package/dist/components/World.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+interface WorldProps {
+    /** Gravitational acceleration in pixels/s² (default inherited from Game) */
+    gravity?: number;
+    /** Canvas background color */
+    background?: string;
+    children?: ReactNode;
+}
+export declare function World({ gravity, background, children }: WorldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/World.js

@@ -0,0 +1,28 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useContext } from 'react';
+import { EngineContext } from '../context';
+export function World({ gravity, background = '#1a1a2e', children }) {
+    const engine = useContext(EngineContext);
+    useEffect(() => {
+        if (!engine)
+            return;
+        if (gravity !== undefined)
+            engine.physics.setGravity(gravity);
+    }, [gravity, engine]);
+    useEffect(() => {
+        if (!engine)
+            return;
+        // Propagate background to the camera component (or store it for renderer)
+        // The camera component stores background — if no camera exists, fill canvas directly
+        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 _jsx(_Fragment, { children: children });
+}

package/dist/components/particlePresets.d.ts

@@ -0,0 +1,13 @@
+export type ParticlePreset = 'explosion' | 'spark' | 'smoke' | 'coinPickup' | 'jumpDust';
+export interface ParticleEmitterConfig {
+    rate?: number;
+    speed?: number;
+    spread?: number;
+    angle?: number;
+    particleLife?: number;
+    particleSize?: number;
+    color?: string;
+    gravity?: number;
+    maxParticles?: number;
+}
+export declare const PARTICLE_PRESETS: Record<ParticlePreset, ParticleEmitterConfig>;

package/dist/components/particlePresets.js

@@ -0,0 +1,27 @@
+export const 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,
+    },
+};

package/dist/components/spriteAtlas.d.ts

@@ -0,0 +1,8 @@
+/** Maps frame names to frameIndex numbers */
+export type SpriteAtlas = Record<string, number>;
+/**
+ * Helper to build an atlas from a grid spritesheet.
+ * columns = number of frames per row.
+ * names = frame names in row-major order.
+ */
+export declare function createAtlas(names: string[], _columns: number): SpriteAtlas;

package/dist/components/spriteAtlas.js

@@ -0,0 +1,10 @@
+/**
+ * Helper to build an atlas from a grid spritesheet.
+ * columns = number of frames per row.
+ * names = frame names in row-major order.
+ */
+export function createAtlas(names, _columns) {
+    const atlas = {};
+    names.forEach((name, i) => { atlas[name] = i; });
+    return atlas;
+}

package/dist/context.d.ts

@@ -0,0 +1,19 @@
+import type { ECSWorld, EventBus, AssetManager, EntityId } from '@cubeforge/core';
+import type { InputManager } from '@cubeforge/input';
+import type { Canvas2DRenderer } from '@cubeforge/renderer';
+import type { PhysicsSystem } from '@cubeforge/physics';
+import type { GameLoop } from '@cubeforge/core';
+export interface EngineState {
+    ecs: ECSWorld;
+    input: InputManager;
+    renderer: Canvas2DRenderer;
+    physics: PhysicsSystem;
+    events: EventBus;
+    assets: AssetManager;
+    loop: GameLoop;
+    canvas: HTMLCanvasElement;
+    /** Maps string entity IDs (e.g. "player") to numeric ECS EntityIds */
+    entityIds: Map<string, EntityId>;
+}
+export declare const EngineContext: import("react").Context<EngineState | null>;
+export declare const EntityContext: import("react").Context<number | null>;

package/dist/context.js

@@ -0,0 +1,3 @@
+import { createContext } from 'react';
+export const EngineContext = createContext(null);
+export const EntityContext = createContext(null);

package/dist/hooks/useEntity.d.ts

@@ -0,0 +1,2 @@
+import type { EntityId } from '@cubeforge/core';
+export declare function useEntity(): EntityId;

package/dist/hooks/useEntity.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { EntityContext } from '../context';
+export function useEntity() {
+    const id = useContext(EntityContext);
+    if (id === null)
+        throw new Error('useEntity must be used inside <Entity>');
+    return id;
+}

package/dist/hooks/useEvents.d.ts

@@ -0,0 +1,3 @@
+import type { EventBus } from '@cubeforge/core';
+export declare function useEvents(): EventBus;
+export declare function useEvent<T>(event: string, handler: (data: T) => void): void;

package/dist/hooks/useEvents.js

@@ -0,0 +1,15 @@
+import { useContext, useEffect } from 'react';
+import { EngineContext } from '../context';
+export function useEvents() {
+    const engine = useContext(EngineContext);
+    if (!engine)
+        throw new Error('useEvents must be used inside <Game>');
+    return engine.events;
+}
+export function useEvent(event, handler) {
+    const events = useEvents();
+    useEffect(() => {
+        return events.on(event, handler);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [events, event]);
+}

package/dist/hooks/useGame.d.ts

@@ -0,0 +1,2 @@
+import { type EngineState } from '../context';
+export declare function useGame(): EngineState;

package/dist/hooks/useGame.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { EngineContext } from '../context';
+export function useGame() {
+    const engine = useContext(EngineContext);
+    if (!engine)
+        throw new Error('useGame must be used inside <Game>');
+    return engine;
+}

package/dist/hooks/useInput.d.ts

@@ -0,0 +1,2 @@
+import type { InputManager } from '@cubeforge/input';
+export declare function useInput(): InputManager;

package/dist/hooks/useInput.js

@@ -0,0 +1,8 @@
+import { useContext } from 'react';
+import { EngineContext } from '../context';
+export function useInput() {
+    const engine = useContext(EngineContext);
+    if (!engine)
+        throw new Error('useInput must be used inside <Game>');
+    return engine.input;
+}