pxt-common-packages 9.5.6 → 9.5.9

package/built/common-sim.d.ts

@@ -728,6 +728,90 @@ declare namespace pxsim {
 }
 declare namespace pxsim.info {
 }
+declare namespace pxsim.keymap {
+    enum Key {
+        None = 0,
+        Left = 1,
+        Up = 2,
+        Right = 3,
+        Down = 4,
+        A = 5,
+        B = 6,
+        Menu = 7,
+        Screenshot = -1,
+        Gif = -2,
+        Reset = -3,
+        TogglePause = -4
+    }
+    function _setPlayerKeys(player: number, // player number is 1-based
+    up: number, down: number, left: number, right: number, A: number, B: number): void;
+    function _setSystemKeys(screenshot: number, gif: number, menu: number, reset: number): void;
+}
+declare namespace pxsim {
+    import Key = pxsim.keymap.Key;
+    interface KeymapBoard extends EventBusBoard {
+        keymapState: KeymapState;
+    }
+    function getKeymapState(): KeymapState;
+    class KeymapState {
+        keymap: {
+            [keyCode: number]: Key;
+        };
+        altmap: {
+            [keyCode: number]: Key;
+        };
+        mappings: {
+            [name: string]: number[];
+        };
+        constructor();
+        setPlayerKeys(player: number, // player number is 1-based
+        up: number, down: number, left: number, right: number, A: number, B: number): void;
+        setSystemKeys(screenshot: number, gif: number, menu: number, reset: number): void;
+        getKey(keyCode: number): Key;
+        private saveMap;
+        private clearMap;
+    }
+}
+declare namespace pxsim.multiplayer {
+    function postImage(im: pxsim.RefImage, goal: string): void;
+    function getCurrentImage(): pxsim.RefImage;
+    function setOrigin(origin: "client" | "server" | undefined): void;
+    function getOrigin(): string;
+}
+declare namespace pxsim {
+    interface MultiplayerBoard extends EventBusBoard {
+        multiplayerState: MultiplayerState;
+    }
+    function getMultiplayerState(): MultiplayerState;
+    interface SimulatorMultiplayerMessage extends SimulatorBroadcastMessage {
+        broadcast: true;
+        type: "multiplayer";
+        content: string;
+        origin?: "server" | "client";
+        clientNumber?: number;
+        id?: number;
+    }
+    interface MultiplayerImageMessage extends SimulatorMultiplayerMessage {
+        content: "Image";
+        goal: string;
+        image: RefImage;
+    }
+    interface MultiplayerButtonEvent extends SimulatorMultiplayerMessage {
+        content: "Button";
+        button: number;
+        state: "Pressed" | "Released" | "Held";
+    }
+    class MultiplayerState {
+        lastMessageId: number;
+        origin: string;
+        backgroundImage: RefImage;
+        constructor();
+        send(msg: SimulatorMultiplayerMessage): void;
+        init(origin: string): void;
+        setButton(key: number, isPressed: boolean): void;
+        protected messageHandler(msg: SimulatorMessage): void;
+    }
+}
 declare namespace pxsim.gamepad {
     function setButton(index: number, up: boolean): void;
     function move(index: number, x: number, y: number): void;

package/built/common-sim.js

@@ -699,7 +699,7 @@ var pxsim;
 var pxsim;
 (function (pxsim) {
     function board() {
-        return pxsim.runtime.board;
+        return pxsim.runtime && pxsim.runtime.board;
     }
     pxsim.board = board;
 })(pxsim || (pxsim = {}));
@@ -2395,6 +2395,237 @@ var pxsim;
     pxsim.ToggleState = ToggleState;
 })(pxsim || (pxsim = {}));
 var pxsim;
+(function (pxsim) {
+    var keymap;
+    (function (keymap) {
+        // Keep in sync with pxt-arcade-sim/api.ts
+        let Key;
+        (function (Key) {
+            Key[Key["None"] = 0] = "None";
+            // Player 1
+            Key[Key["Left"] = 1] = "Left";
+            Key[Key["Up"] = 2] = "Up";
+            Key[Key["Right"] = 3] = "Right";
+            Key[Key["Down"] = 4] = "Down";
+            Key[Key["A"] = 5] = "A";
+            Key[Key["B"] = 6] = "B";
+            Key[Key["Menu"] = 7] = "Menu";
+            // Player 2 = Player 1 + 7
+            // Player 3 = Player 2 + 7
+            // Player 4 = Player 3 + 7
+            // system keys
+            Key[Key["Screenshot"] = -1] = "Screenshot";
+            Key[Key["Gif"] = -2] = "Gif";
+            Key[Key["Reset"] = -3] = "Reset";
+            Key[Key["TogglePause"] = -4] = "TogglePause";
+        })(Key = keymap.Key || (keymap.Key = {}));
+        function _setPlayerKeys(player, // player number is 1-based
+        up, down, left, right, A, B) {
+            pxsim.getKeymapState().setPlayerKeys(player, up, down, left, right, A, B);
+        }
+        keymap._setPlayerKeys = _setPlayerKeys;
+        function _setSystemKeys(screenshot, gif, menu, reset) {
+            pxsim.getKeymapState().setSystemKeys(screenshot, gif, menu, reset);
+        }
+        keymap._setSystemKeys = _setSystemKeys;
+    })(keymap = pxsim.keymap || (pxsim.keymap = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    var Key = pxsim.keymap.Key;
+    function getKeymapState() {
+        return pxsim.board().keymapState;
+    }
+    pxsim.getKeymapState = getKeymapState;
+    const reservedKeyCodes = [
+        27,
+        9 // Tab
+    ];
+    class KeymapState {
+        constructor() {
+            this.keymap = {};
+            this.altmap = {};
+            this.mappings = {};
+            // 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
+        }
+        setPlayerKeys(player, // player number is 1-based
+        up, down, left, right, A, B) {
+            // 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);
+        }
+        setSystemKeys(screenshot, gif, menu, reset) {
+            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]);
+        }
+        getKey(keyCode) {
+            return keyCode ? this.keymap[keyCode] || this.altmap[keyCode] || Key.None : Key.None;
+        }
+        saveMap(name, keyCodes) {
+            this.mappings[name] = keyCodes;
+        }
+        clearMap(name) {
+            const keyCodes = this.mappings[name];
+            keyCodes === null || keyCodes === void 0 ? void 0 : keyCodes.forEach(keyCode => delete this.keymap[keyCode]);
+            delete this.mappings[name];
+        }
+    }
+    pxsim.KeymapState = KeymapState;
+})(pxsim || (pxsim = {}));
+var pxsim;
+(function (pxsim) {
+    var multiplayer;
+    (function (multiplayer) {
+        function postImage(im, goal) {
+            const asBuf = pxsim.image.toBuffer(im);
+            pxsim.getMultiplayerState().send({
+                content: "Image",
+                image: asBuf,
+                goal
+            });
+        }
+        multiplayer.postImage = postImage;
+        function getCurrentImage() {
+            return pxsim.getMultiplayerState().backgroundImage;
+        }
+        multiplayer.getCurrentImage = getCurrentImage;
+        function setOrigin(origin) {
+            pxsim.getMultiplayerState().origin = origin;
+        }
+        multiplayer.setOrigin = setOrigin;
+        function getOrigin() {
+            return pxsim.getMultiplayerState().origin;
+        }
+        multiplayer.getOrigin = getOrigin;
+    })(multiplayer = pxsim.multiplayer || (pxsim.multiplayer = {}));
+})(pxsim || (pxsim = {}));
+(function (pxsim) {
+    function getMultiplayerState() {
+        return pxsim.board().multiplayerState;
+    }
+    pxsim.getMultiplayerState = getMultiplayerState;
+    class MultiplayerState {
+        constructor() {
+            this.lastMessageId = 0;
+        }
+        send(msg) {
+            pxsim.Runtime.postMessage(Object.assign(Object.assign({}, msg), { broadcast: true, toParentIFrameOnly: true, type: "multiplayer", origin: this.origin, id: this.lastMessageId++ }));
+        }
+        init(origin) {
+            this.origin = origin;
+            pxsim.runtime.board.addMessageListener(msg => this.messageHandler(msg));
+            setInterval(() => {
+                if (this.origin === "server") {
+                    const b = pxsim.board();
+                    const screenState = b && b.screenState;
+                    const lastImage = screenState && screenState.lastImage;
+                    lastImage && pxsim.multiplayer.postImage(lastImage, "broadcast-screen");
+                }
+            }, 50);
+        }
+        setButton(key, isPressed) {
+            if (this.origin === "client") {
+                this.send({
+                    content: "Button",
+                    button: key,
+                    state: isPressed ? "Pressed" : "Released"
+                });
+            }
+        }
+        messageHandler(msg) {
+            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") {
+                    pxsim.board().setButton(msg.button + (7 * (msg.clientNumber || 1)), // + 7 to make it player 2 controls,
+                    msg.state === "Pressed" || msg.state === "Held");
+                }
+            }
+        }
+    }
+    pxsim.MultiplayerState = MultiplayerState;
+    function isMultiplayerMessage(msg) {
+        return msg && msg.type === "multiplayer";
+    }
+    function isImageMessage(msg) {
+        return msg && msg.content === "Image";
+    }
+    function isButtonMessage(msg) {
+        return msg && msg.content === "Button";
+    }
+})(pxsim || (pxsim = {}));
+var pxsim;
 (function (pxsim) {
     var gamepad;
     (function (gamepad) {