@thewhateverapp/tile-sdk 0.15.3 → 0.15.4

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;
-    }
-}