minimojs 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/input.js

@@ -1,185 +0,0 @@
-export function createInputState() {
-    return {
-        keysDown: new Set(),
-        keysPressed: new Set(),
-        pointerDown: false,
-        pointerPressed: false,
-        pointerX: 0,
-        pointerY: 0,
-        mouseDown: false,
-        mousePressed: false,
-        mouseX: 0,
-        mouseY: 0,
-        touchPointers: new Map(),
-        primaryTouchId: null,
-    };
-}
-export function bindInputEvents(canvas, input) {
-    window.addEventListener("keydown", (e) => {
-        if (!input.keysDown.has(e.key)) {
-            input.keysPressed.add(e.key);
-        }
-        input.keysDown.add(e.key);
-    });
-    window.addEventListener("keyup", (e) => {
-        input.keysDown.delete(e.key);
-    });
-    const getCanvasPoint = (clientX, clientY) => {
-        const rect = canvas.getBoundingClientRect();
-        const scaleX = canvas.width / rect.width;
-        const scaleY = canvas.height / rect.height;
-        return {
-            x: (clientX - rect.left) * scaleX,
-            y: (clientY - rect.top) * scaleY,
-        };
-    };
-    canvas.addEventListener("mousedown", (e) => {
-        const p = getCanvasPoint(e.clientX, e.clientY);
-        input.mouseX = p.x;
-        input.mouseY = p.y;
-        input.mouseDown = true;
-        input.mousePressed = true;
-        syncPrimaryPointer(input);
-    });
-    canvas.addEventListener("mouseup", () => {
-        input.mouseDown = false;
-        syncPrimaryPointer(input);
-    });
-    canvas.addEventListener("mousemove", (e) => {
-        const p = getCanvasPoint(e.clientX, e.clientY);
-        input.mouseX = p.x;
-        input.mouseY = p.y;
-        syncPrimaryPointer(input);
-    });
-    canvas.addEventListener("touchstart", (e) => {
-        for (const touch of Array.from(e.changedTouches)) {
-            const p = getCanvasPoint(touch.clientX, touch.clientY);
-            input.touchPointers.set(touch.identifier, {
-                x: p.x,
-                y: p.y,
-                pressed: true,
-            });
-            if (input.primaryTouchId === null) {
-                input.primaryTouchId = touch.identifier;
-            }
-        }
-        syncPrimaryPointer(input);
-        e.preventDefault();
-    }, { passive: false });
-    const clearTouches = (e) => {
-        for (const touch of Array.from(e.changedTouches)) {
-            input.touchPointers.delete(touch.identifier);
-            if (input.primaryTouchId === touch.identifier) {
-                input.primaryTouchId = null;
-            }
-        }
-        syncPrimaryPointer(input);
-        e.preventDefault();
-    };
-    canvas.addEventListener("touchend", clearTouches, { passive: false });
-    canvas.addEventListener("touchcancel", clearTouches, { passive: false });
-    canvas.addEventListener("touchmove", (e) => {
-        for (const touch of Array.from(e.changedTouches)) {
-            const p = getCanvasPoint(touch.clientX, touch.clientY);
-            const existing = input.touchPointers.get(touch.identifier);
-            if (existing) {
-                existing.x = p.x;
-                existing.y = p.y;
-            }
-            else {
-                input.touchPointers.set(touch.identifier, {
-                    x: p.x,
-                    y: p.y,
-                    pressed: false,
-                });
-            }
-        }
-        syncPrimaryPointer(input);
-        e.preventDefault();
-    }, { passive: false });
-}
-export function syncPrimaryPointer(input) {
-    if (input.primaryTouchId !== null) {
-        const primaryTouch = input.touchPointers.get(input.primaryTouchId);
-        if (primaryTouch) {
-            input.pointerX = primaryTouch.x;
-            input.pointerY = primaryTouch.y;
-            input.pointerDown = true;
-            input.pointerPressed = primaryTouch.pressed;
-            return;
-        }
-        input.primaryTouchId = null;
-    }
-    if (input.touchPointers.size > 0) {
-        const firstTouchEntry = input.touchPointers.entries().next().value;
-        if (firstTouchEntry) {
-            const [touchId, touch] = firstTouchEntry;
-            input.primaryTouchId = touchId;
-            input.pointerX = touch.x;
-            input.pointerY = touch.y;
-            input.pointerDown = true;
-            input.pointerPressed = touch.pressed;
-            return;
-        }
-    }
-    input.primaryTouchId = null;
-    input.pointerX = input.mouseX;
-    input.pointerY = input.mouseY;
-    input.pointerDown = input.mouseDown;
-    input.pointerPressed = input.mousePressed;
-}
-export function collectPointers(input) {
-    const pointers = [];
-    if (input.mouseDown) {
-        pointers.push({
-            id: "mouse",
-            kind: "mouse",
-            x: input.mouseX,
-            y: input.mouseY,
-            pressed: input.mousePressed,
-        });
-    }
-    for (const [id, pointer] of input.touchPointers.entries()) {
-        pointers.push({
-            id,
-            kind: "touch",
-            x: pointer.x,
-            y: pointer.y,
-            pressed: pointer.pressed,
-        });
-    }
-    return pointers;
-}
-export function isScreenPointOverSprite(x, y, sprite, radiusScale, scrollX, scrollY) {
-    const safeScale = Math.max(0, radiusScale);
-    const radius = sprite.size * safeScale;
-    const drawX = sprite.ignoreScroll ? sprite.x : sprite.x - scrollX;
-    const drawY = sprite.ignoreScroll ? sprite.y : sprite.y - scrollY;
-    const dx = x - drawX;
-    const dy = y - drawY;
-    return dx * dx + dy * dy <= radius * radius;
-}
-export function isPointerDownOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
-    if (!sprite)
-        return false;
-    return collectPointers(input).some((pointer) => isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
-}
-export function isPointerPressedOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
-    if (!sprite)
-        return false;
-    return collectPointers(input).some((pointer) => pointer.pressed &&
-        isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
-}
-export function getPointersOverSprite(input, sprite, radiusScale, scrollX, scrollY) {
-    if (!sprite)
-        return [];
-    return collectPointers(input).filter((pointer) => isScreenPointOverSprite(pointer.x, pointer.y, sprite, radiusScale, scrollX, scrollY));
-}
-export function resetTransientInput(input) {
-    input.keysPressed.clear();
-    input.mousePressed = false;
-    for (const pointer of input.touchPointers.values()) {
-        pointer.pressed = false;
-    }
-    syncPrimaryPointer(input);
-}

package/dist/internal-types.js

@@ -1,4 +0,0 @@
-// ---------------------------------------------------------------------------
-// Internal types (stripped from .d.ts via @internal + stripInternal)
-// ---------------------------------------------------------------------------
-export {};

package/dist/physics.js

@@ -1,10 +0,0 @@
-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/render.js

@@ -1,75 +0,0 @@
-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

@@ -1,149 +0,0 @@
-// ---------------------------------------------------------------------------
-// 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

@@ -1,23 +0,0 @@
-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;
-}