like2d 2.8.0 → 2.10.0

package/dist/prefab-scenes/mapGamepad.js

@@ -0,0 +1,181 @@
+import { defaultMapping } from "../input";
+const mapOrder = [
+    "BRight",
+    "BBottom",
+    "Up",
+    "Down",
+    "Left",
+    "Right",
+    "MenuLeft",
+    "MenuRight",
+    // 8: NES buttons
+    "L1",
+    "R1",
+    // 10: GBA buttons
+    "BLeft",
+    "BTop",
+    // 12: SNES buttons
+    "L2",
+    "R2",
+    // 14: PS1 buttons
+    "LeftStick",
+    "RightStick",
+];
+export const buttonSetNES = new Set(mapOrder.slice(0, 8));
+export const buttonSetGBA = new Set(mapOrder.slice(0, 10));
+export const buttonSetSNES = new Set(mapOrder.slice(0, 12));
+export const buttonSetPS1 = new Set(mapOrder.slice(0, 14));
+export const buttonSetAll = new Set(mapOrder);
+const drawCircButt = (pos, size) => (like, color) => like.gfx.circle("fill", color, pos, size);
+const drawDpadPart = (rot) => (like, color) => {
+    like.gfx.push();
+    like.gfx.translate([2.5, 6]);
+    like.gfx.rotate(rot);
+    like.gfx.rectangle("fill", color, [0.5, -0.5, 1.3, 1]);
+    like.gfx.pop();
+};
+const drawShoulder = (y, width, flip) => (like, color) => {
+    const r = 0.8;
+    const rectPos = [5 - width, y];
+    const circPos = [5 - width - r, y];
+    like.gfx.push();
+    if (flip) {
+        like.gfx.translate([16, 0]);
+        like.gfx.scale([-1, 1]);
+    }
+    like.gfx.circle("fill", color, circPos, r, { arc: [Math.PI, Math.PI * 3 / 2], center: false });
+    like.gfx.rectangle("fill", color, [...rectPos, width, r]);
+    like.gfx.pop();
+};
+// Buttons assume a centered resolution of 16x9px. Transforms exist for a reason lol.
+//      LLLLL           .             RRRRR
+//     LLLLLLLLL        .          RRRRRRRRR
+//                      .                  
+//       DDD         S  .  S              B
+// -.....DDD.....................................
+//    DDD   DDD         .           B        B
+//       DDD      LS    .    RS
+//       DDD            .              B 
+//                      .   
+const buttonProps = {
+    BLeft: { draw: drawCircButt([12, 6], 0.8) },
+    BRight: { draw: drawCircButt([15, 6], 0.8) },
+    BTop: { draw: drawCircButt([13.5, 4.5], 0.8) },
+    BBottom: { draw: drawCircButt([13.5, 7.5], 0.8) },
+    MenuLeft: { draw: drawCircButt([6, 4], 0.5) },
+    MenuRight: { draw: drawCircButt([10, 4], 0.5) },
+    LeftStick: { draw: drawCircButt([6.5, 7], 1.4) },
+    RightStick: { draw: drawCircButt([9.5, 7], 1.4) },
+    L1: { draw: drawShoulder(2, 3, false) },
+    L2: { draw: drawShoulder(1, 2, false) },
+    R1: { draw: drawShoulder(2, 3, true) },
+    R2: { draw: drawShoulder(1, 2, true) },
+    Right: { draw: drawDpadPart(0) },
+    Up: { draw: drawDpadPart(-Math.PI / 2) },
+    Left: { draw: drawDpadPart(Math.PI) },
+    Down: { draw: drawDpadPart(Math.PI / 2) },
+};
+export class MapGamepad {
+    constructor(mapMode, targetPad, next) {
+        Object.defineProperty(this, "mapMode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: mapMode
+        });
+        Object.defineProperty(this, "targetPad", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: targetPad
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: next
+        });
+        Object.defineProperty(this, "currentlyUnmapped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "mapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "held", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "alreadyMapped", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+    }
+    load(like) {
+        this.mapping = like.gamepad.getMapping(this.targetPad) ?? defaultMapping(2);
+        for (const btn of mapOrder.reverse()) {
+            if (this.mapMode.buttons.has(btn)) {
+                this.currentlyUnmapped.push(btn);
+            }
+        }
+        like.canvas.setMode([320, 240]);
+    }
+    draw(like) {
+        const centerText = {
+            font: "1px sans-serif",
+            align: "center",
+            width: 16,
+        };
+        const active = this.currentlyUnmapped.at(-1);
+        like.gfx.clear();
+        like.gfx.scale(20);
+        like.gfx.translate([0, 1]);
+        like.gfx.print("white", "Map gamepad (click to close)", [8, 0.0], centerText);
+        for (const prop of this.mapMode.buttons.keys()) {
+            const color = this.held == prop
+                ? "green"
+                : active == prop
+                    ? "red"
+                    : this.mapMode.buttons.has(prop)
+                        ? "gray"
+                        : "black";
+            buttonProps[prop].draw(like, color);
+        }
+        like.gfx.print("white", active
+            ? `Press ${like.gamepad.fullButtonName(active)}!`
+            : "Press any button to resume.", [2, 10], { font: "1px sans-serif" });
+    }
+    gamepadpressed(like, source, _name, num) {
+        if (source !== this.targetPad || this.held)
+            return;
+        const active = this.currentlyUnmapped.pop();
+        if (active && !this.alreadyMapped.has(num)) {
+            this.alreadyMapped.add(num);
+            this.mapping.buttons[num] = active;
+            this.held = active;
+        }
+        else if (!active) {
+            like.gamepad.setMapping(this.targetPad, this.mapping);
+            setTimeout(() => like.setScene(this.next), 100);
+        }
+    }
+    gamepadreleased(_like, source, _name, num) {
+        if (source !== this.targetPad)
+            return;
+        if (this.held == this.mapping.buttons[num]) {
+            this.held = undefined;
+        }
+    }
+    mousepressed(like) {
+        like.setScene(this.next);
+    }
+}

package/dist/prefab-scenes/startScreen.d.ts

@@ -0,0 +1,59 @@
+import { type Scene } from '../scene';
+import { Like } from '..';
+/**
+ * ## Why
+ *
+ *  1. Because the LIKE logo looks awesome.
+ *  2. Autoplay restriction, doesn't let you play audio until the page is clicked.
+ *  3. You have to click on the game in order to send inputs, anyway.
+ *  4. It's polite.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createLike, StartScreen } from 'like';
+ * import { GameScene } from './game';
+ *
+ * const container = document.getElementById("myGame");
+ * const like = createLike(container);
+ *
+ * // these callbacks will be ignored until the scene is clicked
+ * like.update = function () { ... }
+ * like.draw = function () { ... }
+ *
+ * // Set up the start screen
+ * like.setScene(new StartScreen())
+ * like.start();
+ * ```
+ *
+ * Alternatively, copy-paste this code into your own project and modify it freely.
+ * Update imports:
+ *
+ * ```ts
+ * import { type Scene } from 'like/scene';
+ * import type { ImageHandle } from 'like/graphics';
+ * import { Vec2 } from 'like/math';
+ * import { Like } from 'like';
+ * ```
+ *
+ * ## Custom Rendering
+ *
+ * Pass a custom draw function to replace the default logo:
+ *
+ * ```typescript
+ * const startup = new StartupScene(gameScene, (like) => {
+ *   like.gfx.clear([0, 0, 0, 1]);
+ *   like.gfx.print([1, 1, 1], 'Click to Start', [100, 100]);
+ * });
+ * ```
+ */
+export declare class StartScreen implements Scene {
+    private next;
+    private onDraw?;
+    private logo;
+    constructor(next: Scene, onDraw?: ((like: Like) => void) | undefined);
+    load(like: Like): void;
+    draw(like: Like): void;
+    mousepressed(like: Like): void;
+}
+//# sourceMappingURL=startScreen.d.ts.map

package/dist/prefab-scenes/startScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startScreen.d.ts","sourceRoot":"","sources":["../../src/prefab-scenes/startScreen.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAI1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,WAAY,YAAW,KAAK;IAIrC,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM,CAAC;IAJjB,OAAO,CAAC,IAAI,CAAe;gBAGjB,IAAI,EAAE,KAAK,EACX,MAAM,CAAC,GAAE,CAAC,IAAI,EAAE,IAAI,KAAK,IAAI,aAAA;IAGvC,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAWtB,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CAG/B"}

package/dist/{scenes/startup.js → prefab-scenes/startScreen.js}

@@ -1,13 +1,53 @@
-import { Vec2 } from '../core/vector2';
+import { Vec2 } from '../math/vector2';
 const LOGO = 'data:image/svg+xml;base64,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';
 /**
- * A simple startup scene that waits for a mouse click before advancing.
+ * ## Why
  *
- * This exists to work around browser autoplay restrictions - browsers require
- * user interaction (like a click) before allowing audio playback. Show this
- * scene first, then transition to your game scene on click.
+ *  1. Because the LIKE logo looks awesome.
+ *  2. Autoplay restriction, doesn't let you play audio until the page is clicked.
+ *  3. You have to click on the game in order to send inputs, anyway.
+ *  4. It's polite.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createLike, StartScreen } from 'like';
+ * import { GameScene } from './game';
+ *
+ * const container = document.getElementById("myGame");
+ * const like = createLike(container);
+ *
+ * // these callbacks will be ignored until the scene is clicked
+ * like.update = function () { ... }
+ * like.draw = function () { ... }
+ *
+ * // Set up the start screen
+ * like.setScene(new StartScreen())
+ * like.start();
+ * ```
+ *
+ * Alternatively, copy-paste this code into your own project and modify it freely.
+ * Update imports:
+ *
+ * ```ts
+ * import { type Scene } from 'like/scene';
+ * import type { ImageHandle } from 'like/graphics';
+ * import { Vec2 } from 'like/math';
+ * import { Like } from 'like';
+ * ```
+ *
+ * ## Custom Rendering
+ *
+ * Pass a custom draw function to replace the default logo:
+ *
+ * ```typescript
+ * const startup = new StartupScene(gameScene, (like) => {
+ *   like.gfx.clear([0, 0, 0, 1]);
+ *   like.gfx.print([1, 1, 1], 'Click to Start', [100, 100]);
+ * });
+ * ```
  */
-export class StartupScene {
+export class StartScreen {
     constructor(next, onDraw) {
         Object.defineProperty(this, "next", {
             enumerable: true,
@@ -37,12 +77,12 @@ export class StartupScene {
         }
         else if (this.logo.isReady()) {
             like.gfx.clear([0.05, 0.05, 0.08, 1]);
-            const winSize = like.gfx.getCanvasSize();
+            const winSize = like.canvas.getSize();
             const scale = (winSize[0] * 0.5) / this.logo.size[0];
             like.gfx.draw(this.logo, Vec2.div(winSize, 2), { scale, origin: Vec2.div(this.logo.size, 2) });
         }
     }
-    mousepressed(like, _pos, _button) {
+    mousepressed(like) {
         like.setScene(this.next);
     }
 }

package/dist/scene.d.ts

@@ -1,10 +1,108 @@
-import type { Like2DEvent, EventMap, EventType } from './core/events';
-import type { Like } from './core/like';
-type EventHandler<K extends EventType> = (like: Like, ...args: EventMap[K]) => void;
+/**
+ * @module scene
+ * @description A helpful callback / state management layer, plus utility scenes.
+ *
+ */
+import type { LikeEvent, EventMap } from './events';
+import type { Like } from './like';
+/**
+ * An interface for creating scenes.
+ *
+ * ## Why Scenes?
+ *
+ * For any game with more than one scene, we have to either:
+ *  - switch-case on game state in every single callback
+ *  - rebind all of the callbacks ourselves
+ *  - wrap handleEvent (hint: that's what this does)
+ *
+ * Also, some no need to pass around a `like` object.
+ * Here, `like` instead piggybacks on a closure that follows around
+ * your running scene and shows up as an additional first argument
+ * to every callback.
+ *
+ * ## Quick Start
+ *
+ * Have a scene handle all the callbacks, disabling global
+ * callbacks.
+ * ```typescript
+ * // set up a scene
+ * class MagicalGrowingRectangle extends Scene {
+ *   rectangleSize = 10;
+ *   constructor() {}
+ *
+ *   keypressed(_like: Like) {
+ *     this.rectangleSize += 10;
+ *   }
+ *
+ *   draw(like: Like) {
+ *     like.gfx.rectangle('fill', 'green',
+ *       [10, 10, this.rectangleSize, this.rectangleSize])
+ *   }
+ * }
+ *
+ * like.setScene(new MagicalGrowingRectangle());
+ * ```
+ *
+ * To get back to global callbacks, just use `like.handleEvent = undefined`
+ *
+ * ## Scene Lifecycle
+ *
+ * Works a lot like global callbacks.
+ *
+ * 1. `like.setScene(scene)` is called
+ * 2. Scene's `load` callback fires immediately
+ * 3. `update` and `draw` begin on next frame
+ * 4. Scene receives input events as they occur
+ *
+ * ## Composing scenes
+ *
+ * Thought you'd never ask.
+ * Just like the `like` object, scenes have handleEvent on them.
+ * So, you could layer them like this, for example:
+ *
+ * ```typescript
+ * class UI implements Scene {
+ *   constructor(public game: Game) {}
+ *
+ *   handleEvent(like: Like, event: Like2DEvent) {
+ *     // Block mouse events in order to create a top bar.
+ *     const mouseY = like.mouse.getPosition()[1];
+ *     if (!event.type.startsWith('mouse') || mouseY > 100) {
+ *       sceneDispatch(this.game, like, event);
+ *     }
+ *
+ *     // Then, call my own callbacks.
+ *     // By calling it here, the UI draws on top.
+ *     callSceneHandlers(this, like, event);
+ *   }
+ *   ...
+ * }
+ *
+ * class Game implements Scene {
+ *   ...
+ * }
+ *
+ * like.setScene(new UI(new Game()))
+ * ```
+ *
+ * Composing scenes lets you filter events, layer game elements,
+ * and more. Don't sleep on it.
+ */
 export type Scene = {
-    [K in EventType]?: EventHandler<K>;
+    [K in keyof EventMap]?: (like: Like, ...args: EventMap[K]) => void;
 } & {
-    handleEvent?(like: Like, event: Like2DEvent): void;
+    handleEvent?(like: Like, event: LikeEvent): void;
 };
-export {};
+/**
+ * Used to call a scene's own handlers like `update` or `draw`,
+ * typically at the end of handleEvent
+ * after modifying the event stream or composing sub-scenes.
+ */
+export declare const callSceneHandlers: (scene: Scene, like: Like, event: LikeEvent) => void;
+/**
+ * Used to call sub scenes while respecting potential `handleEvent` within them.
+ * The main scene is similar to a sub-scene of the root (like) object in this
+ * regard.
+ */
+export declare const sceneDispatch: (scene: Scene, like: Like, event: LikeEvent) => void;
 //# sourceMappingURL=scene.d.ts.map

package/dist/scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAExC,KAAK,YAAY,CAAC,CAAC,SAAS,SAAS,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAEpF,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,SAAS,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC;CACnC,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;CACpD,CAAC"}
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../src/scene.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFG;AAEH,MAAM,MAAM,KAAK,GAAG;KACjB,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,IAAI;CACnE,GAAG;IACF,WAAW,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,CAAC;CAClD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAI3E,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,KAAK,EAAE,MAAM,IAAI,EAAE,OAAO,SAAS,SAMvE,CAAA"}

package/dist/scene.js

@@ -1 +1,28 @@
-export {};
+/**
+ * @module scene
+ * @description A helpful callback / state management layer, plus utility scenes.
+ *
+ */
+/**
+ * Used to call a scene's own handlers like `update` or `draw`,
+ * typically at the end of handleEvent
+ * after modifying the event stream or composing sub-scenes.
+ */
+export const callSceneHandlers = (scene, like, event) => {
+    if (event.type in scene) {
+        scene[event.type](like, ...event.args);
+    }
+};
+/**
+ * Used to call sub scenes while respecting potential `handleEvent` within them.
+ * The main scene is similar to a sub-scene of the root (like) object in this
+ * regard.
+ */
+export const sceneDispatch = (scene, like, event) => {
+    if (scene.handleEvent) {
+        scene.handleEvent(like, event);
+    }
+    else {
+        callSceneHandlers(scene, like, event);
+    }
+};

package/dist/timer/index.d.ts

@@ -0,0 +1,2 @@
+export { type Timer } from "./timer";
+//# sourceMappingURL=index.d.ts.map

package/dist/timer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/timer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC"}

package/dist/timer/timer.d.ts

@@ -0,0 +1,32 @@
+import { EngineProps } from "../engine";
+export declare class Timer {
+    private currentDelta;
+    private totalTime;
+    private frameCount;
+    private fps;
+    private fpsAccumulator;
+    private sleepUntil;
+    constructor(props: EngineProps<never>);
+    private update;
+    /** Get `dt` (from the update loop) anywhere.
+     * AKA the time since the last frame.
+     */
+    getDelta(): number;
+    /** Get an estimated FPS based on one-second average. */
+    getFPS(): number;
+    /** Get the ingame time. */
+    getTime(): number;
+    /**
+     * Whether or not the game is (supposed to be) frozen.
+     * The only callback while sleeping is `draw`, and
+     * calling this outside of `draw` will always return
+     * false -- except if you have a custom runtime.
+     */
+    isSleeping(): boolean;
+    /**
+     * Freeze the whole game for a time. Audio will keep playing,
+     * but update functions won't be called and events won't fire.
+     */
+    sleep(duration: number): void;
+}
+//# sourceMappingURL=timer.d.ts.map

package/dist/timer/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/timer/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,qBAAa,KAAK;IAChB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,UAAU,CAAuB;gBAE7B,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC;IAIrC,OAAO,CAAC,MAAM;IAcd;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB,wDAAwD;IACxD,MAAM,IAAI,MAAM;IAIhB,2BAA2B;IAC3B,OAAO,IAAI,MAAM;IAIjB;;;;;OAKG;IACH,UAAU,IAAI,OAAO;IAUrB;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAG9B"}

package/dist/{core → timer}/timer.js

@@ -1,5 +1,5 @@
 export class Timer {
-    constructor() {
+    constructor(props) {
         Object.defineProperty(this, "currentDelta", {
             enumerable: true,
             configurable: true,
@@ -36,14 +36,10 @@ export class Timer {
             writable: true,
             value: null
         });
-        Object.defineProperty(this, "sceneStartTime", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
+        props.canvas.addEventListener("like:update", this.update.bind(this), { signal: props.abort });
     }
-    update(dt) {
+    update(ev) {
+        const { dt } = ev.detail;
         this.currentDelta = dt;
         this.totalTime += dt;
         this.frameCount++;
@@ -54,21 +50,26 @@ export class Timer {
             this.fpsAccumulator = 0;
         }
     }
-    resetSceneTime() {
-        this.sceneStartTime = this.totalTime;
-    }
+    /** Get `dt` (from the update loop) anywhere.
+     * AKA the time since the last frame.
+     */
     getDelta() {
         return this.currentDelta;
     }
+    /** Get an estimated FPS based on one-second average. */
     getFPS() {
         return this.fps;
     }
+    /** Get the ingame time. */
     getTime() {
         return this.totalTime;
     }
-    getSceneTime() {
-        return this.totalTime - this.sceneStartTime;
-    }
+    /**
+     * Whether or not the game is (supposed to be) frozen.
+     * The only callback while sleeping is `draw`, and
+     * calling this outside of `draw` will always return
+     * false -- except if you have a custom runtime.
+     */
     isSleeping() {
         if (this.sleepUntil === null)
             return false;
@@ -79,6 +80,10 @@ export class Timer {
         this.sleepUntil = null;
         return false;
     }
+    /**
+     * Freeze the whole game for a time. Audio will keep playing,
+     * but update functions won't be called and events won't fire.
+     */
     sleep(duration) {
         this.sleepUntil = performance.now() + (duration * 1000);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "like2d",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "A web-native game framework inspired by Love2D",
   "type": "module",
   "main": "./dist/index.js",
@@ -10,6 +10,30 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
+    },
+    "./math": {
+      "import": "./dist/math/index.js",
+      "types": "./dist/math/index.d.ts"
+    },
+    "./prefab-scenes": {
+      "import": "./dist/prefab-scenes/index.js",
+      "types": "./dist/prefab-scenes/index.d.ts"
+    },
+    "./graphics": {
+      "import": "./dist/graphics/index.js",
+      "types": "./dist/graphics/index.d.ts"
+    },
+    "./audio": {
+      "import": "./dist/audio/index.js",
+      "types": "./dist/audio/index.d.ts"
+    },
+    "./input": {
+      "import": "./dist/input/index.js",
+      "types": "./dist/input/index.d.ts"
+    },
+    "./timer": {
+      "import": "./dist/timer/index.js",
+      "types": "./dist/timer/index.d.ts"
     }
   },
   "files": [
@@ -23,7 +47,8 @@
     "typecheck": "tsc --noEmit",
     "lint": "echo 'No linting configured'",
     "clean": "rm -rf dist",
-    "test": "vitest run"
+    "test": "vitest run",
+    "bench": "vitest bench"
   },
   "keywords": [
     "game",

package/dist/core/audio.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"audio.d.ts","sourceRoot":"","sources":["../../src/core/audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAA;AAMD;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6IAA6I;IAC7I,QAAQ,CAAC,KAAK,EAAE,gBAAgB,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,aAAa,CAAC,CAAC;IAC1C,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAO,CAAC,SAAS,CAAoE;IACrF,OAAO,CAAC,QAAQ,CAAQ;gBAEZ,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAE,aAAkB;IAmCtE,OAAO,IAAI,OAAO;IAIlB,IAAI,IAAI,IAAI;IAUZ,IAAI,IAAI,IAAI;IAUZ,KAAK,IAAI,IAAI;IAQb,MAAM,IAAI,IAAI;IAYd,IAAI,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQ5B,IAAI,IAAI,MAAM;IAKd,SAAS,IAAI,OAAO;IAKpB,QAAQ,IAAI,OAAO;IAKnB,SAAS,IAAI,OAAO;IAKpB,+FAA+F;IAC/F,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;CAItB;AAED,qBAAa,KAAK;IAChB,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,YAAY,CAAK;IAEzB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,MAAM;IAMxD;;;QAGI;IACJ,OAAO,CAAC,aAAa;IASrB,OAAO,IAAI,IAAI;IAIf,QAAQ,IAAI,IAAI;IAIhB,SAAS,IAAI,IAAI;IAIjB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO/B,SAAS,IAAI,MAAM;IAInB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAG9B"}

package/dist/core/canvas-config.d.ts

@@ -1,22 +0,0 @@
-import type { Vector2 } from './vector2';
-export type CanvasMode = {
-    pixelResolution: Vector2 | null;
-    fullscreen: boolean;
-};
-export type PartialCanvasMode = {
-    pixelResolution?: Vector2 | null;
-    fullscreen?: boolean;
-};
-/**
- * Calculate the scale and offset for rendering fixed-size content to a target canvas.
- * This is useful when you want to render in "native" mode but maintain a fixed game resolution.
- *
- * @param canvasSize - The actual canvas size in pixels
- * @param gameSize - The desired game resolution (fixed size)
- * @returns Object containing the scale factor and offset for centering
- */
-export declare function calcFixedScale(canvasSize: Vector2, gameSize: Vector2): {
-    scale: number;
-    offset: Vector2;
-};
-//# sourceMappingURL=canvas-config.d.ts.map

package/dist/core/canvas-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"canvas-config.d.ts","sourceRoot":"","sources":["../../src/core/canvas-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,UAAU,GAAG;IACvB,eAAe,EAAE,OAAO,GAAG,IAAI,CAAC;IAChC,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,eAAe,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAKzG"}