pxt-common-packages 9.5.6 → 9.5.9

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/multiplayer.cpp

@@ -0,0 +1,25 @@
+#include "pxt.h"
+
+namespace multiplayer {
+    //%
+    void postImage(Image_ im, String goal) {
+        // no support >:(
+    }
+
+    //%
+    void setOrigin(String origin) {
+        // no
+    }
+
+    //%
+    Image_ getCurrentImage() {
+        // nah
+        return NULL;
+    }
+
+    //%
+    String getOrigin() {
+        return NULL;
+    }
+
+}

package/libs/game/multiplayer.ts

@@ -0,0 +1,24 @@
+namespace multiplayer {
+    //% shim=multiplayer::getCurrentImage
+    declare function getCurrentImage(): Image;
+
+    //% shim=multiplayer::setOrigin
+    declare function setOrigin(origin: string): void;
+
+    //% shim=multiplayer::getOrigin
+    declare function getOrigin(): string;
+
+    export function init() {
+        game.addScenePushHandler(() => {
+            game.eventContext().registerFrameHandler(scene.MULTIPLAYER_SCREEN_PRIORITY, () => {
+                if (getOrigin() === "client") {
+                    const im: Image = getCurrentImage();
+                    scene.setBackgroundImage(im);
+                    // clear default menu button behavior
+                    controller.menu.onEvent(ControllerButtonEvent.Pressed, () => { });
+                }
+            });
+        });
+        game.pushScene();
+    }
+}

package/libs/game/pxt.json

@@ -48,7 +48,11 @@
         "effects.ts",
         "texteffects.ts",
         "assetTemplates.ts",
-        "animation.ts"
+        "animation.ts",
+        "multiplayer.cpp",
+        "multiplayer.ts",
+        "keymap.cpp",
+        "keymap.ts"
     ],
     "public": true,
     "dependencies": {

package/libs/game/scene.ts

@@ -63,6 +63,7 @@ namespace scene {
     export const RENDER_BACKGROUND_PRIORITY = 60;
     export const RENDER_SPRITES_PRIORITY = 90;
     export const RENDER_DIAGNOSTICS_PRIORITY = 150;
+    export const MULTIPLAYER_SCREEN_PRIORITY = 190;
     export const UPDATE_SCREEN_PRIORITY = 200;
 
     // default rendering z indices

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/sim/multiplayer.ts

@@ -0,0 +1,132 @@
+namespace pxsim.multiplayer {
+    export function postImage(im: pxsim.RefImage, goal: string) {
+        const asBuf = pxsim.image.toBuffer(im);
+        getMultiplayerState().send(<MultiplayerImageMessage>{
+            content: "Image",
+            image: asBuf,
+            goal
+        });
+    }
+
+    export function getCurrentImage(): pxsim.RefImage {
+        return getMultiplayerState().backgroundImage;
+    }
+
+    export function setOrigin(origin: "client" | "server" | undefined) {
+        getMultiplayerState().origin = origin;
+    }
+
+    export function getOrigin(): string {
+        return getMultiplayerState().origin;
+    }
+}
+
+namespace pxsim {
+    export interface MultiplayerBoard extends EventBusBoard {
+        multiplayerState: MultiplayerState;
+    }
+
+    export function getMultiplayerState() {
+        return (board() as EventBusBoard as MultiplayerBoard).multiplayerState;
+    }
+
+    export interface SimulatorMultiplayerMessage extends SimulatorBroadcastMessage {
+        broadcast: true
+        type: "multiplayer";
+        content: string;
+        origin?: "server" | "client";
+        clientNumber?: number;
+        id?: number;
+    }
+
+    export interface MultiplayerImageMessage extends SimulatorMultiplayerMessage {
+        content: "Image";
+        goal: string; // goal of message; e.g. "broadcast-screen"
+        image: RefImage;
+    }
+
+    export interface MultiplayerButtonEvent extends SimulatorMultiplayerMessage {
+        content: "Button";
+        button: number; // pxsim.Key.A, ...
+        state: "Pressed" | "Released" | "Held";
+    }
+
+    export class MultiplayerState {
+        lastMessageId: number;
+        origin: string;
+        backgroundImage: RefImage;
+
+        constructor() {
+            this.lastMessageId = 0;
+        }
+
+        send(msg: SimulatorMultiplayerMessage) {
+            Runtime.postMessage(<SimulatorMultiplayerMessage>{
+                ...msg,
+                broadcast: true,
+                toParentIFrameOnly: true,
+                type: "multiplayer",
+                origin: this.origin,
+                id: this.lastMessageId++
+            });
+        }
+
+        init(origin: string) {
+            this.origin = origin;
+            runtime.board.addMessageListener(msg => this.messageHandler(msg));
+            setInterval(() => {
+                if (this.origin === "server") {
+                    const b = board() as ScreenBoard;
+                    const screenState = b && b.screenState;
+                    const lastImage = screenState && screenState.lastImage;
+                    lastImage && pxsim.multiplayer.postImage(lastImage, "broadcast-screen");
+                }
+            }, 50);
+        }
+
+        setButton(key: number, isPressed: boolean) {
+            if (this.origin === "client") {
+                this.send(<pxsim.MultiplayerButtonEvent>{
+                    content: "Button",
+                    button: key,
+                    state: isPressed ? "Pressed" : "Released"
+                })
+            }
+        }
+
+        protected messageHandler(msg: SimulatorMessage) {
+            if (!isMultiplayerMessage(msg)) {
+                return;
+            }
+
+            if (isImageMessage(msg)) {
+                if (this.origin === "client") {
+                    // HACK: peer js can convert Uint8Array into ArrayBuffer when transmitting; fix this.
+                    if (!ArrayBuffer.isView(msg.image.data)) {
+                        msg.image.data = new Uint8Array(msg.image.data);
+                    }
+                    this.backgroundImage = pxsim.image.ofBuffer(msg.image);
+                }
+            } else if (isButtonMessage(msg)) {
+                if (this.origin === "server") {
+                    (board() as any).setButton(
+                        msg.button + (7 * (msg.clientNumber || 1)), // + 7 to make it player 2 controls,
+                        msg.state === "Pressed" || msg.state === "Held"
+                    );
+                }
+            }
+        }
+    }
+
+    function isMultiplayerMessage(msg: SimulatorMessage): msg is SimulatorMultiplayerMessage {
+        return msg && msg.type === "multiplayer";
+    }
+
+    function isImageMessage(msg: SimulatorMultiplayerMessage): msg is MultiplayerImageMessage {
+        return msg && msg.content === "Image";
+    }
+
+    function isButtonMessage(msg: SimulatorMultiplayerMessage): msg is MultiplayerButtonEvent {
+        return msg && msg.content === "Button";
+    }
+}

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___P48182(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___48425 = (undefined);
+    globals._pollEventQueue___48438 = (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___P48182.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
+_main___P48182.continuations = [  ]
 
-function _main___P48928_mk(s) {
+function _main___P48182_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P48928, depth: s.depth + 1,
+        parent: s, fn: _main___P48182, 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___P48182
 })

package/libs/light-spectrum-sensor/built/debug/binary.js

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P97400(s) {
+function _main___P96878(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___97643 = (undefined);
-    globals._pollEventQueue___97656 = (undefined);
+    globals._intervals___97121 = (undefined);
+    globals._pollEventQueue___97134 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P97400.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
-_main___P97400.continuations = [  ]
+_main___P96878.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
+_main___P96878.continuations = [  ]
 
-function _main___P97400_mk(s) {
+function _main___P96878_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P97400, depth: s.depth + 1,
+        parent: s, fn: _main___P96878, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P97400_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P97400
+return _main___P96878
 })

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

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P60230(s) {
+function _main___P59484(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___60473 = (undefined);
-    globals._pollEventQueue___60486 = (undefined);
+    globals._intervals___59727 = (undefined);
+    globals._pollEventQueue___59740 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P60230.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
-_main___P60230.continuations = [  ]
+_main___P59484.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"lora.ts","functionName":"<main>","argumentNames":[]}
+_main___P59484.continuations = [  ]
 
-function _main___P60230_mk(s) {
+function _main___P59484_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P60230, depth: s.depth + 1,
+        parent: s, fn: _main___P59484, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P60230_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P60230
+return _main___P59484
 })