@thewhateverapp/tile-sdk 0.15.3 → 0.15.5

package/dist/scene/physics/PhysicsEngine.js

@@ -1,260 +0,0 @@
-'use client';
-import { useEffect, useRef } from 'react';
-import Matter from 'matter-js';
-import { useGameLoop } from '../../pixi/index.js';
-const { Engine, World, Bodies, Body, Events } = Matter;
-/**
- * Creates a Matter.js body from an entity state
- */
-function createBody(state, worldGravity) {
-    const { entity } = state;
-    const bodyConfig = entity.body;
-    // No physics body
-    if (!bodyConfig || bodyConfig.type === 'none') {
-        return null;
-    }
-    const transform = entity.transform;
-    const x = transform.x;
-    const y = transform.y;
-    const rotation = (transform.rotation ?? 0) * (Math.PI / 180);
-    // Common body options
-    const options = {
-        isStatic: bodyConfig.isStatic ?? false,
-        isSensor: bodyConfig.type === 'sensor',
-        restitution: bodyConfig.restitution ?? 0,
-        friction: bodyConfig.friction ?? 0.1,
-        frictionAir: 0.01,
-        angle: rotation,
-        label: entity.id,
-        collisionFilter: {
-            category: bodyConfig.category ?? 0x0001,
-            mask: bodyConfig.mask ?? 0xFFFF,
-        },
-    };
-    let body = null;
-    // Create body based on shape
-    switch (bodyConfig.shape) {
-        case 'rect': {
-            const geom = entity.geom;
-            body = Bodies.rectangle(x, y, geom.w, geom.h, options);
-            break;
-        }
-        case 'circle': {
-            const geom = entity.geom;
-            body = Bodies.circle(x, y, geom.r, options);
-            break;
-        }
-        case 'poly': {
-            const geom = entity.geom;
-            // Convert points to Matter.js format
-            const vertices = geom.points.map(([px, py]) => ({ x: px, y: py }));
-            body = Bodies.fromVertices(x, y, [vertices], options);
-            break;
-        }
-        default:
-            console.warn(`Unknown body shape: ${bodyConfig.shape}`);
-            return null;
-    }
-    return body;
-}
-/**
- * Hook to initialize and run the physics engine
- */
-export function usePhysicsEngine(context, width, height) {
-    const { spec, entities, player, engine: engineRef, emitEvent } = context;
-    const bodiesMapRef = useRef(new Map());
-    // Get gravity from spec
-    const gravity = spec.world?.gravity ?? 2600;
-    // Initialize engine
-    useEffect(() => {
-        // Create engine with gravity
-        const engine = Engine.create({
-            gravity: {
-                x: 0,
-                y: gravity / 1000, // Matter.js uses different scale
-                scale: 0.001,
-            },
-        });
-        engineRef.current = engine;
-        // Create bodies for all entities
-        const bodiesMap = new Map();
-        const bodiesToAdd = [];
-        for (const [id, state] of entities.current) {
-            const body = createBody(state, gravity);
-            if (body) {
-                bodiesMap.set(id, body);
-                bodiesToAdd.push(body);
-                state.body = body;
-            }
-        }
-        // Add all bodies to world
-        World.add(engine.world, bodiesToAdd);
-        bodiesMapRef.current = bodiesMap;
-        // Set up collision events
-        Events.on(engine, 'collisionStart', (event) => {
-            for (const pair of event.pairs) {
-                const entityA = entities.current.get(pair.bodyA.label);
-                const entityB = entities.current.get(pair.bodyB.label);
-                if (entityA && entityB) {
-                    handleCollision(entityA, entityB, context);
-                }
-            }
-        });
-        // Cleanup
-        return () => {
-            Events.off(engine, 'collisionStart');
-            World.clear(engine.world, false);
-            Engine.clear(engine);
-            engineRef.current = null;
-        };
-    }, [spec, gravity, engineRef, entities]);
-    // Physics update loop
-    useGameLoop((delta) => {
-        const engine = engineRef.current;
-        if (!engine)
-            return;
-        const playerState = player.current;
-        // Update invincibility timer
-        if (playerState.invincible && playerState.invincibilityTimeRemaining > 0) {
-            playerState.invincibilityTimeRemaining -= 16.67 * delta;
-            if (playerState.invincibilityTimeRemaining <= 0) {
-                playerState.invincible = false;
-                playerState.invincibilityTimeRemaining = 0;
-            }
-        }
-        // Update gravity direction for player
-        engine.gravity.y = (gravity / 1000) * playerState.gravityDir;
-        // Step physics (delta is ~1 at 60fps, so we use 16.67ms per frame)
-        Engine.update(engine, 16.67 * delta);
-        // Sync entity positions from physics bodies
-        for (const [id, body] of bodiesMapRef.current) {
-            const state = entities.current.get(id);
-            if (!state || state.destroyed)
-                continue;
-            // Update entity position from body
-            state.x = body.position.x;
-            state.y = body.position.y;
-            state.rotation = body.angle;
-            state.velocityX = body.velocity.x;
-            state.velocityY = body.velocity.y;
-        }
-        // Check if player is grounded
-        const playerEntity = findPlayerEntity(entities.current);
-        if (playerEntity?.body) {
-            const body = playerEntity.body;
-            // Simple ground check - if velocity.y is very small and we're not in the air
-            playerState.grounded = Math.abs(body.velocity.y) < 0.5;
-        }
-        // Check for death (fell off screen) - only if height is valid and not invincible
-        if (playerEntity && height > 0 && playerEntity.y > height + 200) {
-            if (!playerState.dead && !playerState.invincible) {
-                playerState.dead = true;
-                playerState.deaths++;
-                emitEvent('player.death', { cause: 'fall', deaths: playerState.deaths });
-            }
-        }
-    });
-}
-/**
- * Handle collision between two entities
- */
-function handleCollision(entityA, entityB, context) {
-    const { player, emitEvent } = context;
-    const playerState = player.current;
-    // Check if either entity is the player
-    const isPlayerA = entityA.entity.tags?.includes('player');
-    const isPlayerB = entityB.entity.tags?.includes('player');
-    if (!isPlayerA && !isPlayerB)
-        return;
-    const playerEntity = isPlayerA ? entityA : entityB;
-    const otherEntity = isPlayerA ? entityB : entityA;
-    const otherTags = otherEntity.entity.tags ?? [];
-    // Check for hazard collision (only if not invincible)
-    if (otherTags.includes('hazard') || hasComponent(otherEntity, 'KillOnTouch')) {
-        if (!playerState.dead && !playerState.invincible) {
-            playerState.dead = true;
-            playerState.deaths++;
-            emitEvent('player.death', { cause: 'hazard', deaths: playerState.deaths });
-        }
-        return;
-    }
-    // Check for checkpoint collision
-    if (otherTags.includes('checkpoint') || hasComponent(otherEntity, 'Checkpoint')) {
-        playerState.checkpointX = otherEntity.x;
-        playerState.checkpointY = otherEntity.y;
-        emitEvent('checkpoint.reached', { x: otherEntity.x, y: otherEntity.y });
-        return;
-    }
-    // Check for finish line collision
-    if (otherTags.includes('finish') || hasComponent(otherEntity, 'FinishLine')) {
-        if (!playerState.complete) {
-            playerState.complete = true;
-            emitEvent('level.complete', { deaths: playerState.deaths });
-        }
-        return;
-    }
-    // Check for jump orb collision
-    if (otherTags.includes('orb') || hasComponent(otherEntity, 'JumpOrb')) {
-        playerState.touchingOrb = otherEntity.entity.id;
-        return;
-    }
-    // Check for speed portal collision
-    if (hasComponent(otherEntity, 'SpeedPortal')) {
-        const component = getComponent(otherEntity, 'SpeedPortal');
-        const params = component?.params;
-        if (params?.speed) {
-            playerState.speedMultiplier = params.speed / 320; // Base speed
-            emitEvent('speed.changed', { speed: params.speed });
-        }
-        return;
-    }
-    // Check for gravity portal collision
-    if (hasComponent(otherEntity, 'GravityPortal')) {
-        playerState.gravityDir *= -1;
-        emitEvent('gravity.flipped', { direction: playerState.gravityDir });
-        return;
-    }
-    // Ground collision - reset jump count
-    if (otherEntity.entity.body?.isStatic && !otherEntity.entity.body?.type) {
-        playerState.grounded = true;
-        playerState.jumpCount = 0;
-    }
-}
-/**
- * Find the player entity
- */
-function findPlayerEntity(entities) {
-    for (const [, state] of entities) {
-        if (state.entity.tags?.includes('player')) {
-            return state;
-        }
-    }
-    return null;
-}
-/**
- * Check if entity has a component
- */
-function hasComponent(state, type) {
-    return state.entity.components?.some((c) => c.type === type) ?? false;
-}
-/**
- * Get a component from an entity
- */
-function getComponent(state, type) {
-    return state.entity.components?.find((c) => c.type === type);
-}
-/**
- * Apply impulse to a body
- */
-export function applyImpulse(body, impulseX, impulseY) {
-    Body.applyForce(body, body.position, {
-        x: impulseX * 0.001,
-        y: impulseY * 0.001,
-    });
-}
-/**
- * Set velocity on a body
- */
-export function setVelocity(body, velocityX, velocityY) {
-    Body.setVelocity(body, { x: velocityX, y: velocityY });
-}

package/dist/scene/timeline/TimelineExecutor.d.ts

@@ -1,6 +0,0 @@
-import type { SceneContextValue } from '../SceneContext.js';
-/**
- * Hook to execute timeline events
- */
-export declare function useTimelineExecutor(context: SceneContextValue): void;
-//# sourceMappingURL=TimelineExecutor.d.ts.map

package/dist/scene/timeline/TimelineExecutor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"TimelineExecutor.d.ts","sourceRoot":"","sources":["../../../src/scene/timeline/TimelineExecutor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAe,MAAM,oBAAoB,CAAC;AAIzE;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,iBAAiB,QA4C7D"}

package/dist/scene/timeline/TimelineExecutor.js

@@ -1,241 +0,0 @@
-'use client';
-import { useGameLoop } from '../../pixi/index.js';
-import { getEasing } from '@thewhateverapp/scene-sdk';
-/**
- * Hook to execute timeline events
- */
-export function useTimelineExecutor(context) {
-    const { spec, timeline, entities, camera, emitEvent, spawnEntity, bpm, player } = context;
-    const timelineEvents = spec.timeline ?? [];
-    useGameLoop((delta) => {
-        const state = timeline.current;
-        const playerState = player.current;
-        const elapsedMs = state.elapsedMs;
-        const currentBeat = state.currentBeat;
-        // Don't process timeline until game has started
-        if (!playerState.started) {
-            return;
-        }
-        // Process pending timeline events
-        while (state.nextEventIndex < timelineEvents.length) {
-            const event = timelineEvents[state.nextEventIndex];
-            // Calculate event trigger time
-            let triggerTime;
-            if (event.atBeat !== undefined) {
-                triggerTime = beatToMs(event.atBeat, bpm);
-            }
-            else if (event.atTimeMs !== undefined) {
-                triggerTime = event.atTimeMs;
-            }
-            else {
-                // No timing specified, skip
-                state.nextEventIndex++;
-                continue;
-            }
-            // Check if event should fire
-            if (elapsedMs >= triggerTime) {
-                executeEvent(event, context);
-                state.nextEventIndex++;
-            }
-            else {
-                // Events are ordered, so we can stop here
-                break;
-            }
-        }
-        // Update active tweens
-        updateTweens(state.activeTweens, elapsedMs, context);
-    });
-}
-/**
- * Convert beat number to milliseconds
- */
-function beatToMs(beat, bpm) {
-    return (beat / (bpm / 60)) * 1000;
-}
-/**
- * Execute a timeline event
- */
-function executeEvent(event, context) {
-    const { entities, camera, timeline, emitEvent, spawnEntity } = context;
-    switch (event.type) {
-        case 'tween': {
-            const targetEntity = event.target ? entities.current.get(event.target) : null;
-            if (!targetEntity)
-                break;
-            const params = event.params;
-            const startValue = params.from ?? getPropertyValue(targetEntity, params.property);
-            const endValue = params.to;
-            const duration = params.duration;
-            // Add to active tweens
-            timeline.current.activeTweens.push({
-                targetId: event.target,
-                property: params.property,
-                startValue,
-                endValue,
-                startTime: timeline.current.elapsedMs,
-                duration,
-                easing: params.easing ?? 'linear',
-            });
-            break;
-        }
-        case 'pulse': {
-            const targetEntity = event.target ? entities.current.get(event.target) : null;
-            if (!targetEntity)
-                break;
-            const params = event.params;
-            const originalScale = targetEntity.scaleX;
-            const targetScale = params.scale ?? 1.2;
-            const duration = params.durationMs ?? (params.durationBeats ? beatToMs(params.durationBeats, context.bpm) : 200);
-            // Create scale up tween
-            timeline.current.activeTweens.push({
-                targetId: event.target,
-                property: 'scaleX',
-                startValue: originalScale,
-                endValue: originalScale * targetScale,
-                startTime: timeline.current.elapsedMs,
-                duration: duration / 2,
-                easing: 'easeOut',
-            });
-            // Create scale down tween (delayed)
-            setTimeout(() => {
-                timeline.current.activeTweens.push({
-                    targetId: event.target,
-                    property: 'scaleX',
-                    startValue: originalScale * targetScale,
-                    endValue: originalScale,
-                    startTime: timeline.current.elapsedMs,
-                    duration: duration / 2,
-                    easing: 'easeIn',
-                });
-            }, duration / 2);
-            break;
-        }
-        case 'colorSwap': {
-            const targetEntity = event.target ? entities.current.get(event.target) : null;
-            if (!targetEntity)
-                break;
-            targetEntity.fill = event.params.to;
-            break;
-        }
-        case 'cameraShake': {
-            const params = event.params;
-            const duration = params.durationMs ?? (params.durationBeats ? beatToMs(params.durationBeats, context.bpm) : 200);
-            camera.current.shakeIntensity = params.strength;
-            camera.current.shakeTimeRemaining = duration;
-            break;
-        }
-        case 'spawn': {
-            const params = event.params;
-            if (params.prefabId) {
-                const pos = params.at ?? { x: 0, y: 0 };
-                spawnEntity(params.prefabId, pos.x, pos.y);
-            }
-            break;
-        }
-        case 'toggle': {
-            const targetEntity = event.target ? entities.current.get(event.target) : null;
-            if (!targetEntity)
-                break;
-            const property = event.params.property ?? 'visible';
-            if (property === 'visible') {
-                targetEntity.visible = event.params.value ?? !targetEntity.visible;
-            }
-            break;
-        }
-        case 'set': {
-            const targetEntity = event.target ? entities.current.get(event.target) : null;
-            if (!targetEntity)
-                break;
-            setPropertyValue(targetEntity, event.params.path, event.params.value);
-            break;
-        }
-        case 'emit': {
-            emitEvent(event.params.event, event.params.payload);
-            break;
-        }
-    }
-}
-/**
- * Update active tweens
- */
-function updateTweens(tweens, elapsedMs, context) {
-    const { entities } = context;
-    const completedIndices = [];
-    for (let i = 0; i < tweens.length; i++) {
-        const tween = tweens[i];
-        const targetEntity = entities.current.get(tween.targetId);
-        if (!targetEntity) {
-            completedIndices.push(i);
-            continue;
-        }
-        const elapsed = elapsedMs - tween.startTime;
-        const progress = Math.min(elapsed / tween.duration, 1);
-        // Apply easing
-        const easingFn = getEasing(tween.easing);
-        const easedProgress = easingFn ? easingFn(progress) : progress;
-        // Interpolate value
-        const value = tween.startValue + (tween.endValue - tween.startValue) * easedProgress;
-        // Set property
-        setPropertyValue(targetEntity, tween.property, value);
-        // Check if complete
-        if (progress >= 1) {
-            completedIndices.push(i);
-        }
-    }
-    // Remove completed tweens (in reverse order to preserve indices)
-    for (let i = completedIndices.length - 1; i >= 0; i--) {
-        tweens.splice(completedIndices[i], 1);
-    }
-}
-/**
- * Get a property value from an entity
- */
-function getPropertyValue(entity, path) {
-    switch (path) {
-        case 'x':
-            return entity.x;
-        case 'y':
-            return entity.y;
-        case 'rotation':
-            return entity.rotation;
-        case 'scaleX':
-            return entity.scaleX;
-        case 'scaleY':
-            return entity.scaleY;
-        case 'alpha':
-            return entity.alpha;
-        default:
-            return 0;
-    }
-}
-/**
- * Set a property value on an entity
- */
-function setPropertyValue(entity, path, value) {
-    switch (path) {
-        case 'x':
-            entity.x = value;
-            break;
-        case 'y':
-            entity.y = value;
-            break;
-        case 'rotation':
-            entity.rotation = value;
-            break;
-        case 'scaleX':
-            entity.scaleX = value;
-            break;
-        case 'scaleY':
-            entity.scaleY = value;
-            break;
-        case 'alpha':
-            entity.alpha = value;
-            break;
-        case 'visible':
-            entity.visible = value;
-            break;
-        case 'fill':
-            entity.fill = value;
-            break;
-    }
-}