cubeforge 0.0.1

package/dist/components/Animation.d.ts

@@ -0,0 +1,12 @@
+interface AnimationProps {
+    /** Frame indices to play (indexes into the sprite sheet) */
+    frames: number[];
+    /** Frames per second, default 12 */
+    fps?: number;
+    /** Whether to loop, default true */
+    loop?: boolean;
+    /** Whether currently playing, default true */
+    playing?: boolean;
+}
+export declare function Animation({ frames, fps, loop, playing }: AnimationProps): null;
+export {};

package/dist/components/Animation.js

@@ -0,0 +1,32 @@
+import { useEffect, useContext } from 'react';
+import { EngineContext, EntityContext } from '../context';
+export function Animation({ frames, fps = 12, loop = true, playing = true }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        const state = {
+            type: 'AnimationState',
+            frames,
+            fps,
+            loop,
+            playing,
+            currentIndex: 0,
+            timer: 0,
+        };
+        engine.ecs.addComponent(entityId, state);
+        return () => {
+            engine.ecs.removeComponent(entityId, 'AnimationState');
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync playing state and animation params
+    useEffect(() => {
+        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;
+}

package/dist/components/BoxCollider.d.ts

@@ -0,0 +1,10 @@
+interface BoxColliderProps {
+    width: number;
+    height: number;
+    offsetX?: number;
+    offsetY?: number;
+    isTrigger?: boolean;
+    layer?: string;
+}
+export declare function BoxCollider({ width, height, offsetX, offsetY, isTrigger, layer, }: BoxColliderProps): null;
+export {};

package/dist/components/BoxCollider.js

@@ -0,0 +1,21 @@
+import { useEffect, useContext } from 'react';
+import { createBoxCollider } from '@cubeforge/physics';
+import { EngineContext, EntityContext } from '../context';
+export function BoxCollider({ width, height, offsetX = 0, offsetY = 0, isTrigger = false, layer = 'default', }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        engine.ecs.addComponent(entityId, createBoxCollider(width, height, { offsetX, offsetY, isTrigger, layer }));
+        // Defer check so sibling components have had a chance to add their components
+        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');
+        };
+    }, []); // eslint-disable-line react-hooks/exhaustive-deps
+    return null;
+}

package/dist/components/Camera2D.d.ts

@@ -0,0 +1,20 @@
+interface Camera2DProps {
+    /** String ID of entity to follow */
+    followEntity?: string;
+    zoom?: number;
+    /** Lerp smoothing factor (0 = instant snap, 0.85 = smooth) */
+    smoothing?: number;
+    background?: string;
+    bounds?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    deadZone?: {
+        w: number;
+        h: number;
+    };
+}
+export declare function Camera2D({ followEntity, zoom, smoothing, background, bounds, deadZone, }: Camera2DProps): null;
+export {};

package/dist/components/Camera2D.js

@@ -0,0 +1,33 @@
+import { useEffect, useContext } from 'react';
+import { createCamera2D } from '@cubeforge/renderer';
+import { EngineContext } from '../context';
+export function Camera2D({ followEntity, zoom = 1, smoothing = 0, background = '#1a1a2e', bounds, deadZone, }) {
+    const engine = useContext(EngineContext);
+    useEffect(() => {
+        const entityId = engine.ecs.createEntity();
+        engine.ecs.addComponent(entityId, createCamera2D({
+            followEntityId: followEntity,
+            zoom,
+            smoothing,
+            background,
+            bounds,
+            deadZone,
+        }));
+        return () => engine.ecs.destroyEntity(entityId);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync prop changes
+    useEffect(() => {
+        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;
+}

package/dist/components/Checkpoint.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+interface CheckpointProps {
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    color?: string;
+    /** Called once when a 'player'-tagged entity enters the checkpoint */
+    onActivate?: () => void;
+}
+/**
+ * A trigger zone that fires `onActivate` when the player enters it, then destroys itself.
+ *
+ * @example
+ * <Checkpoint x={800} y={450} onActivate={() => setCheckpoint(800)} />
+ */
+export declare function Checkpoint({ x, y, width, height, color, onActivate, }: CheckpointProps): React.ReactElement;
+export {};

package/dist/components/Checkpoint.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Entity } from './Entity';
+import { Transform } from './Transform';
+import { Sprite } from './Sprite';
+import { BoxCollider } from './BoxCollider';
+import { Script } from './Script';
+/**
+ * A trigger zone that fires `onActivate` when the player enters it, then destroys itself.
+ *
+ * @example
+ * <Checkpoint x={800} y={450} onActivate={() => setCheckpoint(800)} />
+ */
+export function Checkpoint({ x, y, width = 24, height = 48, color = '#ffd54f', onActivate, }) {
+    return (_jsxs(Entity, { tags: ['checkpoint'], children: [_jsx(Transform, { x: x, y: y }), _jsx(Sprite, { width: width, height: height, color: color, zIndex: 5 }), _jsx(BoxCollider, { width: width, height: height, isTrigger: true }), _jsx(Script, { init: () => { }, update: (id, world) => {
+                    if (!world.hasEntity(id))
+                        return;
+                    const ct = world.getComponent(id, 'Transform');
+                    if (!ct)
+                        return;
+                    for (const pid of world.query('Tag')) {
+                        const tag = world.getComponent(pid, 'Tag');
+                        if (!tag?.tags.includes('player'))
+                            continue;
+                        const pt = world.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?.();
+                            world.destroyEntity(id);
+                            return;
+                        }
+                    }
+                } })] }));
+}

package/dist/components/Entity.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+interface EntityProps {
+    /** Optional string ID for cross-entity lookups (e.g. camera follow) */
+    id?: string;
+    /** Tags for grouping / querying (e.g. ['enemy', 'damageable']) */
+    tags?: string[];
+    children?: ReactNode;
+}
+export declare function Entity({ id, tags, children }: EntityProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/Entity.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useContext, useState } from 'react';
+import { createTag } from '@cubeforge/core';
+import { EngineContext, EntityContext } from '../context';
+export function Entity({ id, tags = [], children }) {
+    const engine = useContext(EngineContext);
+    const [entityId, setEntityId] = useState(null);
+    useEffect(() => {
+        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);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    if (entityId === null)
+        return null;
+    return (_jsx(EntityContext.Provider, { value: entityId, children: children }));
+}

package/dist/components/Game.d.ts

@@ -0,0 +1,28 @@
+import React, { type CSSProperties } from 'react';
+export interface GameControls {
+    pause(): void;
+    resume(): void;
+    reset(): void;
+}
+interface GameProps {
+    width?: number;
+    height?: number;
+    /** Pixels per second squared downward (default 980) */
+    gravity?: number;
+    /** Enable debug overlay: collider wireframes, FPS, entity count */
+    debug?: boolean;
+    /**
+     * Canvas scaling strategy (default 'none'):
+     * - 'none'    — fixed pixel size, no scaling
+     * - 'contain' — CSS scale to fit parent while preserving aspect ratio
+     * - 'pixel'   — nearest-neighbor pixel-art scaling via CSS
+     */
+    scale?: 'none' | 'contain' | 'pixel';
+    /** Called once the engine is ready — receives pause/resume/reset controls */
+    onReady?: (controls: GameControls) => void;
+    style?: CSSProperties;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare function Game({ width, height, gravity, debug, scale, onReady, style, className, children, }: GameProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Game.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { ECSWorld, GameLoop, EventBus, AssetManager, ScriptSystem } from '@cubeforge/core';
+import { InputManager } from '@cubeforge/input';
+import { Canvas2DRenderer, RenderSystem } from '@cubeforge/renderer';
+import { PhysicsSystem } from '@cubeforge/physics';
+import { EngineContext } from '../context';
+import { DebugSystem } from '../systems/debugSystem';
+export function Game({ width = 800, height = 600, gravity = 980, debug = false, scale = 'none', onReady, 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 renderSystem = new RenderSystem(renderer, entityIds);
+        const debugSystem = debug ? new DebugSystem(renderer) : null;
+        // System order: scripts → physics → render → (debug)
+        ecs.addSystem(new ScriptSystem(input));
+        ecs.addSystem(physics);
+        ecs.addSystem(renderSystem);
+        if (debugSystem)
+            ecs.addSystem(debugSystem);
+        input.attach(canvas);
+        canvas.setAttribute('tabindex', '0');
+        // Validate dimensions
+        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);
+        loop.start();
+        // Expose controls via onReady callback
+        onReady?.({
+            pause: () => loop.pause(),
+            resume: () => loop.resume(),
+            reset: () => {
+                ecs.clear();
+                loop.stop();
+                loop.start();
+            },
+        });
+        // Handle contain scaling
+        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();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync gravity changes
+    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 (_jsxs(EngineContext.Provider, { value: engine, children: [_jsx("div", { ref: wrapperRef, style: wrapperStyle, children: _jsx("canvas", { ref: canvasRef, width: width, height: height, style: canvasStyle, className: className }) }), engine && children] }));
+}

package/dist/components/MovingPlatform.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+interface MovingPlatformProps {
+    /** Start position */
+    x1: number;
+    y1: number;
+    /** End position */
+    x2: number;
+    y2: number;
+    width?: number;
+    height?: number;
+    /** Seconds for a full round trip (default 3) */
+    duration?: number;
+    color?: string;
+}
+/**
+ * A static platform that oscillates between (x1,y1) and (x2,y2).
+ *
+ * @example
+ * <MovingPlatform x1={200} y1={350} x2={450} y2={350} width={120} duration={2.5} />
+ */
+export declare function MovingPlatform({ x1, y1, x2, y2, width, height, duration, color, }: MovingPlatformProps): React.ReactElement;
+export {};

package/dist/components/MovingPlatform.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Entity } from './Entity';
+import { Transform } from './Transform';
+import { Sprite } from './Sprite';
+import { RigidBody } from './RigidBody';
+import { BoxCollider } from './BoxCollider';
+import { Script } from './Script';
+const platformPhases = new Map();
+/**
+ * A static platform that oscillates between (x1,y1) and (x2,y2).
+ *
+ * @example
+ * <MovingPlatform x1={200} y1={350} x2={450} y2={350} width={120} duration={2.5} />
+ */
+export function MovingPlatform({ x1, y1, x2, y2, width = 120, height = 18, duration = 3, color = '#37474f', }) {
+    return (_jsxs(Entity, { children: [_jsx(Transform, { x: x1, y: y1 }), _jsx(Sprite, { width: width, height: height, color: color, zIndex: 5 }), _jsx(RigidBody, { isStatic: true }), _jsx(BoxCollider, { width: width, height: height }), _jsx(Script, { init: () => { }, update: (id, world, _input, dt) => {
+                    if (!world.hasEntity(id))
+                        return;
+                    const t = world.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; // 0..1
+                    t.x = x1 + (x2 - x1) * alpha;
+                    t.y = y1 + (y2 - y1) * alpha;
+                } })] }));
+}

package/dist/components/ParallaxLayer.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+interface ParallaxLayerProps {
+    /** Image URL to use as the background layer */
+    src: string;
+    /** Scroll speed relative to camera (0 = fixed, 1 = moves with camera, 0.3 = slow parallax). Default 0.5 */
+    speedX?: number;
+    /** Vertical scroll speed relative to camera. Default 0 */
+    speedY?: number;
+    /** Tile image horizontally. Default true */
+    repeatX?: boolean;
+    /** Tile image vertically. Default false */
+    repeatY?: boolean;
+    /** Render order — use negative values to render behind sprites. Default -10 */
+    zIndex?: number;
+    /** Manual horizontal offset in pixels. Default 0 */
+    offsetX?: number;
+    /** Manual vertical offset in pixels. Default 0 */
+    offsetY?: number;
+}
+/**
+ * A background layer that scrolls at a fraction of the camera speed to create depth.
+ *
+ * @example
+ * <ParallaxLayer src="/bg/sky.png" speedX={0.2} repeatX />
+ * <ParallaxLayer src="/bg/mountains.png" speedX={0.5} repeatX zIndex={-5} />
+ */
+export declare function ParallaxLayer({ src, speedX, speedY, repeatX, repeatY, zIndex, offsetX, offsetY, }: ParallaxLayerProps): React.ReactElement;
+export {};

package/dist/components/ParallaxLayer.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useContext } from 'react';
+import { Entity } from './Entity';
+import { Transform } from './Transform';
+import { EngineContext, EntityContext } from '../context';
+function ParallaxLayerInner({ src, speedX, speedY, repeatX, repeatY, zIndex, offsetX, offsetY, }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        engine.ecs.addComponent(entityId, {
+            type: 'ParallaxLayer',
+            src,
+            speedX,
+            speedY,
+            repeatX,
+            repeatY,
+            zIndex,
+            offsetX,
+            offsetY,
+            imageWidth: 0,
+            imageHeight: 0,
+        });
+        return () => engine.ecs.removeComponent(entityId, 'ParallaxLayer');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync prop changes
+    useEffect(() => {
+        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;
+}
+/**
+ * A background layer that scrolls at a fraction of the camera speed to create depth.
+ *
+ * @example
+ * <ParallaxLayer src="/bg/sky.png" speedX={0.2} repeatX />
+ * <ParallaxLayer src="/bg/mountains.png" speedX={0.5} repeatX zIndex={-5} />
+ */
+export function ParallaxLayer({ src, speedX = 0.5, speedY = 0, repeatX = true, repeatY = false, zIndex = -10, offsetX = 0, offsetY = 0, }) {
+    return (_jsxs(Entity, { children: [_jsx(Transform, { x: 0, y: 0 }), _jsx(ParallaxLayerInner, { src: src, speedX: speedX, speedY: speedY, repeatX: repeatX, repeatY: repeatY, zIndex: zIndex, offsetX: offsetX, offsetY: offsetY })] }));
+}

package/dist/components/ParticleEmitter.d.ts

@@ -0,0 +1,26 @@
+import type { ParticlePreset } from './particlePresets';
+interface ParticleEmitterProps {
+    active?: boolean;
+    /** Named preset — values can be overridden by explicit props */
+    preset?: ParticlePreset;
+    /** Particles per second, default 20 */
+    rate?: number;
+    /** Initial particle speed (pixels/s), default 80 */
+    speed?: number;
+    /** Angle spread in radians, default Math.PI */
+    spread?: number;
+    /** Base emit angle in radians (0=right, -PI/2=up), default -Math.PI/2 */
+    angle?: number;
+    /** Particle lifetime in seconds, default 0.8 */
+    particleLife?: number;
+    /** Particle size in pixels, default 4 */
+    particleSize?: number;
+    /** Particle color, default '#ffffff' */
+    color?: string;
+    /** Gravity applied to particles (pixels/s²), default 200 */
+    gravity?: number;
+    /** Maximum live particles, default 100 */
+    maxParticles?: number;
+}
+export declare function ParticleEmitter({ active, preset, rate, speed, spread, angle, particleLife, particleSize, color, gravity, maxParticles, }: ParticleEmitterProps): null;
+export {};

package/dist/components/ParticleEmitter.js

@@ -0,0 +1,44 @@
+import { useEffect, useContext } from 'react';
+import { EngineContext, EntityContext } from '../context';
+import { PARTICLE_PRESETS } from './particlePresets';
+export 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 = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        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');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // Sync active state
+    useEffect(() => {
+        const pool = engine.ecs.getComponent(entityId, 'ParticlePool');
+        if (!pool)
+            return;
+        pool.active = active;
+    }, [active, engine, entityId]);
+    return null;
+}

package/dist/components/RigidBody.d.ts

@@ -0,0 +1,11 @@
+interface RigidBodyProps {
+    mass?: number;
+    gravityScale?: number;
+    isStatic?: boolean;
+    bounce?: number;
+    friction?: number;
+    vx?: number;
+    vy?: number;
+}
+export declare function RigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy, }: RigidBodyProps): null;
+export {};

package/dist/components/RigidBody.js

@@ -0,0 +1,13 @@
+import { useEffect, useContext } from 'react';
+import { createRigidBody } from '@cubeforge/physics';
+import { EngineContext, EntityContext } from '../context';
+export function RigidBody({ mass = 1, gravityScale = 1, isStatic = false, bounce = 0, friction = 0.85, vx = 0, vy = 0, }) {
+    const engine = useContext(EngineContext);
+    const entityId = useContext(EntityContext);
+    useEffect(() => {
+        engine.ecs.addComponent(entityId, createRigidBody({ mass, gravityScale, isStatic, bounce, friction, vx, vy }));
+        return () => engine.ecs.removeComponent(entityId, 'RigidBody');
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    return null;
+}

package/dist/components/ScreenFlash.d.ts

@@ -0,0 +1,4 @@
+export interface ScreenFlashHandle {
+    flash(color: string, duration: number): void;
+}
+export declare const ScreenFlash: import("react").ForwardRefExoticComponent<import("react").RefAttributes<ScreenFlashHandle>>;

package/dist/components/ScreenFlash.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useImperativeHandle, useRef } from 'react';
+export const ScreenFlash = forwardRef((_, ref) => {
+    const divRef = useRef(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;
+            // Next frame: start the fade
+            requestAnimationFrame(() => {
+                requestAnimationFrame(() => {
+                    if (!divRef.current)
+                        return;
+                    divRef.current.style.transition = `opacity ${durationMs}ms linear`;
+                    divRef.current.style.opacity = '0';
+                });
+            });
+        },
+    }));
+    return (_jsx("div", { ref: divRef, style: {
+            position: 'absolute',
+            inset: 0,
+            pointerEvents: 'none',
+            zIndex: 9999,
+            opacity: 0,
+            backgroundColor: 'transparent',
+        } }));
+});
+ScreenFlash.displayName = 'ScreenFlash';

package/dist/components/Script.d.ts

@@ -0,0 +1,11 @@
+import { type ScriptUpdateFn } from '@cubeforge/core';
+import type { ECSWorld, EntityId } from '@cubeforge/core';
+import type { InputManager } from '@cubeforge/input';
+interface ScriptProps {
+    /** Called once when the entity is mounted — use to attach extra components */
+    init?: (entityId: EntityId, world: ECSWorld) => void;
+    /** Called every frame */
+    update: ScriptUpdateFn | ((entityId: EntityId, world: ECSWorld, input: InputManager, dt: number) => void);
+}
+export declare function Script({ init, update }: ScriptProps): null;
+export {};