minimojs 1.0.0-alpha.1 → 1.0.0-alpha.2

package/dist/minimo.js

@@ -386,12 +386,19 @@ export class Game {
         /** @internal */ this._pointerPressed = false;
         /** @internal */ this._pointerX = 0;
         /** @internal */ this._pointerY = 0;
+        /** @internal */ this._mouseDown = false;
+        /** @internal */ this._mousePressed = false;
+        /** @internal */ this._mouseX = 0;
+        /** @internal */ this._mouseY = 0;
+        /** @internal */ this._touchPointers = new Map();
+        /** @internal */ this._primaryTouchId = null;
         /** @internal */ this._rafId = null;
         /** @internal */ this._lastTimestamp = null;
         /** @internal */ this._running = false;
         /** @internal */ this._hasCreated = false;
         /** @internal */ this._onResize = () => this._applyResponsiveCanvasLayout();
         /** @internal */ this._audioCtx = null;
+        /** @internal */ this._spriteGlyphCache = new Map();
         /** @internal */ this._lastAppliedPageBackground = undefined;
         // -------------------------------------------------------------------------
         // Public state
@@ -791,6 +798,136 @@ export class Game {
     isPointerPressed() {
         return this._pointerPressed;
     }
+    /**
+     * Returns `true` while any active pointer is held down over the target sprite.
+     * Works with both mouse input and multiple simultaneous touches.
+     *
+     * Pointer hit testing uses a circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * Use this for continuous virtual buttons such as touch movement controls.
+     *
+     * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
+     * @param radiusScale - Multiplier applied to `sprite.size` to define the hit radius.
+     *   Default: `0.5`.
+     * @returns `true` if any currently held pointer overlaps the sprite hit area.
+     *
+     * @example
+     * ```ts
+     * if (game.isPointerDownOverSprite(leftButton, 0.72)) {
+     *   player.x -= 200 * dt;
+     * }
+     * ```
+     */
+    isPointerDownOverSprite(sprite, radiusScale = 0.5) {
+        if (!sprite)
+            return false;
+        if (this._mouseDown &&
+            this._isScreenPointOverSprite(this._mouseX, this._mouseY, sprite, radiusScale)) {
+            return true;
+        }
+        for (const pointer of this._touchPointers.values()) {
+            if (this._isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns `true` only on the frame any pointer first pressed over the target
+     * sprite. Works with both mouse input and multiple simultaneous touches.
+     *
+     * Pointer hit testing uses a circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * Use this for one-shot virtual buttons such as menu taps.
+     *
+     * @param sprite - Target sprite to test. If `null` / `undefined`, returns `false`.
+     * @param radiusScale - Multiplier applied to `sprite.size` to define the hit radius.
+     *   Default: `0.5`.
+     * @returns `true` if any pointer began pressing this frame over the sprite hit area.
+     *
+     * @example
+     * ```ts
+     * if (game.isPointerPressedOverSprite(startButton, 0.8)) {
+     *   startGame();
+     * }
+     * ```
+     */
+    isPointerPressedOverSprite(sprite, radiusScale = 0.5) {
+        if (!sprite)
+            return false;
+        if (this._mousePressed &&
+            this._isScreenPointOverSprite(this._mouseX, this._mouseY, sprite, radiusScale)) {
+            return true;
+        }
+        for (const pointer of this._touchPointers.values()) {
+            if (pointer.pressed &&
+                this._isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns a read-only snapshot of all currently active pointers.
+     *
+     * Mouse appears in the list only while the mouse button is held down. Touches
+     * appear while they remain active on the canvas. Coordinates are returned in
+     * canvas/screen space.
+     *
+     * Use this for advanced multitouch controls such as joysticks, drag handles,
+     * or gesture-like gameplay logic.
+     *
+     * @returns A read-only array of active pointer snapshots.
+     *
+     * @example
+     * ```ts
+     * const pointers = game.getPointers();
+     * if (pointers.length > 0) {
+     *   const first = pointers[0];
+     *   game.text(`Pointer: ${first.x}, ${first.y}`, 10, 10);
+     * }
+     * ```
+     */
+    getPointers() {
+        return this._collectPointers();
+    }
+    /**
+     * Returns a read-only snapshot of all active pointers currently overlapping
+     * the target sprite.
+     *
+     * Pointer hit testing uses a circular area centered on the sprite. The radius
+     * is `sprite.size * radiusScale`. World-space sprites are tested against the
+     * current camera scroll. HUD sprites with `ignoreScroll = true` are tested in
+     * screen space.
+     *
+     * Use this when you need more than a boolean result, such as reading the exact
+     * pointer position over a virtual joystick or draggable control.
+     *
+     * @param sprite - Target sprite to test. If `null` / `undefined`, returns an empty array.
+     * @param radiusScale - Multiplier applied to `sprite.size` to define the hit radius.
+     *   Default: `0.5`.
+     * @returns A read-only array of active pointer snapshots currently over the sprite.
+     *
+     * @example
+     * ```ts
+     * const touches = game.getPointersOverSprite(joystickBase, 1.0);
+     * if (touches.length > 0) {
+     *   const p = touches[0];
+     *   const dx = p.x - joystickBase.x;
+     * }
+     * ```
+     */
+    getPointersOverSprite(sprite, radiusScale = 0.5) {
+        if (!sprite)
+            return [];
+        return this._collectPointers().filter((pointer) => this._isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale));
+    }
     /**
      * Returns `true` when the current device appears to be mobile/touch-first.
      *
@@ -1095,7 +1232,11 @@ export class Game {
         this._animations = [];
         this._textOverlays = [];
         this._keysPressed.clear();
-        this._pointerPressed = false;
+        this._mousePressed = false;
+        for (const pointer of this._touchPointers.values()) {
+            pointer.pressed = false;
+        }
+        this._syncPrimaryPointer();
         this.scrollX = 0;
         this.scrollY = 0;
         this._invokeCreate();
@@ -1161,58 +1302,152 @@ export class Game {
         window.addEventListener("keyup", (e) => {
             this._keysDown.delete(e.key);
         });
-        const getCanvasPoint = (e) => {
+        const getCanvasPoint = (clientX, clientY) => {
             const rect = this._canvas.getBoundingClientRect();
             const scaleX = this._canvas.width / rect.width;
             const scaleY = this._canvas.height / rect.height;
-            let clientX;
-            let clientY;
-            if (e instanceof MouseEvent) {
-                clientX = e.clientX;
-                clientY = e.clientY;
-            }
-            else {
-                clientX = e.touches[0]?.clientX ?? this._pointerX;
-                clientY = e.touches[0]?.clientY ?? this._pointerY;
-            }
             return {
                 x: (clientX - rect.left) * scaleX,
                 y: (clientY - rect.top) * scaleY,
             };
         };
         this._canvas.addEventListener("mousedown", (e) => {
-            const p = getCanvasPoint(e);
-            this._pointerX = p.x;
-            this._pointerY = p.y;
-            this._pointerDown = true;
-            this._pointerPressed = true;
+            const p = getCanvasPoint(e.clientX, e.clientY);
+            this._mouseX = p.x;
+            this._mouseY = p.y;
+            this._mouseDown = true;
+            this._mousePressed = true;
+            this._syncPrimaryPointer();
         });
         this._canvas.addEventListener("mouseup", () => {
-            this._pointerDown = false;
+            this._mouseDown = false;
+            this._syncPrimaryPointer();
         });
         this._canvas.addEventListener("mousemove", (e) => {
-            const p = getCanvasPoint(e);
-            this._pointerX = p.x;
-            this._pointerY = p.y;
+            const p = getCanvasPoint(e.clientX, e.clientY);
+            this._mouseX = p.x;
+            this._mouseY = p.y;
+            this._syncPrimaryPointer();
         });
         this._canvas.addEventListener("touchstart", (e) => {
-            const p = getCanvasPoint(e);
-            this._pointerX = p.x;
-            this._pointerY = p.y;
-            this._pointerDown = true;
-            this._pointerPressed = true;
+            for (const touch of Array.from(e.changedTouches)) {
+                const p = getCanvasPoint(touch.clientX, touch.clientY);
+                this._touchPointers.set(touch.identifier, {
+                    x: p.x,
+                    y: p.y,
+                    pressed: true,
+                });
+                if (this._primaryTouchId === null) {
+                    this._primaryTouchId = touch.identifier;
+                }
+            }
+            this._syncPrimaryPointer();
+            e.preventDefault();
+        }, { passive: false });
+        this._canvas.addEventListener("touchend", (e) => {
+            for (const touch of Array.from(e.changedTouches)) {
+                this._touchPointers.delete(touch.identifier);
+                if (this._primaryTouchId === touch.identifier) {
+                    this._primaryTouchId = null;
+                }
+            }
+            this._syncPrimaryPointer();
+            e.preventDefault();
+        }, { passive: false });
+        this._canvas.addEventListener("touchcancel", (e) => {
+            for (const touch of Array.from(e.changedTouches)) {
+                this._touchPointers.delete(touch.identifier);
+                if (this._primaryTouchId === touch.identifier) {
+                    this._primaryTouchId = null;
+                }
+            }
+            this._syncPrimaryPointer();
             e.preventDefault();
         }, { passive: false });
-        this._canvas.addEventListener("touchend", () => {
-            this._pointerDown = false;
-        });
         this._canvas.addEventListener("touchmove", (e) => {
-            const p = getCanvasPoint(e);
-            this._pointerX = p.x;
-            this._pointerY = p.y;
+            for (const touch of Array.from(e.changedTouches)) {
+                const p = getCanvasPoint(touch.clientX, touch.clientY);
+                const existing = this._touchPointers.get(touch.identifier);
+                if (existing) {
+                    existing.x = p.x;
+                    existing.y = p.y;
+                }
+                else {
+                    this._touchPointers.set(touch.identifier, {
+                        x: p.x,
+                        y: p.y,
+                        pressed: false,
+                    });
+                }
+            }
+            this._syncPrimaryPointer();
             e.preventDefault();
         }, { passive: false });
     }
+    /** @internal */
+    _isScreenPointOverSprite(x, y, sprite, radiusScale) {
+        const safeScale = Math.max(0, radiusScale);
+        const radius = sprite.size * safeScale;
+        const drawX = sprite.ignoreScroll ? sprite.x : sprite.x - this.scrollX;
+        const drawY = sprite.ignoreScroll ? sprite.y : sprite.y - this.scrollY;
+        const dx = x - drawX;
+        const dy = y - drawY;
+        return dx * dx + dy * dy <= radius * radius;
+    }
+    /** @internal */
+    _collectPointers() {
+        const pointers = [];
+        if (this._mouseDown) {
+            pointers.push({
+                id: "mouse",
+                kind: "mouse",
+                x: this._mouseX,
+                y: this._mouseY,
+                pressed: this._mousePressed,
+            });
+        }
+        for (const [id, pointer] of this._touchPointers.entries()) {
+            pointers.push({
+                id,
+                kind: "touch",
+                x: pointer.x,
+                y: pointer.y,
+                pressed: pointer.pressed,
+            });
+        }
+        return pointers;
+    }
+    /** @internal */
+    _syncPrimaryPointer() {
+        if (this._primaryTouchId !== null) {
+            const primaryTouch = this._touchPointers.get(this._primaryTouchId);
+            if (primaryTouch) {
+                this._pointerX = primaryTouch.x;
+                this._pointerY = primaryTouch.y;
+                this._pointerDown = true;
+                this._pointerPressed = primaryTouch.pressed;
+                return;
+            }
+            this._primaryTouchId = null;
+        }
+        if (this._touchPointers.size > 0) {
+            const firstTouchEntry = this._touchPointers.entries().next().value;
+            if (firstTouchEntry) {
+                const [touchId, touch] = firstTouchEntry;
+                this._primaryTouchId = touchId;
+                this._pointerX = touch.x;
+                this._pointerY = touch.y;
+                this._pointerDown = true;
+                this._pointerPressed = touch.pressed;
+                return;
+            }
+        }
+        this._primaryTouchId = null;
+        this._pointerX = this._mouseX;
+        this._pointerY = this._mouseY;
+        this._pointerDown = this._mouseDown;
+        this._pointerPressed = this._mousePressed;
+    }
     // -------------------------------------------------------------------------
     // Private — rAF loop
     // -------------------------------------------------------------------------
@@ -1235,7 +1470,11 @@ export class Game {
             this.onUpdate(dt);
         this._render();
         this._keysPressed.clear();
-        this._pointerPressed = false;
+        this._mousePressed = false;
+        for (const pointer of this._touchPointers.values()) {
+            pointer.pressed = false;
+        }
+        this._syncPrimaryPointer();
         this._textOverlays = [];
         this._rafId = requestAnimationFrame(this._loop.bind(this));
     }
@@ -1294,6 +1533,34 @@ export class Game {
     // Private — rendering
     // -------------------------------------------------------------------------
     /** @internal */
+    _getSpriteGlyphCanvas(sprite) {
+        const size = Math.max(1, Math.round(sprite.size));
+        const cacheKey = `${sprite.sprite}::${size}`;
+        const cached = this._spriteGlyphCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const glyphCanvas = document.createElement("canvas");
+        const boxSize = Math.max(2, Math.ceil(size * 2));
+        glyphCanvas.width = boxSize;
+        glyphCanvas.height = boxSize;
+        const glyphCtx = glyphCanvas.getContext("2d");
+        if (!glyphCtx) {
+            throw new Error("MinimoJS: Could not acquire a glyph rendering context.");
+        }
+        glyphCtx.clearRect(0, 0, boxSize, boxSize);
+        glyphCtx.shadowColor = "transparent";
+        glyphCtx.shadowBlur = 0;
+        glyphCtx.shadowOffsetX = 0;
+        glyphCtx.shadowOffsetY = 0;
+        glyphCtx.fillStyle = "#ffffff";
+        glyphCtx.font = `${size}px "Apple Color Emoji", "Segoe UI Emoji", "Noto Color Emoji", sans-serif`;
+        glyphCtx.textAlign = "center";
+        glyphCtx.textBaseline = "middle";
+        glyphCtx.fillText(sprite.sprite, boxSize / 2, boxSize / 2);
+        this._spriteGlyphCache.set(cacheKey, glyphCanvas);
+        return glyphCanvas;
+    }
+    /** @internal */
     _render() {
         const ctx = this._ctx;
         const W = this._canvas.width;
@@ -1317,8 +1584,8 @@ export class Game {
                 continue;
             ctx.save();
             ctx.globalAlpha = Math.max(0, Math.min(1, sprite.alpha));
-            const drawX = sprite.ignoreScroll ? sprite.x : sprite.x - this.scrollX;
-            const drawY = sprite.ignoreScroll ? sprite.y : sprite.y - this.scrollY;
+            const drawX = Math.round(sprite.ignoreScroll ? sprite.x : sprite.x - this.scrollX);
+            const drawY = Math.round(sprite.ignoreScroll ? sprite.y : sprite.y - this.scrollY);
             ctx.translate(drawX, drawY);
             if (sprite.rotation !== 0) {
                 ctx.rotate((sprite.rotation * Math.PI) / 180);
@@ -1326,10 +1593,12 @@ export class Game {
             if (sprite.flipX || sprite.flipY) {
                 ctx.scale(sprite.flipX ? -1 : 1, sprite.flipY ? -1 : 1);
             }
-            ctx.font = `${sprite.size}px serif`;
-            ctx.textAlign = "center";
-            ctx.textBaseline = "middle";
-            ctx.fillText(sprite.sprite, 0, 0);
+            ctx.shadowColor = "transparent";
+            ctx.shadowBlur = 0;
+            ctx.shadowOffsetX = 0;
+            ctx.shadowOffsetY = 0;
+            const glyphCanvas = this._getSpriteGlyphCanvas(sprite);
+            ctx.drawImage(glyphCanvas, -glyphCanvas.width / 2, -glyphCanvas.height / 2);
             ctx.restore();
         }
         for (const entry of this._textOverlays) {

package/dist/physics.js

@@ -0,0 +1,10 @@
+export function updatePhysics(sprites, gravityX, gravityY, dt) {
+    for (const sprite of sprites) {
+        if (sprite.gravityScale !== 0) {
+            sprite.vx += gravityX * sprite.gravityScale * dt;
+            sprite.vy += gravityY * sprite.gravityScale * dt;
+        }
+        sprite.x += sprite.vx * dt;
+        sprite.y += sprite.vy * dt;
+    }
+}

package/dist/pointer-info.js

@@ -0,0 +1 @@
+export {};

package/dist/render.js

@@ -0,0 +1,75 @@
+export function renderFrame(options) {
+    const { ctx, canvas, sprites, textOverlays, background, backgroundGradient, scrollX, scrollY, } = options;
+    const width = canvas.width;
+    const height = canvas.height;
+    ctx.clearRect(0, 0, width, height);
+    if (backgroundGradient !== null) {
+        const gradient = ctx.createLinearGradient(0, 0, 0, height);
+        gradient.addColorStop(0, backgroundGradient.from);
+        gradient.addColorStop(1, backgroundGradient.to);
+        ctx.fillStyle = gradient;
+        ctx.fillRect(0, 0, width, height);
+    }
+    else if (background !== null) {
+        ctx.fillStyle = background;
+        ctx.fillRect(0, 0, width, height);
+    }
+    const sortedSprites = [...sprites].sort((a, b) => a.layer - b.layer);
+    for (const sprite of sortedSprites) {
+        if (!sprite.visible)
+            continue;
+        ctx.save();
+        ctx.globalAlpha = Math.max(0, Math.min(1, sprite.alpha));
+        const drawX = sprite.ignoreScroll ? sprite.x : sprite.x - scrollX;
+        const drawY = sprite.ignoreScroll ? sprite.y : sprite.y - scrollY;
+        ctx.translate(drawX, drawY);
+        if (sprite.rotation !== 0) {
+            ctx.rotate((sprite.rotation * Math.PI) / 180);
+        }
+        if (sprite.flipX || sprite.flipY) {
+            ctx.scale(sprite.flipX ? -1 : 1, sprite.flipY ? -1 : 1);
+        }
+        ctx.font = `${sprite.size}px serif`;
+        ctx.textAlign = "center";
+        ctx.textBaseline = "middle";
+        ctx.fillText(sprite.sprite, 0, 0);
+        ctx.restore();
+    }
+    for (const entry of textOverlays) {
+        ctx.save();
+        ctx.font = `${entry.fontSize}px monospace`;
+        ctx.fillStyle = entry.color;
+        ctx.textAlign = entry.centered ? "center" : "left";
+        ctx.textBaseline = entry.centered ? "middle" : "top";
+        ctx.fillText(entry.text, entry.x, entry.y);
+        ctx.restore();
+    }
+}
+export function applyPageBackground(pageBackground, lastAppliedPageBackground) {
+    if (!document.body)
+        return lastAppliedPageBackground;
+    if (lastAppliedPageBackground === pageBackground)
+        return lastAppliedPageBackground;
+    if (pageBackground === null) {
+        document.body.style.removeProperty("background");
+    }
+    else {
+        document.body.style.background = pageBackground;
+    }
+    return pageBackground;
+}
+export function applyResponsiveCanvasLayout(canvas) {
+    if (!document.body)
+        return;
+    document.body.style.margin = "0";
+    document.body.style.minHeight = "100vh";
+    document.body.style.display = "grid";
+    document.body.style.placeItems = "center";
+    document.body.style.touchAction = "manipulation";
+    const viewportWidth = Math.max(1, window.innerWidth);
+    const viewportHeight = Math.max(1, window.innerHeight);
+    const scale = Math.min(viewportWidth / canvas.width, viewportHeight / canvas.height);
+    const safeScale = Number.isFinite(scale) && scale > 0 ? scale : 1;
+    canvas.style.width = `${Math.floor(canvas.width * safeScale)}px`;
+    canvas.style.height = `${Math.floor(canvas.height * safeScale)}px`;
+}

package/dist/sprite.js

@@ -0,0 +1,149 @@
+// ---------------------------------------------------------------------------
+// Sprite
+// ---------------------------------------------------------------------------
+/**
+ * A 2D game object rendered as an emoji on the canvas.
+ *
+ * Instantiate directly or extend to create custom sprite types.
+ * Register with the engine by passing the instance to {@link Game.add}.
+ *
+ * **Coordinate system:** center-based world space. `(x, y)` is the center of
+ * the sprite. Positive X = right, positive Y = down.
+ *
+ * **Lifecycle:** A sprite exists until {@link Game.destroySprite} is called or
+ * {@link Game.reset} is invoked. After destruction, do not read or write its fields.
+ *
+ * @example
+ * ```ts
+ * // Direct instantiation
+ * const coin = new Sprite("🪙");
+ * coin.x = 300;
+ * coin.y = 200;
+ * coin.size = 32;
+ * game.add(coin);
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Subclassing for custom game objects
+ * class Player extends Sprite {
+ *   health = 3;
+ *
+ *   constructor(x: number, y: number) {
+ *     super("🐢");
+ *     this.x = x;
+ *     this.y = y;
+ *     this.size = 48;
+ *     this.gravityScale = 1;
+ *   }
+ * }
+ *
+ * const player = new Player(400, 300);
+ * game.add(player);
+ * ```
+ */
+export class Sprite {
+    /**
+     * Creates a new Sprite with the given emoji and optional position.
+     * All other properties use their defaults and can be set after construction.
+     *
+     * @param sprite - The emoji character to render. Must be a single emoji.
+     *   Image sprites are NOT supported — emoji only.
+     *   @example "🔥", "⭐", "🐢", "💣", "👾"
+     * @param x - Initial X position in world space (center), in pixels. Default: `0`.
+     * @param y - Initial Y position in world space (center), in pixels. Default: `0`.
+     *
+     * @example
+     * ```ts
+     * const enemy = new Sprite("👾", 200, 100);
+     * enemy.size = 40;
+     * game.add(enemy);
+     * ```
+     */
+    constructor(sprite, x = 0, y = 0) {
+        /**
+         * X position in world space (horizontal center of the sprite), in pixels.
+         * Positive X points right. Updated each frame by: `x += vx * dt`.
+         * May be set directly to teleport the sprite.
+         */
+        this.x = 0;
+        /**
+         * Y position in world space (vertical center of the sprite), in pixels.
+         * Positive Y points down. Updated each frame by: `y += vy * dt`.
+         * May be set directly to teleport the sprite.
+         */
+        this.y = 0;
+        /**
+         * Width and height of the sprite's bounding square, in pixels.
+         * Used for both canvas rendering (font size) and AABB collision detection.
+         */
+        this.size = 32;
+        /**
+         * Visual rotation of the sprite in degrees.
+         * `0` = upright. Positive values rotate clockwise.
+         * **Note:** rotation does NOT affect the AABB collision box — it remains axis-aligned.
+         */
+        this.rotation = 0;
+        /**
+         * Horizontal visual flip.
+         * When `true`, the sprite is mirrored left-right during rendering.
+         * This is visual-only and does NOT affect collision detection.
+         */
+        this.flipX = false;
+        /**
+         * Vertical visual flip.
+         * When `true`, the sprite is mirrored top-bottom during rendering.
+         * This is visual-only and does NOT affect collision detection.
+         */
+        this.flipY = false;
+        /**
+         * Camera scroll toggle for this sprite.
+         * When `false` (default), the sprite is rendered in world space and is affected
+         * by {@link Game.scrollX} and {@link Game.scrollY}.
+         * When `true`, the sprite is rendered in canvas/screen space and ignores camera
+         * scrolling. Useful for HUD-like sprites that should stay fixed on screen.
+         */
+        this.ignoreScroll = false;
+        /**
+         * Opacity of the sprite. Must be in range `[0, 1]`.
+         * `0` = fully transparent, `1` = fully opaque.
+         * Clamped to `[0, 1]` at render time.
+         */
+        this.alpha = 1;
+        /**
+         * Controls whether this sprite is drawn each frame.
+         * When `false`, the sprite still receives physics updates (gravity, velocity)
+         * but is not rendered. Use {@link Game.destroySprite} to fully remove a sprite.
+         */
+        this.visible = true;
+        /**
+         * Render layer order. Sprites with higher `layer` values are drawn on top.
+         * Sprites on the same layer render in creation order (first created = bottom).
+         * Changing this at runtime takes effect on the next frame.
+         */
+        this.layer = 0;
+        /**
+         * Horizontal velocity in pixels per second.
+         * Applied each frame: `x += vx * dt`.
+         * Gravity also modifies this: `vx += gravityX * gravityScale * dt`.
+         */
+        this.vx = 0;
+        /**
+         * Vertical velocity in pixels per second.
+         * Applied each frame: `y += vy * dt`.
+         * Gravity also modifies this: `vy += gravityY * gravityScale * dt`.
+         */
+        this.vy = 0;
+        /**
+         * Gravity multiplier for this sprite.
+         * Each frame: `vx += game.gravityX * gravityScale * dt`
+         *             `vy += game.gravityY * gravityScale * dt`.
+         * `0` = immune to gravity (default). `1` = full gravity.
+         * Values > 1 amplify gravity; negative values invert it.
+         */
+        this.gravityScale = 0;
+        this.sprite = sprite;
+        this.x = x;
+        this.y = y;
+    }
+}

package/dist/timers.js

@@ -0,0 +1,23 @@
+export function updateTimers(timers, dtMs) {
+    const toRemove = new Set();
+    const toFire = [];
+    for (const timer of timers) {
+        timer.elapsed += dtMs;
+        if (timer.elapsed >= timer.delayMs) {
+            toFire.push(timer);
+            if (timer.repeat) {
+                timer.elapsed -= timer.delayMs;
+            }
+            else {
+                toRemove.add(timer.id);
+            }
+        }
+    }
+    const nextTimers = toRemove.size > 0
+        ? timers.filter((timer) => !toRemove.has(timer.id))
+        : timers;
+    for (const timer of toFire) {
+        timer.callback();
+    }
+    return nextTimers;
+}