pxt-microbit 4.1.28 → 4.1.31

package/built/common-sim.d.ts

@@ -728,6 +728,46 @@ declare namespace pxsim {
 }
 declare namespace pxsim.info {
 }
+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,98 @@ var pxsim;
     pxsim.ToggleState = ToggleState;
 })(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) {

package/built/editor.js

@@ -3167,6 +3167,7 @@ class DAPWrapper {
         this.pageSize = 1024;
         this.numPages = 256;
         this.usesCODAL = false;
+        this.jacdacInHex = false;
         this.forceFullFlash = /webusbfullflash=1/.test(window.location.href);
         this.onSerial = (buf, isStderr) => { };
         this.onCustomEvent = (type, payload) => { };
@@ -3186,7 +3187,7 @@ class DAPWrapper {
         this.allocDAP();
     }
     get useJACDAC() {
-        return this.usesCODAL;
+        return this.jacdacInHex && this.usesCODAL;
     }
     processSerialLine(line) {
         if (this.onSerial) {
@@ -3321,6 +3322,7 @@ class DAPWrapper {
         const binVersion = stringResponse(r);
         log(`bin name: ${this.binName} v:${binVersion}`);
         pxt.tickEvent("hid.flash.connect", { codal: this.usesCODAL ? 1 : 0, daplink: daplinkVersion, bin: binVersion });
+        // set baud rate
         const baud = new Uint8Array(5);
         baud[0] = 0x82; // set baud
         pxt.HF2.write32(baud, 1, 115200);
@@ -3329,6 +3331,7 @@ class DAPWrapper {
         await pxt.Util.delay(200);
         // only init after setting baud rate, in case we got reset
         await this.cortexM.init();
+        await this.cortexM.reset(true);
         const res = await this.readWords(0x10000010, 2);
         this.pageSize = res[0];
         this.numPages = res[1];
@@ -3362,9 +3365,13 @@ class DAPWrapper {
             .then(() => this.io.disconnectAsync());
     }
     reflashAsync(resp) {
+        var _a, _b;
+        pxt.tickEvent("hid.flash.start");
         log("reflash");
         startTime = 0;
-        pxt.tickEvent("hid.flash.start");
+        const codalJson = resp.outfiles["codal.json"];
+        // JACDAC_WEBUSB is defined in microsoft/pxt-jacdac/pxt.json
+        this.jacdacInHex = codalJson && !!((_b = (_a = pxt.Util.jsonTryParse(codalJson)) === null || _a === void 0 ? void 0 : _a.definitions) === null || _b === void 0 ? void 0 : _b.JACDAC_WEBUSB);
         this.flashAborted = false;
         this.flashing = true;
         return (this.io.isConnected() ? Promise.resolve() : this.io.reconnectAsync())
@@ -3721,8 +3728,17 @@ class DAPWrapper {
             log(`jacdac: disabled`);
             return;
         }
-        await pxt.Util.delay(700); // wait for the program to start and setup memory correctly
-        const xchg = await this.findJacdacXchgAddr();
+        // allow jacdac to boot
+        const now = pxt.U.now();
+        await pxt.Util.delay(1000);
+        let xchgRetry = 0;
+        let xchg;
+        while (xchg == null && xchgRetry++ < 2) {
+            log(`jacdac: finding xchg address (retry ${xchgRetry})`);
+            await pxt.Util.delay(100); // wait for the program to start and setup memory correctly
+            xchg = await this.findJacdacXchgAddr();
+        }
+        log(`jacdac: exchange address 0x${xchg ? xchg.toString(16) : "?"}; ${xchgRetry} retries; ${(pxt.U.now() - now) | 0}ms`);
         if (xchg == null) {
             log("jacdac: xchg address not found");
             pxt.tickEvent("hid.flash.jacdac.error.missingxchg");