@thewhateverapp/tile-sdk 0.15.3 → 0.15.5

package/dist/scene/SceneRenderer.js

@@ -1,312 +0,0 @@
-'use client';
-import React, { useEffect, useRef, useCallback, useMemo, useState } from 'react';
-import * as PIXI from 'pixi.js';
-import Matter from 'matter-js';
-import { compileScene } from '@thewhateverapp/scene-sdk';
-import { PixiGame, usePixiApp, useGameLoop, TILE_WIDTH, TILE_HEIGHT } from '../pixi/index.js';
-import { SceneContext, createEntityState, createPlayerState, createCameraState, createInputState, createTimelineState, } from './SceneContext.js';
-import { usePhysicsEngine } from './physics/PhysicsEngine.js';
-import { useInputManager } from './input/InputManager.js';
-import { useComponentRunner } from './components/ComponentRunner.js';
-import { useTimelineExecutor } from './timeline/TimelineExecutor.js';
-import { useCameraController } from './camera/CameraController.js';
-import { createEntityGraphics, updateEntityGraphics, } from './entities/EntityGraphics.js';
-const { Body } = Matter;
-/**
- * Hook to track container size using ResizeObserver
- */
-function useContainerSize(containerRef) {
-    const [size, setSize] = useState({ width: TILE_WIDTH, height: TILE_HEIGHT });
-    useEffect(() => {
-        const container = containerRef.current;
-        if (!container)
-            return;
-        const updateSize = () => {
-            const rect = container.getBoundingClientRect();
-            if (rect.width > 0 && rect.height > 0) {
-                setSize({ width: rect.width, height: rect.height });
-            }
-        };
-        // Initial size
-        updateSize();
-        // Watch for resize
-        const observer = new ResizeObserver(updateSize);
-        observer.observe(container);
-        return () => observer.disconnect();
-    }, [containerRef]);
-    return size;
-}
-/**
- * SceneRenderer - Renders a SceneSpecV1 with physics, components, and timeline
- *
- * By default, fills its parent container responsively. Pass explicit width/height
- * to override with fixed dimensions.
- */
-export function SceneRenderer({ spec: inputSpec, onEvent, paused = false, width: fixedWidth, height: fixedHeight, debug = false, }) {
-    const containerRef = useRef(null);
-    const autoSize = useContainerSize(containerRef);
-    // Use fixed dimensions if provided, otherwise auto-size to container
-    const width = fixedWidth ?? autoSize.width;
-    const height = fixedHeight ?? autoSize.height;
-    // Compile patterns once on mount
-    const compiledSpec = useMemo(() => compileScene(inputSpec), [inputSpec]);
-    // Get background color from spec
-    const backgroundColor = useMemo(() => {
-        const bg = compiledSpec.style?.background?.color;
-        if (bg) {
-            return parseInt(bg.replace('#', ''), 16);
-        }
-        return 0x0a0a1a; // Default dark background
-    }, [compiledSpec]);
-    return (React.createElement("div", { ref: containerRef, style: { width: '100%', height: '100%' } },
-        React.createElement(PixiGame, { width: width, height: height, background: backgroundColor, paused: paused },
-            React.createElement(SceneContent, { spec: compiledSpec, onEvent: onEvent, paused: paused, width: width, height: height, debug: debug }))));
-}
-/**
- * Inner component that runs inside PixiGame context
- */
-function SceneContent({ spec, onEvent, paused, width, height, debug, }) {
-    const app = usePixiApp();
-    // Pixi containers
-    const worldContainerRef = useRef(null);
-    const layerContainersRef = useRef(new Map());
-    const entityGraphicsRef = useRef(new Map());
-    // Initialize refs for all state
-    const entitiesRef = useRef(new Map());
-    const playerRef = useRef(createPlayerState());
-    const cameraRef = useRef(createCameraState(spec.camera));
-    const inputRef = useRef(createInputState());
-    const timelineRef = useRef(createTimelineState());
-    const engineRef = useRef(null);
-    const startTimeRef = useRef(Date.now());
-    // Get layers from spec or use defaults
-    const layers = useMemo(() => {
-        if (spec.layers && spec.layers.length > 0) {
-            return spec.layers;
-        }
-        // Default dash layers
-        return ['bg', 'deco', 'solids', 'hazards', 'orbs', 'player', 'fx', 'ui'];
-    }, [spec.layers]);
-    // Get BPM from spec
-    const bpm = spec.meta?.bpm ?? 120;
-    // Event emitter callback
-    const emitEvent = useCallback((event, data) => {
-        onEvent?.(event, data);
-    }, [onEvent]);
-    // Get entity by ID
-    const getEntity = useCallback((id) => {
-        return entitiesRef.current.get(id);
-    }, []);
-    // Spawn entity from prefab
-    const spawnEntity = useCallback((prefabId, x, y) => {
-        const prefab = spec.prefabs?.[prefabId];
-        if (!prefab) {
-            console.warn(`Prefab not found: ${prefabId}`);
-            return;
-        }
-        const id = `${prefabId}_${Date.now()}`;
-        const entity = {
-            id,
-            kind: prefab.kind ?? 'rect',
-            layer: prefab.layer ?? 'fx',
-            transform: {
-                x,
-                y,
-                ...prefab.transform,
-            },
-            geom: prefab.geom ?? { w: 20, h: 20 },
-            render: prefab.render,
-            body: prefab.body,
-            tags: prefab.tags,
-            components: prefab.components,
-        };
-        const state = createEntityState(entity);
-        entitiesRef.current.set(id, state);
-        // Create graphics for the new entity
-        const layerContainer = layerContainersRef.current.get(entity.layer);
-        if (layerContainer) {
-            const graphics = createEntityGraphics(state, debug);
-            entityGraphicsRef.current.set(id, graphics);
-            layerContainer.addChild(graphics.container);
-        }
-    }, [spec.prefabs, debug]);
-    // Destroy entity
-    const destroyEntity = useCallback((id) => {
-        const entity = entitiesRef.current.get(id);
-        if (entity) {
-            entity.destroyed = true;
-            // Body cleanup happens in physics engine
-            // Graphics cleanup happens in render loop
-        }
-    }, []);
-    // Respawn player at checkpoint
-    const respawnPlayer = useCallback(() => {
-        const player = playerRef.current;
-        player.dead = false;
-        player.jumpCount = 0;
-        player.gravityDir = 1;
-        // Grant 1 second of invincibility to prevent instant re-death
-        player.invincible = true;
-        player.invincibilityTimeRemaining = 1000;
-        // Find player entity and reset position
-        for (const [, state] of entitiesRef.current) {
-            if (state.entity.tags?.includes('player')) {
-                const respawnX = player.checkpointX ?? state.entity.transform.x;
-                const respawnY = player.checkpointY ?? state.entity.transform.y;
-                state.x = respawnX;
-                state.y = respawnY;
-                state.velocityX = 0;
-                state.velocityY = 0;
-                state.rotation = 0;
-                // Update physics body if it exists
-                if (state.body) {
-                    Body.setPosition(state.body, { x: respawnX, y: respawnY });
-                    Body.setVelocity(state.body, { x: 0, y: 0 });
-                    Body.setAngle(state.body, 0);
-                }
-                break;
-            }
-        }
-        emitEvent('player.respawn', { x: player.checkpointX, y: player.checkpointY });
-    }, [emitEvent]);
-    // Build context value
-    const contextValue = useMemo(() => ({
-        spec,
-        entities: entitiesRef,
-        layers,
-        player: playerRef,
-        camera: cameraRef,
-        input: inputRef,
-        timeline: timelineRef,
-        engine: engineRef,
-        emitEvent,
-        getEntity,
-        spawnEntity,
-        destroyEntity,
-        respawnPlayer,
-        bpm,
-        startTime: startTimeRef.current,
-    }), [spec, layers, bpm, emitEvent, getEntity, spawnEntity, destroyEntity, respawnPlayer]);
-    // Initialize pixi containers
-    useEffect(() => {
-        if (!app)
-            return;
-        // Create world container
-        const worldContainer = new PIXI.Container();
-        worldContainer.sortableChildren = true;
-        app.stage.addChild(worldContainer);
-        worldContainerRef.current = worldContainer;
-        // Create layer containers
-        const layerContainers = new Map();
-        layers.forEach((layer, index) => {
-            const container = new PIXI.Container();
-            container.zIndex = index;
-            worldContainer.addChild(container);
-            layerContainers.set(layer, container);
-        });
-        layerContainersRef.current = layerContainers;
-        return () => {
-            // Cleanup
-            entityGraphicsRef.current.forEach((graphics) => {
-                graphics.container.destroy({ children: true });
-            });
-            entityGraphicsRef.current.clear();
-            layerContainersRef.current.clear();
-            worldContainer.destroy({ children: true });
-            worldContainerRef.current = null;
-        };
-    }, [app, layers]);
-    // Initialize entities from spec
-    useEffect(() => {
-        const entityMap = new Map();
-        for (const entity of spec.entities) {
-            entityMap.set(entity.id, createEntityState(entity));
-        }
-        entitiesRef.current = entityMap;
-        // Find player and set initial checkpoint
-        for (const entity of spec.entities) {
-            if (entity.tags?.includes('player')) {
-                playerRef.current.checkpointX = entity.transform.x;
-                playerRef.current.checkpointY = entity.transform.y;
-                break;
-            }
-        }
-        // Reset start time
-        startTimeRef.current = Date.now();
-        timelineRef.current = createTimelineState();
-        // Create graphics for all entities
-        entityGraphicsRef.current.forEach((graphics) => {
-            graphics.container.destroy({ children: true });
-        });
-        entityGraphicsRef.current.clear();
-        for (const [id, state] of entityMap) {
-            const layerContainer = layerContainersRef.current.get(state.entity.layer);
-            if (layerContainer) {
-                const graphics = createEntityGraphics(state, debug);
-                entityGraphicsRef.current.set(id, graphics);
-                layerContainer.addChild(graphics.container);
-            }
-        }
-    }, [spec, debug]);
-    // Initialize physics engine
-    usePhysicsEngine(contextValue, width, height);
-    // Initialize input handling
-    useInputManager(contextValue);
-    // Run component logic
-    useComponentRunner(contextValue);
-    // Run timeline
-    useTimelineExecutor(contextValue);
-    // Update camera
-    useCameraController(contextValue, width, height);
-    // Main game loop - update graphics positions
-    useGameLoop((delta) => {
-        if (paused)
-            return;
-        const playerState = playerRef.current;
-        // Update timeline elapsed time (only when game has started)
-        if (playerState.started) {
-            // Adjust start time on first frame after starting
-            if (timelineRef.current.elapsedMs === 0) {
-                startTimeRef.current = Date.now();
-            }
-            const now = Date.now();
-            timelineRef.current.elapsedMs = now - startTimeRef.current;
-            timelineRef.current.currentBeat = (timelineRef.current.elapsedMs / 1000) * (bpm / 60);
-        }
-        // Update camera position
-        if (worldContainerRef.current) {
-            const camera = cameraRef.current;
-            worldContainerRef.current.x = -camera.x + width / 2;
-            worldContainerRef.current.y = -camera.y + height / 2;
-            worldContainerRef.current.scale.set(camera.zoom);
-        }
-        // Update entity graphics
-        for (const [id, state] of entitiesRef.current) {
-            const graphics = entityGraphicsRef.current.get(id);
-            if (!graphics)
-                continue;
-            if (state.destroyed || !state.visible) {
-                // Remove destroyed/hidden entities
-                if (graphics.container.parent) {
-                    graphics.container.parent.removeChild(graphics.container);
-                }
-                if (state.destroyed) {
-                    graphics.container.destroy({ children: true });
-                    entityGraphicsRef.current.delete(id);
-                    entitiesRef.current.delete(id);
-                }
-                else {
-                    graphics.container.visible = false;
-                }
-                continue;
-            }
-            graphics.container.visible = true;
-            updateEntityGraphics(graphics, state);
-        }
-    }, !paused);
-    // Provide context for hooks that need it
-    return (React.createElement(SceneContext.Provider, { value: contextValue }, null));
-}
-// Re-export useScene for convenience
-import { useScene } from './SceneContext.js';
-export { useScene };

package/dist/scene/camera/CameraController.d.ts

@@ -1,6 +0,0 @@
-import type { SceneContextValue } from '../SceneContext.js';
-/**
- * Hook to control the camera
- */
-export declare function useCameraController(context: SceneContextValue, width: number, height: number): void;
-//# sourceMappingURL=CameraController.d.ts.map

package/dist/scene/camera/CameraController.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CameraController.d.ts","sourceRoot":"","sources":["../../../src/scene/camera/CameraController.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,QA6Ff"}

package/dist/scene/camera/CameraController.js

@@ -1,90 +0,0 @@
-'use client';
-import { useGameLoop } from '../../pixi/index.js';
-/**
- * Hook to control the camera
- */
-export function useCameraController(context, width, height) {
-    const { spec, camera, entities, player, timeline } = context;
-    const cameraConfig = spec.camera;
-    useGameLoop((delta) => {
-        const cameraState = camera.current;
-        const playerState = player.current;
-        const elapsedMs = timeline.current.elapsedMs;
-        // Get camera mode
-        const mode = cameraConfig?.mode ?? 'static';
-        switch (mode) {
-            case 'static': {
-                // Camera stays at initial position
-                cameraState.x = cameraConfig?.initialX ?? width / 2;
-                cameraState.y = cameraConfig?.initialY ?? height / 2;
-                break;
-            }
-            case 'scroll': {
-                // Auto-scroll camera (only when game has started)
-                if (!playerState.started) {
-                    // Initialize camera position when not started
-                    cameraState.x = cameraConfig?.initialX ?? width / 2;
-                    cameraState.y = cameraConfig?.initialY ?? height / 2;
-                    break;
-                }
-                const scrollSpeed = (cameraConfig?.scrollSpeed ?? 320) * playerState.speedMultiplier;
-                const direction = cameraConfig?.scrollDirection ?? 'right';
-                switch (direction) {
-                    case 'right':
-                        cameraState.x += scrollSpeed * delta * 0.016;
-                        break;
-                    case 'left':
-                        cameraState.x -= scrollSpeed * delta * 0.016;
-                        break;
-                    case 'down':
-                        cameraState.y += scrollSpeed * delta * 0.016;
-                        break;
-                    case 'up':
-                        cameraState.y -= scrollSpeed * delta * 0.016;
-                        break;
-                }
-                break;
-            }
-            case 'follow': {
-                // Follow target entity
-                const targetId = cameraConfig?.followTarget;
-                if (!targetId)
-                    break;
-                const targetEntity = entities.current.get(targetId);
-                if (!targetEntity)
-                    break;
-                const smoothing = cameraConfig?.smoothing ?? 0.1;
-                const targetX = targetEntity.x;
-                const targetY = targetEntity.y;
-                // Lerp camera towards target
-                cameraState.x += (targetX - cameraState.x) * smoothing;
-                cameraState.y += (targetY - cameraState.y) * smoothing;
-                break;
-            }
-        }
-        // Apply camera bounds
-        const bounds = cameraConfig?.bounds;
-        if (bounds) {
-            if (bounds.minX !== undefined)
-                cameraState.x = Math.max(cameraState.x, bounds.minX);
-            if (bounds.maxX !== undefined)
-                cameraState.x = Math.min(cameraState.x, bounds.maxX);
-            if (bounds.minY !== undefined)
-                cameraState.y = Math.max(cameraState.y, bounds.minY);
-            if (bounds.maxY !== undefined)
-                cameraState.y = Math.min(cameraState.y, bounds.maxY);
-        }
-        // Apply camera shake
-        if (cameraState.shakeTimeRemaining > 0) {
-            const intensity = cameraState.shakeIntensity;
-            cameraState.x += (Math.random() - 0.5) * intensity;
-            cameraState.y += (Math.random() - 0.5) * intensity;
-            cameraState.shakeTimeRemaining -= delta * 16.67;
-            if (cameraState.shakeTimeRemaining <= 0) {
-                cameraState.shakeIntensity = 0;
-            }
-        }
-        // Apply zoom
-        cameraState.zoom = cameraConfig?.zoom ?? 1;
-    });
-}

package/dist/scene/components/ComponentRunner.d.ts

@@ -1,22 +0,0 @@
-import type { SceneContextValue, EntityState } from '../SceneContext.js';
-/**
- * Generic component type
- */
-interface GenericComponent {
-    type: string;
-    params?: Record<string, unknown>;
-}
-/**
- * Component handler function type
- */
-type ComponentHandler = (state: EntityState, component: GenericComponent, context: SceneContextValue, delta: number) => void;
-/**
- * Hook to run component logic each frame
- */
-export declare function useComponentRunner(context: SceneContextValue): void;
-/**
- * Register a custom component handler
- */
-export declare function registerComponent(type: string, handler: ComponentHandler): void;
-export {};
-//# sourceMappingURL=ComponentRunner.d.ts.map

package/dist/scene/components/ComponentRunner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComponentRunner.d.ts","sourceRoot":"","sources":["../../../src/scene/components/ComponentRunner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAazE;;GAEG;AACH,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,KAAK,gBAAgB,GAAG,CACtB,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,iBAAiB,EAC1B,KAAK,EAAE,MAAM,KACV,IAAI,CAAC;AAcV;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,iBAAiB,QAkB5D;AA8ND;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,QAExE"}

package/dist/scene/components/ComponentRunner.js

@@ -1,210 +0,0 @@
-'use client';
-import { useGameLoop } from '../../pixi/index.js';
-import { isJumpPressed } from '../input/InputManager.js';
-import { setVelocity } from '../physics/PhysicsEngine.js';
-import Matter from 'matter-js';
-const { Body } = Matter;
-/**
- * Registry of component handlers
- */
-const componentHandlers = {
-    Move: handleMove,
-    Rotate: handleRotate,
-    Oscillate: handleOscillate,
-    Follow: handleFollow,
-    DashPlayer: handleDashPlayer,
-    // Add more handlers as needed
-};
-/**
- * Hook to run component logic each frame
- */
-export function useComponentRunner(context) {
-    const { entities } = context;
-    useGameLoop((delta) => {
-        for (const [, state] of entities.current) {
-            if (state.destroyed)
-                continue;
-            const components = state.entity.components;
-            if (!components)
-                continue;
-            for (const component of components) {
-                const handler = componentHandlers[component.type];
-                if (handler) {
-                    handler(state, component, context, delta);
-                }
-            }
-        }
-    });
-}
-/**
- * Move component - applies constant velocity/acceleration
- */
-function handleMove(state, component, context, delta) {
-    const params = (component.params ?? {});
-    // Apply acceleration
-    if (params.accelX) {
-        state.velocityX += params.accelX * delta * 0.016;
-    }
-    if (params.accelY) {
-        state.velocityY += params.accelY * delta * 0.016;
-    }
-    // Apply constant velocity (overrides physics for non-physics entities)
-    if (!state.body) {
-        if (params.velocityX !== undefined) {
-            state.x += params.velocityX * delta * 0.016;
-        }
-        if (params.velocityY !== undefined) {
-            state.y += params.velocityY * delta * 0.016;
-        }
-    }
-    else if (params.velocityX !== undefined || params.velocityY !== undefined) {
-        // For physics bodies, set velocity directly
-        setVelocity(state.body, params.velocityX ?? state.velocityX, params.velocityY ?? state.velocityY);
-    }
-}
-/**
- * Rotate component - spins the entity
- */
-function handleRotate(state, component, context, delta) {
-    const params = (component.params ?? { speed: 0 });
-    const rotationSpeed = (params.speed * Math.PI) / 180; // Convert to radians/second
-    state.rotation += rotationSpeed * delta * 0.016;
-    // Update physics body rotation if present
-    if (state.body) {
-        Body.setAngle(state.body, state.rotation);
-    }
-}
-/**
- * Oscillate component - sine wave motion
- */
-function handleOscillate(state, component, context, delta) {
-    const params = (component.params ?? { axis: 'y', amplitude: 10, frequency: 1 });
-    const { axis, amplitude, frequency, phase = 0 } = params;
-    // Get or initialize oscillation state
-    if (state.componentState.oscillateTime === undefined) {
-        state.componentState.oscillateTime = 0;
-        state.componentState.oscillateStartX = state.x;
-        state.componentState.oscillateStartY = state.y;
-    }
-    state.componentState.oscillateTime += delta * 0.016;
-    const time = state.componentState.oscillateTime;
-    const offset = Math.sin(time * frequency * Math.PI * 2 + phase) * amplitude;
-    if (axis === 'x') {
-        state.x = state.componentState.oscillateStartX + offset;
-    }
-    else {
-        state.y = state.componentState.oscillateStartY + offset;
-    }
-    // Update physics body position if present and static
-    if (state.body && state.entity.body?.isStatic) {
-        Body.setPosition(state.body, { x: state.x, y: state.y });
-    }
-}
-/**
- * Follow component - tracks another entity
- */
-function handleFollow(state, component, context, delta) {
-    const params = (component.params ?? { target: '' });
-    const { target, offsetX = 0, offsetY = 0, smoothing = 0.1 } = params;
-    const targetEntity = context.getEntity(target);
-    if (!targetEntity)
-        return;
-    const targetX = targetEntity.x + offsetX;
-    const targetY = targetEntity.y + offsetY;
-    // Lerp towards target
-    state.x += (targetX - state.x) * smoothing;
-    state.y += (targetY - state.y) * smoothing;
-    // Update physics body if present
-    if (state.body) {
-        Body.setPosition(state.body, { x: state.x, y: state.y });
-    }
-}
-/**
- * DashPlayer component - main player controller for Geometry Dash style games
- */
-function handleDashPlayer(state, component, context, delta) {
-    const { player, camera, emitEvent, respawnPlayer } = context;
-    const playerState = player.current;
-    // Handle jump input (check before started check so we can start the game)
-    const jumpPressed = isJumpPressed(context);
-    const wasJumpPressed = state.componentState.wasJumpPressed ?? false;
-    const justPressed = jumpPressed && !wasJumpPressed;
-    state.componentState.wasJumpPressed = jumpPressed;
-    // Start the game on first jump
-    if (!playerState.started && justPressed) {
-        playerState.started = true;
-        emitEvent('game.started');
-        return; // Don't process jump on the start frame
-    }
-    // Don't run game logic until started
-    if (!playerState.started) {
-        return;
-    }
-    // Handle death
-    if (playerState.dead) {
-        // Wait a moment then respawn
-        if (state.componentState.deathTimer === undefined) {
-            state.componentState.deathTimer = 0;
-        }
-        state.componentState.deathTimer += delta * 16.67;
-        if (state.componentState.deathTimer > 500) {
-            state.componentState.deathTimer = 0;
-            respawnPlayer();
-        }
-        return;
-    }
-    // Handle jump (only after game started)
-    if (justPressed) {
-        // Check if touching an orb
-        if (playerState.touchingOrb) {
-            const orb = context.getEntity(playerState.touchingOrb);
-            if (orb) {
-                const orbComponent = orb.entity.components?.find((c) => c.type === 'JumpOrb');
-                const impulse = orbComponent?.params?.impulse ?? -900;
-                if (state.body) {
-                    Body.setVelocity(state.body, {
-                        x: state.body.velocity.x,
-                        y: impulse * 0.01 * playerState.gravityDir,
-                    });
-                }
-                emitEvent('orb.used', { orbId: playerState.touchingOrb });
-                playerState.touchingOrb = null;
-            }
-        }
-        // Normal jump from ground
-        else if (playerState.grounded) {
-            const jumpVelocity = -15 * playerState.gravityDir;
-            if (state.body) {
-                Body.setVelocity(state.body, {
-                    x: state.body.velocity.x,
-                    y: jumpVelocity,
-                });
-            }
-            playerState.grounded = false;
-            playerState.jumpCount++;
-            emitEvent('player.jump', { jumpCount: playerState.jumpCount });
-        }
-    }
-    // Clear orb touching state if not colliding anymore
-    // This is handled in physics collision detection
-    // Rotate player based on movement (visual only)
-    if (state.body && Math.abs(state.body.velocity.y) > 1) {
-        state.rotation += 0.1 * delta * playerState.gravityDir;
-    }
-    // Apply constant forward velocity (for auto-runners)
-    // Physics velocity is in px/s, engine runs at 16.67ms steps
-    // To match camera scroll: velocity = scrollSpeed (direct, physics handles timing)
-    const scrollSpeed = (context.spec.camera?.scrollSpeed ?? 320) * playerState.speedMultiplier;
-    if (state.body) {
-        Body.setVelocity(state.body, {
-            x: scrollSpeed,
-            y: state.body.velocity.y,
-        });
-    }
-}
-/**
- * Register a custom component handler
- */
-export function registerComponent(type, handler) {
-    componentHandlers[type] = handler;
-}

package/dist/scene/effects/GlowFilter.d.ts

@@ -1,38 +0,0 @@
-/**
- * Glow effect utilities
- *
- * Note: Full glow filter implementation requires @pixi/filter-glow
- * which is an optional peer dependency. This file provides helper
- * functions for creating and managing glow effects.
- */
-export interface GlowOptions {
-    color?: string;
-    strength?: number;
-    blur?: number;
-    quality?: number;
-}
-/**
- * Parse color string to number
- */
-export declare function parseColor(color: string): number;
-/**
- * Create glow filter options
- * Returns options compatible with @pixi/filter-glow GlowFilter
- */
-export declare function createGlowOptions(options?: GlowOptions): {
-    color: number;
-    outerStrength: number;
-    innerStrength: number;
-    distance: number;
-    quality: number;
-};
-/**
- * Check if glow filter is available
- * Returns true if @pixi/filter-glow is installed
- */
-export declare function isGlowFilterAvailable(): boolean;
-/**
- * Create a CSS text-shadow style for glow effect (fallback)
- */
-export declare function createGlowShadow(color: string, strength: number, blur: number): string;
-//# sourceMappingURL=GlowFilter.d.ts.map