yuuna-engine 0.8.0 → 0.10.0

package/README.md

@@ -84,7 +84,7 @@ runEngine<GameState>({
   `CIRCLE`, `TEXT`, `SPRITE`, `ANIMATED_SPRITE`, `LINE`, and `GROUP`. Give
   one an `id` plus `isClickable`/`isHoverable` to make it interactive.
 - **Events** — `nextState` receives one `GameEvent` per call: `TIME`,
-  `CLICK`, `HOVER_IN`, `HOVER_OUT`, `MOUSE_MOVE`, `MOUSE_LEAVE`,
+  `CLICK`, `RIGHT_CLICK`, `HOVER_IN`, `HOVER_OUT`, `MOUSE_MOVE`, `MOUSE_LEAVE`,
   `MUSIC_END`, or a `CUSTOM` event of a type you define yourself, for
   reporting things like an async `fetch()` resolving back into your
   state machine.

package/lib/engine/types.d.ts

@@ -117,6 +117,18 @@ export type ClickEvent = {
         y: number;
     };
 };
+export type RightClickEvent = {
+    tag: "RIGHT_CLICK";
+    id?: string;
+    mouse: {
+        x: number;
+        y: number;
+    };
+    worldMouse: {
+        x: number;
+        y: number;
+    };
+};
 export type HoverInEvent = {
     tag: "HOVER_IN";
     id?: string;
@@ -178,7 +190,7 @@ export type FullscreenChangeEvent = {
     tag: "FULLSCREEN_CHANGE";
     isFullscreen: boolean;
 };
-export type GameEvent = TimeEvent | ClickEvent | HoverInEvent | HoverOutEvent | MouseMoveEvent | MouseLeaveEvent | TabBlurEvent | TabFocusEvent | MusicEndEvent | FullscreenChangeEvent;
+export type GameEvent = TimeEvent | ClickEvent | RightClickEvent | HoverInEvent | HoverOutEvent | MouseMoveEvent | MouseLeaveEvent | TabBlurEvent | TabFocusEvent | MusicEndEvent | FullscreenChangeEvent;
 export type CustomGameEvent<Custom> = {
     tag: "CUSTOM";
     event: Custom;
@@ -196,6 +208,11 @@ export type NextStateProps<State, Custom = never> = {
         isJustPressed: boolean;
         isJustReleased: boolean;
     };
+    rightMouseButton: {
+        isPressed: boolean;
+        isJustPressed: boolean;
+        isJustReleased: boolean;
+    };
     playSound: (id: string) => void;
     playMusic: (id: string) => void;
     pauseMusic: () => void;
@@ -240,6 +257,7 @@ export type RunEngineProps<State, Custom = never> = {
         height?: number;
         backgroundColor?: string;
         resize?: "none" | "fit" | "stretch";
+        disableContextMenu?: boolean;
         pixelRatio?: number | true;
     };
     camera?: (state: State) => {
@@ -248,6 +266,7 @@ export type RunEngineProps<State, Custom = never> = {
         zoom: number;
     };
     timeScale?: (state: State) => number;
+    maxFps?: (state: State) => number;
 };
 export type RunEngineFunction = <State, Custom = never>(props: RunEngineProps<State, Custom>) => Promise<{
     sendEvent: (event: Custom) => void;

package/lib/index.cjs

@@ -680,6 +680,9 @@ const runEngine = async (props) => {
     };
     const nextStateFns = Array.isArray(props.nextState) ? props.nextState : [props.nextState];
     let lastFrame = Date.now();
+    // When the next tick is due under RunEngineProps.maxFps — only read
+    // or advanced while a cap is set (see the top of the loop below).
+    let nextTickAt = 0;
     let hoveredId = null;
     // How much this tick's simulated time is scaled by (see
     // RunEngineProps.timeScale) — set once per tick, right before that
@@ -689,21 +692,33 @@ const runEngine = async (props) => {
     // one tick rather than each recomputing props.timeScale(state)
     // separately (state may itself have just changed this same tick).
     let currentTimeScale = 1;
-    // Shared by the mouse "click" listener and the touch handlers below —
-    // firing a CLICK is the same "is whatever's currently hovered
-    // isClickable" check either way; only how `mouse` was determined
-    // differs (a real click event vs. a lifted finger).
-    const fireClick = (mouse) => {
+    // Shared by the mouse "click"/"contextmenu" listeners and the touch
+    // handlers below — firing a CLICK (or RIGHT_CLICK) is the same "is
+    // whatever's currently hovered isClickable" check either way; only how
+    // `mouse` was determined differs (a real click event vs. a lifted
+    // finger), and which button it was.
+    const fireClick = (mouse, tag = "CLICK") => {
         if (hoveredId === null)
             return;
         const { renderables, camera } = renderState(state);
         const hovered = renderables.find((e) => e.id === hoveredId);
         if (hovered !== undefined && hovered.isClickable) {
-            events.push({ tag: "CLICK", id: hovered.id, mouse, worldMouse: toWorldPosition(mouse, camera) });
+            events.push({ tag, id: hovered.id, mouse, worldMouse: toWorldPosition(mouse, camera) });
         }
     };
     const handleClick = (ev) => fireClick(getCanvasPosition(ev));
     canvas.addEventListener("click", handleClick);
+    // contextmenu rather than mouseup with button 2 — it's the browser's
+    // own "secondary click" (Ctrl+click on macOS included), the same way
+    // "click" above is its primary one, and it's the event that has to be
+    // cancelled to keep the browser's menu from opening anyway.
+    const handleContextMenu = (ev) => {
+        if (props.canvas?.disableContextMenu ?? true) {
+            ev.preventDefault();
+        }
+        fireClick(getCanvasPosition(ev), "RIGHT_CLICK");
+    };
+    canvas.addEventListener("contextmenu", handleContextMenu);
     const initialState = {
         keyboardState: createRecord(keyboardKeys, () => false),
     };
@@ -732,22 +747,30 @@ const runEngine = async (props) => {
         }
     };
     canvas.addEventListener("keyup", handleKeyUp);
-    // mouseButton state (see NextStateProps.mouseButton) — a double-buffer
-    // exactly like keyboardState above, just for the primary mouse button.
+    // mouseButton/rightMouseButton state (see NextStateProps.mouseButton)
+    // — double-buffers exactly like keyboardState above, one per button.
     let previousMouseButtonState = { isPressed: false };
     const currentMouseButtonState = { isPressed: false };
+    let previousRightMouseButtonState = { isPressed: false };
+    const currentRightMouseButtonState = { isPressed: false };
     const handleMouseDown = (event) => {
-        // Left/primary button only — matching CLICK, which already only
-        // ever fires for it.
+        // Primary and secondary buttons only — matching CLICK and
+        // RIGHT_CLICK respectively. Middle/back/forward stay ignored.
         if (event.button === 0) {
             currentMouseButtonState.isPressed = true;
         }
+        else if (event.button === 2) {
+            currentRightMouseButtonState.isPressed = true;
+        }
     };
     canvas.addEventListener("mousedown", handleMouseDown);
     const handleMouseUp = (event) => {
         if (event.button === 0) {
             currentMouseButtonState.isPressed = false;
         }
+        else if (event.button === 2) {
+            currentRightMouseButtonState.isPressed = false;
+        }
     };
     // On window rather than the canvas — so releasing the button after
     // having dragged off the canvas while still holding it down still
@@ -1002,6 +1025,27 @@ const runEngine = async (props) => {
     const intervalId = setInterval(() => {
         const now = Date.now();
         const rawDelta = now - lastFrame;
+        // Skipped rather than delayed (see RunEngineProps.maxFps) — returning
+        // before anything else runs leaves `events`, keyboard/mouse state and
+        // lastFrame all untouched, so whatever happened in the meantime is
+        // still delivered by the next tick that does run, and its TIME delta
+        // covers this skipped one too.
+        const maxFps = props.maxFps?.(state);
+        if (maxFps !== undefined && maxFps > 0) {
+            if (now < nextTickAt) {
+                return;
+            }
+            // Scheduled from the previous target rather than from `now`: the
+            // interval only fires every ~4ms, so "at least 1000/maxFps since
+            // the last tick" would always round late (a 60 cap landing on
+            // 20ms ticks, i.e. 50 FPS), while this lets the early and late
+            // ticks average out to the cap itself. Falling more than a whole
+            // interval behind (a hitch, a backgrounded tab, the cap having
+            // just been turned on) restarts the schedule from now instead of
+            // bursting through every missed tick to catch up.
+            const interval = 1000 / maxFps;
+            nextTickAt = now - nextTickAt > interval ? now + interval : nextTickAt + interval;
+        }
         // Read from state as this tick starts (i.e. still last tick's own
         // result) — resolveAnimatedSprite (below, during this same tick's
         // render pass) reads this same currentTimeScale rather than calling
@@ -1024,12 +1068,18 @@ const runEngine = async (props) => {
                 isJustPressed: currentMouseButtonState.isPressed && !previousMouseButtonState.isPressed,
                 isJustReleased: !currentMouseButtonState.isPressed && previousMouseButtonState.isPressed,
             };
+            const rightMouseButton = {
+                isPressed: currentRightMouseButtonState.isPressed,
+                isJustPressed: currentRightMouseButtonState.isPressed && !previousRightMouseButtonState.isPressed,
+                isJustReleased: !currentRightMouseButtonState.isPressed && previousRightMouseButtonState.isPressed,
+            };
             for (const nextState of nextStateFns) {
                 const result = nextState({
                     state,
                     event,
                     keyboard,
                     mouseButton,
+                    rightMouseButton,
                     playSound,
                     playMusic,
                     pauseMusic,
@@ -1161,6 +1211,7 @@ const runEngine = async (props) => {
         lastFrame = now;
         previousState.keyboardState = { ...currentState.keyboardState };
         previousMouseButtonState = { ...currentMouseButtonState };
+        previousRightMouseButtonState = { ...currentRightMouseButtonState };
     }, 0);
     resetCanvas = () => {
         clearInterval(intervalId);
@@ -1182,6 +1233,7 @@ const runEngine = async (props) => {
         // slow enough device or long enough playground session, that pile-up
         // is what "clicks stop working" actually looks like.
         canvas.removeEventListener("click", handleClick);
+        canvas.removeEventListener("contextmenu", handleContextMenu);
         canvas.removeEventListener("keydown", handleKeyDown);
         canvas.removeEventListener("keyup", handleKeyUp);
         canvas.removeEventListener("mousedown", handleMouseDown);

package/lib/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/index.js

@@ -678,6 +678,9 @@ const runEngine = async (props) => {
     };
     const nextStateFns = Array.isArray(props.nextState) ? props.nextState : [props.nextState];
     let lastFrame = Date.now();
+    // When the next tick is due under RunEngineProps.maxFps — only read
+    // or advanced while a cap is set (see the top of the loop below).
+    let nextTickAt = 0;
     let hoveredId = null;
     // How much this tick's simulated time is scaled by (see
     // RunEngineProps.timeScale) — set once per tick, right before that
@@ -687,21 +690,33 @@ const runEngine = async (props) => {
     // one tick rather than each recomputing props.timeScale(state)
     // separately (state may itself have just changed this same tick).
     let currentTimeScale = 1;
-    // Shared by the mouse "click" listener and the touch handlers below —
-    // firing a CLICK is the same "is whatever's currently hovered
-    // isClickable" check either way; only how `mouse` was determined
-    // differs (a real click event vs. a lifted finger).
-    const fireClick = (mouse) => {
+    // Shared by the mouse "click"/"contextmenu" listeners and the touch
+    // handlers below — firing a CLICK (or RIGHT_CLICK) is the same "is
+    // whatever's currently hovered isClickable" check either way; only how
+    // `mouse` was determined differs (a real click event vs. a lifted
+    // finger), and which button it was.
+    const fireClick = (mouse, tag = "CLICK") => {
         if (hoveredId === null)
             return;
         const { renderables, camera } = renderState(state);
         const hovered = renderables.find((e) => e.id === hoveredId);
         if (hovered !== undefined && hovered.isClickable) {
-            events.push({ tag: "CLICK", id: hovered.id, mouse, worldMouse: toWorldPosition(mouse, camera) });
+            events.push({ tag, id: hovered.id, mouse, worldMouse: toWorldPosition(mouse, camera) });
         }
     };
     const handleClick = (ev) => fireClick(getCanvasPosition(ev));
     canvas.addEventListener("click", handleClick);
+    // contextmenu rather than mouseup with button 2 — it's the browser's
+    // own "secondary click" (Ctrl+click on macOS included), the same way
+    // "click" above is its primary one, and it's the event that has to be
+    // cancelled to keep the browser's menu from opening anyway.
+    const handleContextMenu = (ev) => {
+        if (props.canvas?.disableContextMenu ?? true) {
+            ev.preventDefault();
+        }
+        fireClick(getCanvasPosition(ev), "RIGHT_CLICK");
+    };
+    canvas.addEventListener("contextmenu", handleContextMenu);
     const initialState = {
         keyboardState: createRecord(keyboardKeys, () => false),
     };
@@ -730,22 +745,30 @@ const runEngine = async (props) => {
         }
     };
     canvas.addEventListener("keyup", handleKeyUp);
-    // mouseButton state (see NextStateProps.mouseButton) — a double-buffer
-    // exactly like keyboardState above, just for the primary mouse button.
+    // mouseButton/rightMouseButton state (see NextStateProps.mouseButton)
+    // — double-buffers exactly like keyboardState above, one per button.
     let previousMouseButtonState = { isPressed: false };
     const currentMouseButtonState = { isPressed: false };
+    let previousRightMouseButtonState = { isPressed: false };
+    const currentRightMouseButtonState = { isPressed: false };
     const handleMouseDown = (event) => {
-        // Left/primary button only — matching CLICK, which already only
-        // ever fires for it.
+        // Primary and secondary buttons only — matching CLICK and
+        // RIGHT_CLICK respectively. Middle/back/forward stay ignored.
         if (event.button === 0) {
             currentMouseButtonState.isPressed = true;
         }
+        else if (event.button === 2) {
+            currentRightMouseButtonState.isPressed = true;
+        }
     };
     canvas.addEventListener("mousedown", handleMouseDown);
     const handleMouseUp = (event) => {
         if (event.button === 0) {
             currentMouseButtonState.isPressed = false;
         }
+        else if (event.button === 2) {
+            currentRightMouseButtonState.isPressed = false;
+        }
     };
     // On window rather than the canvas — so releasing the button after
     // having dragged off the canvas while still holding it down still
@@ -1000,6 +1023,27 @@ const runEngine = async (props) => {
     const intervalId = setInterval(() => {
         const now = Date.now();
         const rawDelta = now - lastFrame;
+        // Skipped rather than delayed (see RunEngineProps.maxFps) — returning
+        // before anything else runs leaves `events`, keyboard/mouse state and
+        // lastFrame all untouched, so whatever happened in the meantime is
+        // still delivered by the next tick that does run, and its TIME delta
+        // covers this skipped one too.
+        const maxFps = props.maxFps?.(state);
+        if (maxFps !== undefined && maxFps > 0) {
+            if (now < nextTickAt) {
+                return;
+            }
+            // Scheduled from the previous target rather than from `now`: the
+            // interval only fires every ~4ms, so "at least 1000/maxFps since
+            // the last tick" would always round late (a 60 cap landing on
+            // 20ms ticks, i.e. 50 FPS), while this lets the early and late
+            // ticks average out to the cap itself. Falling more than a whole
+            // interval behind (a hitch, a backgrounded tab, the cap having
+            // just been turned on) restarts the schedule from now instead of
+            // bursting through every missed tick to catch up.
+            const interval = 1000 / maxFps;
+            nextTickAt = now - nextTickAt > interval ? now + interval : nextTickAt + interval;
+        }
         // Read from state as this tick starts (i.e. still last tick's own
         // result) — resolveAnimatedSprite (below, during this same tick's
         // render pass) reads this same currentTimeScale rather than calling
@@ -1022,12 +1066,18 @@ const runEngine = async (props) => {
                 isJustPressed: currentMouseButtonState.isPressed && !previousMouseButtonState.isPressed,
                 isJustReleased: !currentMouseButtonState.isPressed && previousMouseButtonState.isPressed,
             };
+            const rightMouseButton = {
+                isPressed: currentRightMouseButtonState.isPressed,
+                isJustPressed: currentRightMouseButtonState.isPressed && !previousRightMouseButtonState.isPressed,
+                isJustReleased: !currentRightMouseButtonState.isPressed && previousRightMouseButtonState.isPressed,
+            };
             for (const nextState of nextStateFns) {
                 const result = nextState({
                     state,
                     event,
                     keyboard,
                     mouseButton,
+                    rightMouseButton,
                     playSound,
                     playMusic,
                     pauseMusic,
@@ -1159,6 +1209,7 @@ const runEngine = async (props) => {
         lastFrame = now;
         previousState.keyboardState = { ...currentState.keyboardState };
         previousMouseButtonState = { ...currentMouseButtonState };
+        previousRightMouseButtonState = { ...currentRightMouseButtonState };
     }, 0);
     resetCanvas = () => {
         clearInterval(intervalId);
@@ -1180,6 +1231,7 @@ const runEngine = async (props) => {
         // slow enough device or long enough playground session, that pile-up
         // is what "clicks stop working" actually looks like.
         canvas.removeEventListener("click", handleClick);
+        canvas.removeEventListener("contextmenu", handleContextMenu);
         canvas.removeEventListener("keydown", handleKeyDown);
         canvas.removeEventListener("keyup", handleKeyUp);
         canvas.removeEventListener("mousedown", handleMouseDown);

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yuuna-engine",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "A lightweight, state-machine-based TypeScript game engine for quick prototypes. Runs directly in the browser.",
   "type": "module",
   "main": "./lib/index.cjs",