minimojs 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/internal/InputSystem.js

@@ -0,0 +1,292 @@
+/** @internal */
+export class InputSystem {
+    constructor(
+    /** @internal */ game, 
+    /** @internal */ canvas) {
+        this.game = game;
+        this.canvas = canvas;
+        /** @internal */
+        this._keysDown = new Set();
+        /** @internal */
+        this._keysPressed = new Set();
+        /** @internal */
+        this._pointerDown = false;
+        /** @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;
+        /**
+         * The primary touch after it lifted, kept until the mouse or a new touch
+         * takes over, so the pointer stays where the finger left the screen instead
+         * of jumping to the mouse's last position.
+         *
+         * @internal
+         */
+        this._releasedTouch = null;
+        /** @internal True on the frame the primary touch ended in a `touchcancel`. */
+        this._pointerCancelled = false;
+    }
+    get pointerX() {
+        return this._pointerX;
+    }
+    get pointerY() {
+        return this._pointerY;
+    }
+    bindInputEvents() {
+        window.addEventListener("keydown", (e) => {
+            if (!this._keysDown.has(e.key)) {
+                this._keysPressed.add(e.key);
+            }
+            this._keysDown.add(e.key);
+        });
+        window.addEventListener("keyup", (e) => {
+            this._keysDown.delete(e.key);
+        });
+        this.canvas.addEventListener("mousedown", (e) => {
+            const p = this.getCanvasPoint(e.clientX, e.clientY);
+            this._mouseX = p.x;
+            this._mouseY = p.y;
+            this._mouseDown = true;
+            this._mousePressed = true;
+            this._releasedTouch = null;
+            this.syncPrimaryPointer();
+        });
+        this.canvas.addEventListener("mouseup", () => {
+            this._mouseDown = false;
+            this._releasedTouch = null;
+            this.syncPrimaryPointer();
+        });
+        this.canvas.addEventListener("mousemove", (e) => {
+            const p = this.getCanvasPoint(e.clientX, e.clientY);
+            this._mouseX = p.x;
+            this._mouseY = p.y;
+            this._releasedTouch = null;
+            this.syncPrimaryPointer();
+        });
+        this.canvas.addEventListener("touchstart", (e) => {
+            for (const touch of Array.from(e.changedTouches)) {
+                const p = this.getCanvasPoint(touch.clientX, touch.clientY);
+                this._touchPointers.set(touch.identifier, {
+                    x: p.x,
+                    y: p.y,
+                    pressed: true,
+                });
+                // A finger that touches while none is followed becomes the pointer,
+                // even when other fingers are still down.
+                if (this._primaryTouchId === null) {
+                    this._primaryTouchId = touch.identifier;
+                }
+            }
+            this._releasedTouch = null;
+            this._pointerCancelled = false;
+            this.syncPrimaryPointer();
+            e.preventDefault();
+        }, { passive: false });
+        this.canvas.addEventListener("touchend", (e) => {
+            this.endTouches(e, false);
+            e.preventDefault();
+        }, { passive: false });
+        this.canvas.addEventListener("touchcancel", (e) => {
+            this.endTouches(e, true);
+            e.preventDefault();
+        }, { passive: false });
+        this.canvas.addEventListener("touchmove", (e) => {
+            for (const touch of Array.from(e.changedTouches)) {
+                const p = this.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 });
+    }
+    isKeyDown(key) {
+        return this._keysDown.has(key);
+    }
+    isKeyPressed(key) {
+        return this._keysPressed.has(key);
+    }
+    isPointerDown() {
+        return this._pointerDown;
+    }
+    isPointerPressed() {
+        return this._pointerPressed;
+    }
+    isPointerCancelled() {
+        return this._pointerCancelled;
+    }
+    isPointerDownOverSprite(sprite) {
+        if (!sprite)
+            return false;
+        if (this._mouseDown &&
+            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite)) {
+            return true;
+        }
+        for (const pointer of this._touchPointers.values()) {
+            if (this.isScreenPointOverSprite(pointer.x, pointer.y, sprite)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isPointerPressedOverSprite(sprite) {
+        if (!sprite)
+            return false;
+        if (this._mousePressed &&
+            this.isScreenPointOverSprite(this._mouseX, this._mouseY, sprite)) {
+            return true;
+        }
+        for (const pointer of this._touchPointers.values()) {
+            if (pointer.pressed &&
+                this.isScreenPointOverSprite(pointer.x, pointer.y, sprite)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    getPointers() {
+        return this.collectPointers();
+    }
+    getPointersOverSprite(sprite) {
+        if (!sprite)
+            return [];
+        return this.collectPointers().filter((pointer) => this.isScreenPointOverSprite(pointer.x, pointer.y, sprite));
+    }
+    isMobileDevice() {
+        if (typeof navigator === "undefined")
+            return false;
+        const ua = navigator.userAgent ?? "";
+        const mobileUA = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Mobile/i.test(ua);
+        const iPadOS = navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+        const coarsePointer = typeof window !== "undefined" &&
+            typeof window.matchMedia === "function" &&
+            window.matchMedia("(pointer: coarse)").matches;
+        return mobileUA || iPadOS || coarsePointer;
+    }
+    clearFramePressedState() {
+        this._keysPressed.clear();
+        this._mousePressed = false;
+        for (const pointer of this._touchPointers.values()) {
+            pointer.pressed = false;
+        }
+        if (this._releasedTouch)
+            this._releasedTouch.pressed = false;
+        this._pointerCancelled = false;
+        this.syncPrimaryPointer();
+    }
+    resetPressedState() {
+        this.clearFramePressedState();
+    }
+    /**
+     * Removes the touches an event ended. When the primary one lifts, it is kept
+     * as the released touch at the point it lifted, carrying its frame-press flag
+     * so a tap that starts and ends between two frames still reads as pressed.
+     *
+     * @internal
+     */
+    endTouches(e, cancelled) {
+        for (const touch of Array.from(e.changedTouches)) {
+            const pointer = this._touchPointers.get(touch.identifier);
+            this._touchPointers.delete(touch.identifier);
+            if (this._primaryTouchId !== touch.identifier || !pointer)
+                continue;
+            this._primaryTouchId = null;
+            if (!cancelled) {
+                const p = this.getCanvasPoint(touch.clientX, touch.clientY);
+                pointer.x = p.x;
+                pointer.y = p.y;
+            }
+            this._releasedTouch = pointer;
+            this._pointerCancelled = cancelled;
+        }
+        this.syncPrimaryPointer();
+    }
+    /** @internal */
+    getCanvasPoint(clientX, clientY) {
+        const rect = this.canvas.getBoundingClientRect();
+        const scaleX = this.canvas.width / rect.width;
+        const scaleY = this.canvas.height / rect.height;
+        return {
+            x: (clientX - rect.left) * scaleX,
+            y: (clientY - rect.top) * scaleY,
+        };
+    }
+    /** @internal */
+    isScreenPointOverSprite(x, y, sprite) {
+        const halfWidth = sprite.displayWidth / 2;
+        const halfHeight = sprite.displayHeight / 2;
+        const drawX = sprite.ignoreScroll ? sprite.renderX : sprite.renderX - this.game.scrollX;
+        const drawY = sprite.ignoreScroll ? sprite.renderY : sprite.renderY - this.game.scrollY;
+        return Math.abs(x - drawX) <= halfWidth && Math.abs(y - drawY) <= halfHeight;
+    }
+    /** @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;
+        }
+        // No finger is followed. Fingers still down are not adopted: the pointer
+        // reports the followed finger's release, and the next finger to touch
+        // is followed instead.
+        this._primaryTouchId = null;
+        const released = this._releasedTouch;
+        this._pointerX = released ? released.x : this._mouseX;
+        this._pointerY = released ? released.y : this._mouseY;
+        this._pointerDown = this._mouseDown;
+        this._pointerPressed = this._mousePressed || (released?.pressed ?? false);
+    }
+}

package/dist/internal/LoopSystem.d.ts

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

package/dist/internal/LoopSystem.js

@@ -0,0 +1,61 @@
+/** @internal */
+export class LoopSystem {
+    constructor(/** @internal */ onFrame) {
+        this.onFrame = onFrame;
+        /** @internal */
+        this._rafId = null;
+        /** @internal */
+        this._lastTimestamp = null;
+        /** @internal */
+        this._running = false;
+        /** @internal */
+        this._hasCreated = false;
+        /** @internal */
+        this._onCreate = null;
+        /** @internal */
+        this.loop = (timestamp) => {
+            if (!this._running)
+                return;
+            if (this._lastTimestamp === null) {
+                this._lastTimestamp = timestamp;
+            }
+            let dt = (timestamp - this._lastTimestamp) / 1000;
+            this._lastTimestamp = timestamp;
+            if (dt > 0.1)
+                dt = 0.1;
+            this.onFrame(dt, dt * 1000);
+            this._rafId = requestAnimationFrame(this.loop);
+        };
+    }
+    get onCreate() {
+        return this._onCreate;
+    }
+    set onCreate(callback) {
+        this._onCreate = callback;
+    }
+    get isRunning() {
+        return this._running;
+    }
+    start() {
+        if (this._running)
+            return;
+        if (!this._hasCreated) {
+            this.invokeCreate();
+        }
+        this._running = true;
+        this._lastTimestamp = null;
+        this._rafId = requestAnimationFrame(this.loop);
+    }
+    stop() {
+        this._running = false;
+        if (this._rafId !== null) {
+            cancelAnimationFrame(this._rafId);
+            this._rafId = null;
+        }
+        this._lastTimestamp = null;
+    }
+    invokeCreate() {
+        this._hasCreated = true;
+        this._onCreate?.();
+    }
+}

package/dist/internal/PhysicsSystem.d.ts

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

package/dist/internal/PhysicsSystem.js

@@ -0,0 +1,174 @@
+/** @internal */
+export class PhysicsSystem {
+    constructor() {
+        /** @internal */
+        this._gravityX = 0;
+        /** @internal */
+        this._gravityY = 0;
+        /** @internal */
+        this._enabled = false;
+    }
+    get gravityX() {
+        return this._gravityX;
+    }
+    set gravityX(value) {
+        this._gravityX = value;
+    }
+    get gravityY() {
+        return this._gravityY;
+    }
+    set gravityY(value) {
+        this._gravityY = value;
+    }
+    get enabled() {
+        return this._enabled;
+    }
+    set enabled(value) {
+        this._enabled = value;
+    }
+    update(sprites, dt) {
+        for (const sprite of sprites) {
+            if (sprite.isStatic) {
+                continue;
+            }
+            if (sprite.gravityScale !== 0) {
+                sprite.vx += this._gravityX * sprite.gravityScale * dt;
+                sprite.vy += this._gravityY * sprite.gravityScale * dt;
+            }
+            sprite.x += sprite.vx * dt;
+            sprite.y += sprite.vy * dt;
+        }
+    }
+    overlap(a, b) {
+        const halfWidthA = a.bodyDisplayWidth / 2;
+        const halfHeightA = a.bodyDisplayHeight / 2;
+        const halfWidthB = b.bodyDisplayWidth / 2;
+        const halfHeightB = b.bodyDisplayHeight / 2;
+        return (Math.abs(a.bodyCenterX - b.bodyCenterX) < halfWidthA + halfWidthB &&
+            Math.abs(a.bodyCenterY - b.bodyCenterY) < halfHeightA + halfHeightB);
+    }
+    overlapAny(listA, listB) {
+        for (const a of listA) {
+            for (const b of listB) {
+                if (this.overlap(a, b)) {
+                    return [a, b];
+                }
+            }
+        }
+        return null;
+    }
+    collide(a, b) {
+        this.assertEnabled();
+        if (a === b)
+            return null;
+        const collision = this.getCollisionResolution(a, b);
+        if (!collision)
+            return null;
+        if (!a.isStatic) {
+            a.x += collision.separationX;
+            a.y += collision.separationY;
+            if (collision.axis === "x") {
+                a.vx = 0;
+            }
+            else {
+                a.vy = 0;
+            }
+        }
+        else if (!b.isStatic) {
+            b.x -= collision.separationX;
+            b.y -= collision.separationY;
+            if (collision.axis === "x") {
+                b.vx = 0;
+            }
+            else {
+                b.vy = 0;
+            }
+        }
+        return collision.info;
+    }
+    collideAny(listA, listB) {
+        this.assertEnabled();
+        for (const a of listA) {
+            for (const b of listB) {
+                const info = this.collide(a, b);
+                if (info)
+                    return [a, b, info];
+            }
+        }
+        return null;
+    }
+    /** @internal */
+    assertEnabled() {
+        if (!this._enabled) {
+            throw new Error("MinimoJS: collide() and collideAny() require game.physics = true.");
+        }
+    }
+    /** @internal */
+    getCollisionResolution(a, b) {
+        const halfWidthA = a.bodyDisplayWidth / 2;
+        const halfHeightA = a.bodyDisplayHeight / 2;
+        const halfWidthB = b.bodyDisplayWidth / 2;
+        const halfHeightB = b.bodyDisplayHeight / 2;
+        const dx = b.bodyCenterX - a.bodyCenterX;
+        const dy = b.bodyCenterY - a.bodyCenterY;
+        const overlapX = halfWidthA + halfWidthB - Math.abs(dx);
+        const overlapY = halfHeightA + halfHeightB - Math.abs(dy);
+        if (overlapX <= 0 || overlapY <= 0) {
+            return null;
+        }
+        let axis;
+        if (overlapX < overlapY) {
+            axis = "x";
+        }
+        else if (overlapY < overlapX) {
+            axis = "y";
+        }
+        else {
+            const relVX = Math.abs(a.vx - b.vx);
+            const relVY = Math.abs(a.vy - b.vy);
+            axis = relVX > relVY ? "x" : "y";
+        }
+        const info = {
+            left: false,
+            right: false,
+            top: false,
+            bottom: false,
+            grounded: false,
+        };
+        if (axis === "x") {
+            if (dx >= 0) {
+                info.right = true;
+                return {
+                    info,
+                    axis,
+                    separationX: -overlapX,
+                    separationY: 0,
+                };
+            }
+            info.left = true;
+            return {
+                info,
+                axis,
+                separationX: overlapX,
+                separationY: 0,
+            };
+        }
+        if (dy >= 0) {
+            info.bottom = true;
+            info.grounded = true;
+            return {
+                info,
+                axis,
+                separationX: 0,
+                separationY: -overlapY,
+            };
+        }
+        info.top = true;
+        return {
+            info,
+            axis,
+            separationX: 0,
+            separationY: overlapY,
+        };
+    }
+}

package/dist/internal/RenderSystem.d.ts

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