pxt-common-packages 9.4.13 → 9.4.16

package/libs/game/extendableSprite.ts

@@ -0,0 +1,80 @@
+namespace sprites {
+    /**
+     * A version of the Sprite class that is easier to extend.
+     * 
+     * Unlike the normal Sprite class, this class will automatically add
+     * itself to the physics engine and run all sprite created handlers
+     * in the constructor
+     */
+    export class ExtendableSprite extends Sprite {
+        protected hasCustomDimensions: boolean;
+
+        constructor(spriteImage: Image, kind?: number) {
+            super(spriteImage);
+
+            const scene = game.currentScene();
+            this.setKind(kind);
+            scene.physicsEngine.addSprite(this);
+    
+            // run on created handlers
+            scene.createdHandlers
+                .filter(h => h.kind == kind)
+                .forEach(h => h.handler(this));
+
+            this.hasCustomDimensions = false;
+        }
+
+        /**
+         * Override to change how the sprite is drawn to the screen
+         * 
+         * @param drawLeft The left position to draw the sprite at (already adjusted for camera)
+         * @param drawTop The top position to draw the sprite at (already adjusted for camera)
+         */
+        draw(drawLeft: number, drawTop: number) {
+            super.drawSprite(drawLeft, drawTop);
+        }
+
+        /**
+         * Override to add update logic for a sprite. This method runs once per frame
+         * 
+         * @param deltaTimeMillis The time that has elapsed since the last frame in milliseconds
+         */
+        update(deltaTimeMillis: number) {
+        }
+
+        /**
+         * Sets the width and height of this sprite. Once set, this will also prevent
+         * this width and height from automatically changing whenever scale or the image
+         * changes
+         */
+        setDimensions(width: number, height: number) {
+            this._width = Fx8(width);
+            this._height = Fx8(height);
+            this.hasCustomDimensions = true;
+            this.resetHitbox();
+        }
+        
+        __update(camera: scene.Camera, dt: number) {
+            super.__update(camera, dt);
+            this.update(game.currentScene().eventContext.deltaTimeMillis)
+        }
+
+        setHitbox() {
+            if (this.hasCustomDimensions) {
+                this._hitbox = new game.Hitbox(this, this._width, this._height, Fx.zeroFx8, Fx.zeroFx8)
+            }
+            else {
+                super.setHitbox();
+            }
+        }
+
+        protected drawSprite(drawLeft: number, drawTop: number): void {
+            this.draw(drawLeft, drawTop);
+        }
+
+        protected recalcSize() {
+            if (this.hasCustomDimensions) return;
+            super.recalcSize();
+        }
+    }
+}

package/libs/game/hitbox.ts

@@ -1,6 +1,6 @@
 namespace game {
     export class Hitbox {
-        hash: Fx8;
+        hash: number;
         parent: Sprite;
         ox: Fx8;
         oy: Fx8;
@@ -46,7 +46,48 @@ namespace game {
             return (x >= this.left) && (x <= this.right) && (y >= this.top) && (y <= this.bottom);
         }
 
+        updateIfInvalid() {
+            if (this.isValid())
+                return;
+
+            const newHitBox = game.calculateHitBox(this.parent);
+
+            const oMinX = this.ox;
+            const oMinY = this.oy;
+            const oMaxX = Fx.add(oMinX, this.width);
+            const oMaxY = Fx.add(oMinY, this.height);
+
+            const nMinX = newHitBox.ox;
+            const nMinY = newHitBox.oy;
+            const nMaxX = Fx.add(nMinX, newHitBox.width);
+            const nMaxY = Fx.add(nMinY, newHitBox.height);
+
+            // total diff in x / y corners between the two hitboxes
+            const xDiff = Fx.add(
+                Fx.abs(Fx.sub(oMinX, nMinX)),
+                Fx.abs(Fx.sub(oMaxX, nMaxX))
+            );
+            const yDiff = Fx.add(
+                Fx.abs(Fx.sub(oMinY, nMinY)),
+                Fx.abs(Fx.sub(oMaxY, nMaxY))
+            );
+
+            // If it's just a small change to the hitbox on one axis,
+            // don't change the dimensions to avoid random clipping
+            if (xDiff > Fx.twoFx8) {
+                this.ox = nMinX;
+                this.width = newHitBox.width;
+            }
+            if (yDiff > Fx.twoFx8) {
+                this.oy = nMinY;
+                this.height = newHitBox.height;
+            }
+            this.hash = newHitBox.hash;
+        }
+
         overlapsWith(other: Hitbox): boolean {
+            this.updateIfInvalid();
+            other.updateIfInvalid();
             if (this.contains(other.left, other.top)) return true;
             if (this.contains(other.left, other.bottom)) return true;
             if (this.contains(other.right, other.top)) return true;

package/libs/game/keymap.cpp

@@ -0,0 +1,12 @@
+#include "pxt.h"
+
+namespace keymap {
+
+    void _setPlayerKeys(int player, int up, int down, int left, int right, int A, int B) {
+        // not supported
+    }
+
+    void _setSystemKeys(int screenshot, int gif) {
+        // not supported
+    }
+}

package/libs/game/keymap.ts

@@ -0,0 +1,169 @@
+namespace keymap {
+    //% shim=keymap::_setPlayerKeys
+    declare function _setPlayerKeys(
+        player: number, // player number is 1-based
+        up: number,
+        down: number,
+        left: number,
+        right: number,
+        A: number,
+        B: number
+    ): void;
+
+    //% shim=keymap::_setSystemKeys
+    declare function _setSystemKeys(screenshot: number, gif: number, menu: number, reset: number): void;
+
+    /**
+     * Sets the keyboard input map for the given player.
+     * @param player The player number. 1 = Player1, etc.
+     * @param up The key code for 'up'.
+     * @param down The key code for 'down'
+     * @param left The key code for 'left'
+     * @param right The key code for 'right'
+     * @param A The key code for 'A'
+     * @param B The key code for 'B'
+     */
+    export function setPlayerKeys(
+        player: number, // player number is 1-based
+        up: KeyCode,
+        down: KeyCode,
+        left: KeyCode,
+        right: KeyCode,
+        A: KeyCode,
+        B: KeyCode
+    ) {
+        _setPlayerKeys(player, up, down, left, right, A, B);
+    }
+
+    /**
+     * Sets the keyboard input map for system keys.
+     * @param screenshot The key code for 'screenshot'
+     * @param gif The key code for 'gif'
+     * @param menu The key code for 'menu'
+     * @param reset The key code for 'reset'
+     */
+    export function setSystemKeys(screenshot: KeyCode, gif: KeyCode, menu: KeyCode, reset: KeyCode) {
+        _setSystemKeys(screenshot, gif, menu, reset);
+    }
+
+    /**
+     * Key codes
+     */
+    export enum KeyCode {
+        None = 0,
+
+        Backspace = 8,
+        Tab = 9,
+        Enter = 13,
+        Shift = 16,
+        Ctrl = 17,
+        Alt = 18,
+        PauseBreak = 19,
+        CapsLock = 20,
+        Escape = 27,
+        Space = 32,
+        PageUp = 33,
+        PageDown = 34,
+        End = 35,
+        Home = 36,
+
+        LeftArrow = 37,
+        UpArrow = 38,
+        RightArrow = 39,
+        DownArrow = 40,
+
+        Insert = 45,
+        Delete = 46,
+
+        Zero = 48,
+        One = 49,
+        Two = 50,
+        Three = 51,
+        Four = 52,
+        Five = 53,
+        Six = 54,
+        Seven = 55,
+        Eight = 56,
+        Nine = 57,
+
+        A = 65,
+        B = 66,
+        C = 67,
+        D = 68,
+        E = 69,
+        F = 70,
+        G = 71,
+        H = 72,
+        I = 73,
+        J = 74,
+        K = 75,
+        L = 76,
+        M = 77,
+        N = 78,
+        O = 79,
+        P = 80,
+        Q = 81,
+        R = 82,
+        S = 83,
+        T = 84,
+        U = 85,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+
+        LeftWindowsKey = 91,
+        RightWindowsKey = 92,
+
+        Numpad0 = 96,
+        Numpad1 = 97,
+        Numpad2 = 98,
+        Numpad3 = 99,
+        Numpad4 = 100,
+        Numpad5 = 101,
+        Numpad6 = 102,
+        Numpad7 = 103,
+        Numpad8 = 104,
+        Numpad9 = 105,
+
+        Multiply = 106,
+        Add = 107,
+        Subtract = 109,
+        DecimalPoint = 110,
+        Divide = 111,
+
+        F1 = 112,
+        F2 = 113,
+        F3 = 114,
+        F4 = 115,
+        F5 = 116,
+        F6 = 117,
+        F7 = 118,
+        F8 = 119,
+        F9 = 120,
+        F10 = 121,
+        F11 = 122,
+        F12 = 123,
+
+        NumLock = 144,
+        ScrollLock = 145,
+
+        SemiColon = 186,
+        Equals = 187,
+        Comma = 188,
+        Dash = 189,
+        Period = 190,
+        ForwardSlash = 191,
+        Tilde = 192,
+
+        OpenBracket = 219,
+        ClosedBracket = 221,
+        SingleQuote = 222,
+
+        // Mouse
+        MouseLeftButton = -1,
+        MouseRightButton = -2,
+        MouseCenterButton = -3,
+    }
+}

package/libs/game/pxt.json

@@ -13,6 +13,7 @@
         "spritesay.ts",
         "sprites.ts",
         "sprite.ts",
+        "extendableSprite.ts",
         "sprite.d.ts",
         "spritemap.ts",
         "spriteevents.ts",
@@ -48,7 +49,9 @@
         "effects.ts",
         "texteffects.ts",
         "assetTemplates.ts",
-        "animation.ts"
+        "animation.ts",
+        "keymap.cpp",
+        "keymap.ts"
     ],
     "public": true,
     "dependencies": {

package/libs/game/sim/keymap.ts

@@ -0,0 +1,167 @@
+namespace pxsim.keymap {
+    // Keep in sync with pxt-arcade-sim/api.ts
+    export enum Key {
+        None = 0,
+
+        // Player 1
+        Left = 1,
+        Up = 2,
+        Right = 3,
+        Down = 4,
+        A = 5,
+        B = 6,
+
+        Menu = 7,
+
+        // Player 2 = Player 1 + 7
+        // Player 3 = Player 2 + 7
+        // Player 4 = Player 3 + 7
+
+        // system keys
+        Screenshot = -1,
+        Gif = -2,
+        Reset = -3,
+        TogglePause = -4
+    }
+
+    export function _setPlayerKeys(
+        player: number, // player number is 1-based
+        up: number,
+        down: number,
+        left: number,
+        right: number,
+        A: number,
+        B: number
+    ) {
+        getKeymapState().setPlayerKeys(player, up, down, left, right, A, B);
+    }
+
+    export function _setSystemKeys(screenshot: number, gif: number, menu: number, reset: number) {
+        getKeymapState().setSystemKeys(screenshot, gif, menu, reset);
+    }
+}
+
+namespace pxsim {
+    import Key = pxsim.keymap.Key;
+
+    export interface KeymapBoard extends EventBusBoard {
+        keymapState: KeymapState;
+    }
+
+    export function getKeymapState() {
+        return (board() as EventBusBoard as KeymapBoard).keymapState;
+    }
+
+    const reservedKeyCodes = [
+        27, // Escape
+        9 // Tab
+    ];
+
+    export class KeymapState {
+        keymap: { [keyCode: number]: Key } = {};
+        altmap: { [keyCode: number]: Key } = {};
+        mappings: { [name: string]: number[] } = {};
+
+        constructor() {
+            // Player 1 keymap
+            this.setPlayerKeys(
+                1, // Player 1
+                87, // W - Up
+                83, // S - Down
+                65, // A - Left
+                68, // D - Right
+                32, // Space - A
+                13 // Enter - B
+            );
+            // Player 2 keymap
+            this.setPlayerKeys(
+                2, // Player 2
+                73, // I - Up
+                75, // K - Down
+                74, // J - Left
+                76, // L - Right
+                85, // U - A
+                79 // O - B
+            );
+            // Note: Player 3 and 4 have no default keyboard mapping
+
+            // System keymap
+            this.setSystemKeys(
+                80, // P - Screenshot
+                82, // R - Gif
+                0, // Menu - not mapped
+                0 // Reset - not mapped
+            );
+
+            // Player 1 alternate mapping. This is cleared when the game sets any player keys explicitly
+            this.altmap[38] = Key.Up; // UpArrow
+            this.altmap[37] = Key.Left; // LeftArrow
+            this.altmap[40] = Key.Down; // DownArrow
+            this.altmap[39] = Key.Right; // RightArrow
+            this.altmap[81] = Key.A; // Q
+            this.altmap[90] = Key.A; // Z
+            this.altmap[88] = Key.B; // X
+            this.altmap[69] = Key.B; // E
+        }
+
+        public setPlayerKeys(
+            player: number, // player number is 1-based
+            up: number,
+            down: number,
+            left: number,
+            right: number,
+            A: number,
+            B: number
+        ) {
+            // We only support four players
+            if (player < 1 || player > 4) return;
+            const keyCodes = [up, down, left, right, A, B];
+            // Check for reserved key codes
+            // TODO: How to surface this runtime error to the user?
+            // TODO: Send message to UI: "Keyboard mapping contains a reserved key code"
+            const filtered = keyCodes.filter(keyCode => reservedKeyCodes.includes(keyCode));
+            if (filtered.length) return;
+            // Clear existing mapped keys for player
+            const mapName = `player-${player}`;
+            this.clearMap(mapName);
+            // Clear altmap When explicitly setting the player keys
+            this.altmap = {};
+            // Map the new keys
+            const offset = (player - 1) * 7; // +7 for player 2's keys
+            this.keymap[up] = Key.Up + offset;
+            this.keymap[down] = Key.Down + offset;
+            this.keymap[left] = Key.Left + offset;
+            this.keymap[right] = Key.Right + offset;
+            this.keymap[A] = Key.A + offset;
+            this.keymap[B] = Key.B + offset;
+            // Remember this mapping
+            this.saveMap(mapName, keyCodes);
+        }
+
+        public setSystemKeys(screenshot: number, gif: number, menu: number, reset: number) {
+            const mapName = "system";
+            // Clear existing mapped keys for system
+            this.clearMap(mapName);
+            this.keymap[screenshot] = Key.Screenshot;
+            this.keymap[gif] = Key.Gif;
+            this.keymap[menu] = Key.Menu;
+            this.keymap[reset] = Key.Reset;
+            // Remember this mapping
+            this.saveMap(mapName, [screenshot, gif, menu, reset]);
+        }
+
+        public getKey(keyCode: number): Key {
+            return keyCode ? this.keymap[keyCode] || this.altmap[keyCode] || Key.None : Key.None;
+        }
+
+        private saveMap(name: string, keyCodes: number[]) {
+            this.mappings[name] = keyCodes;
+        }
+
+        private clearMap(name: string) {
+            const keyCodes = this.mappings[name];
+            keyCodes?.forEach(keyCode => delete this.keymap[keyCode]);
+            delete this.mappings[name];
+        }
+    }
+}