pxt-common-packages 9.4.11 → 9.4.14

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

@@ -17,11 +17,11 @@ namespace game {
         }
 
         get left() {
-            return Fx.add(this.ox, Fx.floor(this.parent._x));
+            return Fx.add(this.ox, this.parent._x);
         }
 
         get top() {
-            return Fx.add(this.oy, Fx.floor(this.parent._y));
+            return Fx.add(this.oy, this.parent._y);
         }
 
         get right() {

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/scenes.ts

@@ -116,7 +116,6 @@ namespace scene {
         if (!scene.tileMap)
             scene.tileMap = new tiles.TileMap();
         scene.tileMap.setData(map);
-        scene.tileMap.scale = map.scale;
     }
 
      /**

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, // D - Down
+                65, // A - Left
+                83, // S - Right
+                32, // Space - A
+                13 // Enter - B
+            );
+            // Player 2 keymap
+            this.setPlayerKeys(
+                2, // Player 2
+                73, // I - Up
+                75, // K - Down
+                74, // J - Left
+                75, // K - 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];
+        }
+    }
+}

package/libs/game/sprite.ts

@@ -394,7 +394,7 @@ class Sprite extends sprites.BaseSprite {
         return !(this.flags & SpriteFlag.Invisible);
     }
 
-    private recalcSize(): void {
+    protected recalcSize(): void {
         this._width = Fx8(this._image.width * this.sx);
         this._height = Fx8(this._image.height * this.sy);
         this.resetHitbox();
@@ -645,21 +645,7 @@ class Sprite extends sprites.BaseSprite {
     }
 
     __drawCore(camera: scene.Camera) {
-        if (this.sayRenderer) {
-            if (this.sayEndTime !== undefined) {
-                if (control.millis() < this.sayEndTime) {
-                    this.sayRenderer.draw(screen, camera, this);
-                }
-                else {
-                    this.sayRenderer.destroy();
-                    this.sayRenderer = undefined;
-                    this.sayEndTime = undefined;
-                }
-            }
-            else {
-                this.sayRenderer.draw(screen, camera, this)
-            }
-        }
+        this.drawSay(camera);
 
         if (this.isOutOfScreen(camera)) return;
 
@@ -669,47 +655,8 @@ class Sprite extends sprites.BaseSprite {
         const l = Math.floor(this.left - ox);
         const t = Math.floor(this.top - oy);
 
-        if (!this.isScaled())
-            screen.drawTransparentImage(this._image, l, t);
-        else
-            screen.blit(
-                // dst rect in screen
-                l, t,
-                this.width,
-                this.height,
-                // src rect in sprite image
-                this._image,
-                0, 0,
-                this._image.width, this._image.height,
-                true, false);
-
-        if (this.flags & SpriteFlag.ShowPhysics) {
-            const font = image.font5;
-            const margin = 2;
-            let tx = l;
-            let ty = t + this.height + margin;
-            screen.print(`${this.x >> 0},${this.y >> 0}`, tx, ty, 1, font);
-            tx -= font.charWidth;
-            if (this.vx || this.vy) {
-                ty += font.charHeight + margin;
-                screen.print(`v${this.vx >> 0},${this.vy >> 0}`, tx, ty, 1, font);
-            }
-            if (this.ax || this.ay) {
-                ty += font.charHeight + margin;
-                screen.print(`a${this.ax >> 0},${this.ay >> 0}`, tx, ty, 1, font);
-            }
-        }
-
-        // debug info
-        if (game.debug) {
-            screen.drawRect(
-                Fx.toInt(this._hitbox.left) - ox,
-                Fx.toInt(this._hitbox.top) - oy,
-                Fx.toInt(this._hitbox.width),
-                Fx.toInt(this._hitbox.height),
-                1
-            );
-        }
+        this.drawSprite(l, t);
+        this.drawDebug(l, t, ox, oy);
     }
 
     __update(camera: scene.Camera, dt: number) {
@@ -1170,4 +1117,68 @@ class Sprite extends sprites.BaseSprite {
     toString() {
         return `${this.id}(${this.x},${this.y})->(${this.vx},${this.vy})`;
     }
+
+    protected drawSay(camera: scene.Camera) {
+        if (this.sayRenderer) {
+            if (this.sayEndTime !== undefined) {
+                if (control.millis() < this.sayEndTime) {
+                    this.sayRenderer.draw(screen, camera, this);
+                }
+                else {
+                    this.sayRenderer.destroy();
+                    this.sayRenderer = undefined;
+                    this.sayEndTime = undefined;
+                }
+            }
+            else {
+                this.sayRenderer.draw(screen, camera, this)
+            }
+        }
+    }
+
+    protected drawDebug(left: number, top: number, offsetX: number, offsetY: number) {
+        if (this.flags & SpriteFlag.ShowPhysics) {
+            const font = image.font5;
+            const margin = 2;
+            let tx = left;
+            let ty = top + this.height + margin;
+            screen.print(`${this.x >> 0},${this.y >> 0}`, tx, ty, 1, font);
+            tx -= font.charWidth;
+            if (this.vx || this.vy) {
+                ty += font.charHeight + margin;
+                screen.print(`v${this.vx >> 0},${this.vy >> 0}`, tx, ty, 1, font);
+            }
+            if (this.ax || this.ay) {
+                ty += font.charHeight + margin;
+                screen.print(`a${this.ax >> 0},${this.ay >> 0}`, tx, ty, 1, font);
+            }
+        }
+
+        // debug info
+        if (game.debug) {
+            screen.drawRect(
+                Fx.toInt(this._hitbox.left) - offsetX,
+                Fx.toInt(this._hitbox.top) - offsetY,
+                Fx.toInt(this._hitbox.width),
+                Fx.toInt(this._hitbox.height),
+                1
+            );
+        }
+    }
+
+    protected drawSprite(drawLeft: number, drawTop: number) {
+        if (!this.isScaled())
+            screen.drawTransparentImage(this._image, drawLeft, drawTop);
+        else
+            screen.blit(
+                // dst rect in screen
+                drawLeft, drawTop,
+                this.width,
+                this.height,
+                // src rect in sprite image
+                this._image,
+                0, 0,
+                this._image.width, this._image.height,
+                true, false);
+    }
 }

package/libs/game/tilemap.ts

@@ -357,16 +357,17 @@ namespace tiles {
             const previous = this._map;
 
             if (this.handlerState && previous !== map && previous) {
-                if (map) {
-                    for (const eventHandler of this.handlerState) {
-                        if (eventHandler.event === TileMapEvent.Unloaded) {
-                            eventHandler.callback(previous);
-                        }
+                for (const eventHandler of this.handlerState) {
+                    if (eventHandler.event === TileMapEvent.Unloaded) {
+                        eventHandler.callback(previous);
                     }
                 }
             }
 
             this._map = map;
+            if (map) {
+                this._scale = map.scale;
+            }
 
             if (this.handlerState && previous !== map && map) {
                 for (const eventHandler of this.handlerState) {

package/libs/lcd/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P48928(s) {
+function _main___P48209(s) {
 let r0 = s.r0, step = s.pc;
 s.pc = -1;
 
@@ -66,19 +66,19 @@ if (yieldSteps-- < 0 && maybeYield(s, step, r0) || runtime !== pxsim.runtime) re
 switch (step) {
   case 0:
 
-    globals._intervals___49171 = (undefined);
-    globals._pollEventQueue___49184 = (undefined);
+    globals._intervals___48452 = (undefined);
+    globals._pollEventQueue___48465 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P48928.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
-_main___P48928.continuations = [  ]
+_main___P48209.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
+_main___P48209.continuations = [  ]
 
-function _main___P48928_mk(s) {
+function _main___P48209_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P48928, depth: s.depth + 1,
+        parent: s, fn: _main___P48209, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P48928_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P48928
+return _main___P48209
 })