pxt-microbit 5.1.3 → 5.1.5

package/built/common-sim.d.ts

@@ -773,7 +773,8 @@ declare namespace pxsim {
     }
 }
 declare namespace pxsim.multiplayer {
-    function postImage(im: pxsim.RefImage, goal: string): void;
+    function postImage(im: pxsim.RefImage): void;
+    function postIcon(iconType: IconType, slot: number, im: pxsim.RefImage): void;
     function getCurrentImage(): pxsim.RefImage;
     function setOrigin(origin: "client" | "server" | undefined): void;
     function getOrigin(): string;
@@ -793,14 +794,35 @@ declare namespace pxsim {
     }
     interface MultiplayerImageMessage extends SimulatorMultiplayerMessage {
         content: "Image";
-        goal: string;
-        image: RefImage;
+        image: RefBuffer;
+        palette: Uint8Array;
+    }
+    enum IconType {
+        Player = 0,
+        Reaction = 1
+    }
+    interface MultiplayerIconMessage extends SimulatorMultiplayerMessage {
+        content: "Icon";
+        icon: RefBuffer;
+        slot: number;
+        iconType: IconType;
+        palette: Uint8Array;
     }
     interface MultiplayerButtonEvent extends SimulatorMultiplayerMessage {
         content: "Button";
         button: number;
         state: "Pressed" | "Released" | "Held";
     }
+    interface MultiplayerAudioEvent extends SimulatorMultiplayerMessage {
+        content: "Audio";
+        instruction: "playinstructions" | "muteallchannels";
+        soundbuf?: Uint8Array;
+    }
+    interface MultiplayerConnectionEvent extends SimulatorMultiplayerMessage {
+        content: "Connection";
+        slot: number;
+        connected: boolean;
+    }
     class MultiplayerState {
         lastMessageId: number;
         origin: string;
@@ -809,6 +831,7 @@ declare namespace pxsim {
         send(msg: SimulatorMultiplayerMessage): void;
         init(origin: string): void;
         setButton(key: number, isPressed: boolean): void;
+        registerConnectionState(player: number, connected: boolean): void;
         protected messageHandler(msg: SimulatorMessage): void;
     }
 }
@@ -924,6 +947,20 @@ declare namespace pxsim.music {
     function queuePlayInstructions(when: number, b: RefBuffer): void;
     function stopPlaying(): void;
     function forceOutput(mode: number): void;
+    const SEQUENCER_STOP_MESSAGE = 3243;
+    const SEQUENCER_TICK_MESSAGE = 3244;
+    const SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+    const SEQUENCER_LOOPED_MESSAGE = 3246;
+    function _createSequencer(): Promise<number>;
+    function _sequencerState(id: number): string;
+    function _sequencerCurrentTick(id: number): number;
+    function _sequencerPlaySong(id: number, song: RefBuffer, loop: boolean): void;
+    function _sequencerStop(id: number): void;
+    function _sequencerSetVolume(id: number, volume: number): void;
+    function _sequencerSetVolumeForAll(volume: number): void;
+    function _sequencerSetTrackVolume(id: number, trackIndex: number, volume: number): void;
+    function _sequencerSetDrumTrackVolume(id: number, trackIndex: number, drumIndex: number, volume: number): void;
+    function _sequencerDispose(id: number): void;
 }
 declare namespace pxsim.mouse {
     function setButton(button: number, down: boolean): void;
@@ -1131,6 +1168,8 @@ declare namespace pxsim {
         onChange: () => void;
         constructor(paletteSrc: string[], w?: number, h?: number);
         setScreenBrightness(b: number): void;
+        paletteToUint8Array(): Uint8Array;
+        setPaletteFromHtmlColors(src: string[]): void;
         setPalette(buf: RefBuffer): void;
         bpp(): 1 | 4;
         didChange(): boolean;
@@ -1166,8 +1205,8 @@ declare namespace pxsim.visuals {
     }
 }
 declare namespace pxsim.settings {
-    function _set(key: string, buf: RefBuffer): -1 | 0;
-    function _remove(key: string): -1 | 0;
+    function _set(key: string, buf: RefBuffer): 0 | -1;
+    function _remove(key: string): 0 | -1;
     function _exists(key: string): boolean;
     function _get(key: string): RefBuffer;
     function _userClean(): void;

package/built/common-sim.js

@@ -2467,8 +2467,8 @@ var pxsim;
             // System keymap
             this.setSystemKeys(80, // P - Screenshot
             82, // R - Gif
-            0, // Menu - not mapped
-            0 // Reset - not mapped
+            192, // Menu - '`' (backtick) button
+            8 // Reset - Backspace button
             );
             // Player 1 alternate mapping. This is cleared when the game sets any player keys explicitly
             this.altmap[38] = Key.Up; // UpArrow
@@ -2527,7 +2527,7 @@ var pxsim;
         }
         clearMap(name) {
             const keyCodes = this.mappings[name];
-            keyCodes === null || keyCodes === void 0 ? void 0 : keyCodes.forEach(keyCode => delete this.keymap[keyCode]);
+            keyCodes && keyCodes.forEach(keyCode => delete this.keymap[keyCode]);
             delete this.mappings[name];
         }
     }
@@ -2537,15 +2537,41 @@ var pxsim;
 (function (pxsim) {
     var multiplayer;
     (function (multiplayer) {
-        function postImage(im, goal) {
+        const throttledImgPost = pxsim.U.throttle((msg) => {
+            pxsim.getMultiplayerState().send(msg);
+        }, 50, true);
+        function postImage(im) {
+            if (pxsim.getMultiplayerState().origin !== "server")
+                return;
             const asBuf = pxsim.image.toBuffer(im);
-            pxsim.getMultiplayerState().send({
+            const sb = pxsim.board();
+            const screenState = sb && sb.screenState;
+            throttledImgPost({
                 content: "Image",
                 image: asBuf,
-                goal
+                palette: screenState && screenState.paletteToUint8Array(),
             });
         }
         multiplayer.postImage = postImage;
+        function postIcon(iconType, slot, im) {
+            if (im && (im._width * im._height > 64 * 64)) {
+                // setting 64x64 as max size for icon for now
+                return;
+            }
+            // treat empty icon as undefined
+            const asBuf = (im && im.data.some(pixel => pixel != 0))
+                ? pxsim.image.toBuffer(im) : undefined;
+            const sb = pxsim.board();
+            const screenState = sb && sb.screenState;
+            pxsim.getMultiplayerState().send({
+                content: "Icon",
+                slot: slot,
+                icon: asBuf,
+                iconType: iconType,
+                palette: screenState.paletteToUint8Array(),
+            });
+        }
+        multiplayer.postIcon = postIcon;
         function getCurrentImage() {
             return pxsim.getMultiplayerState().backgroundImage;
         }
@@ -2565,6 +2591,13 @@ var pxsim;
         return pxsim.board().multiplayerState;
     }
     pxsim.getMultiplayerState = getMultiplayerState;
+    let IconType;
+    (function (IconType) {
+        IconType[IconType["Player"] = 0] = "Player";
+        IconType[IconType["Reaction"] = 1] = "Reaction";
+    })(IconType = pxsim.IconType || (pxsim.IconType = {}));
+    const MULTIPLAYER_PLAYER_JOINED_ID = 3241;
+    const MULTIPLAYER_PLAYER_LEFT_ID = 3242;
     class MultiplayerState {
         constructor() {
             this.lastMessageId = 0;
@@ -2575,14 +2608,18 @@ var pxsim;
         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);
+            if (this.origin === "server") {
+                pxsim.AudioContextManager.soundEventCallback = (ev, data) => {
+                    this.send({
+                        content: "Audio",
+                        instruction: ev,
+                        soundbuf: data,
+                    });
+                };
+            }
+            else {
+                pxsim.AudioContextManager.soundEventCallback = undefined;
+            }
         }
         setButton(key, isPressed) {
             if (this.origin === "client") {
@@ -2593,6 +2630,11 @@ var pxsim;
                 });
             }
         }
+        registerConnectionState(player, connected) {
+            const evId = connected ? MULTIPLAYER_PLAYER_JOINED_ID : MULTIPLAYER_PLAYER_LEFT_ID;
+            const b = pxsim.board();
+            b.bus.queue(evId, player);
+        }
         messageHandler(msg) {
             if (!isMultiplayerMessage(msg)) {
                 return;
@@ -2604,14 +2646,31 @@ var pxsim;
                         msg.image.data = new Uint8Array(msg.image.data);
                     }
                     this.backgroundImage = pxsim.image.ofBuffer(msg.image);
+                    if (msg.palette && msg.palette.length === 48) {
+                        const palBuffer = new pxsim.RefBuffer(msg.palette);
+                        pxsim.pxtcore.setPalette(palBuffer);
+                    }
                 }
             }
             else if (isButtonMessage(msg)) {
                 if (this.origin === "server") {
-                    pxsim.board().setButton(msg.button + (7 * (msg.clientNumber || 1)), // + 7 to make it player 2 controls,
+                    pxsim.board().handleKeyEvent(msg.button + (7 * (msg.clientNumber || 1)), // + 7 to make it player 2 controls,
                     msg.state === "Pressed" || msg.state === "Held");
                 }
             }
+            else if (isAudioMessage(msg)) {
+                if (this.origin === "client") {
+                    if (msg.instruction === "playinstructions") {
+                        pxsim.AudioContextManager.playInstructionsAsync(msg.soundbuf);
+                    }
+                    else if (msg.instruction === "muteallchannels") {
+                        pxsim.AudioContextManager.muteAllChannels();
+                    }
+                }
+            }
+            else if (isConnectionMessage(msg)) {
+                this.registerConnectionState(msg.slot, msg.connected);
+            }
         }
     }
     pxsim.MultiplayerState = MultiplayerState;
@@ -2624,6 +2683,12 @@ var pxsim;
     function isButtonMessage(msg) {
         return msg && msg.content === "Button";
     }
+    function isAudioMessage(msg) {
+        return msg && msg.content === "Audio";
+    }
+    function isConnectionMessage(msg) {
+        return msg && msg.content === "Connection";
+    }
 })(pxsim || (pxsim = {}));
 var pxsim;
 (function (pxsim) {
@@ -3126,7 +3191,7 @@ var pxsim;
     var music;
     (function (music) {
         function playInstructions(b) {
-            return pxsim.AudioContextManager.playInstructionsAsync(b);
+            return pxsim.AudioContextManager.playInstructionsAsync(b.data);
         }
         music.playInstructions = playInstructions;
         function queuePlayInstructions(when, b) {
@@ -3135,10 +3200,108 @@ var pxsim;
         music.queuePlayInstructions = queuePlayInstructions;
         function stopPlaying() {
             pxsim.AudioContextManager.muteAllChannels();
+            if (sequencers) {
+                for (const seq of sequencers) {
+                    seq.sequencer.stop();
+                    seq.sequencer.dispose();
+                }
+            }
         }
         music.stopPlaying = stopPlaying;
         function forceOutput(mode) { }
         music.forceOutput = forceOutput;
+        music.SEQUENCER_STOP_MESSAGE = 3243;
+        music.SEQUENCER_TICK_MESSAGE = 3244;
+        music.SEQUENCER_STATE_CHANGE_MESSAGE = 3245;
+        music.SEQUENCER_LOOPED_MESSAGE = 3246;
+        let sequencers;
+        let nextSequencerId = 0;
+        async function _createSequencer() {
+            if (!sequencers) {
+                pxsim.AudioContextManager.onStopAll(() => {
+                    for (const seq of sequencers) {
+                        seq.sequencer.stop();
+                        seq.sequencer.dispose();
+                    }
+                    sequencers = [];
+                });
+                sequencers = [];
+            }
+            const res = {
+                id: nextSequencerId++,
+                sequencer: new music.Sequencer()
+            };
+            sequencers.push(res);
+            await res.sequencer.initAsync();
+            res.sequencer.addEventListener("stop", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_STOP_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("state-change", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_STATE_CHANGE_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("looped", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_LOOPED_MESSAGE, this.id);
+            });
+            res.sequencer.addEventListener("tick", () => {
+                pxsim.board().bus.queue(music.SEQUENCER_TICK_MESSAGE, this.id);
+            });
+            return res.id;
+        }
+        music._createSequencer = _createSequencer;
+        function _sequencerState(id) {
+            var _a;
+            return (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.state();
+        }
+        music._sequencerState = _sequencerState;
+        function _sequencerCurrentTick(id) {
+            var _a;
+            return (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.currentTick();
+        }
+        music._sequencerCurrentTick = _sequencerCurrentTick;
+        function _sequencerPlaySong(id, song, loop) {
+            var _a;
+            const decoded = music.decodeSong(song.data);
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.start(decoded, loop);
+        }
+        music._sequencerPlaySong = _sequencerPlaySong;
+        function _sequencerStop(id) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.stop();
+        }
+        music._sequencerStop = _sequencerStop;
+        function _sequencerSetVolume(id, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setVolume(volume);
+        }
+        music._sequencerSetVolume = _sequencerSetVolume;
+        function _sequencerSetVolumeForAll(volume) {
+            for (const seq of sequencers) {
+                seq.sequencer.setVolume(volume);
+            }
+        }
+        music._sequencerSetVolumeForAll = _sequencerSetVolumeForAll;
+        function _sequencerSetTrackVolume(id, trackIndex, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setTrackVolume(trackIndex, volume);
+        }
+        music._sequencerSetTrackVolume = _sequencerSetTrackVolume;
+        function _sequencerSetDrumTrackVolume(id, trackIndex, drumIndex, volume) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.setDrumTrackVolume(trackIndex, drumIndex, volume);
+        }
+        music._sequencerSetDrumTrackVolume = _sequencerSetDrumTrackVolume;
+        function _sequencerDispose(id) {
+            var _a;
+            (_a = lookupSequencer(id)) === null || _a === void 0 ? void 0 : _a.dispose();
+            sequencers = sequencers.filter(s => s.id !== id);
+        }
+        music._sequencerDispose = _sequencerDispose;
+        function lookupSequencer(id) {
+            for (const seq of sequencers)
+                if (seq.id === id)
+                    return seq.sequencer;
+            return undefined;
+        }
     })(music = pxsim.music || (pxsim.music = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
@@ -3706,7 +3869,7 @@ var pxsim;
             let hh = 0;
             while (len--) {
                 if (hh++ >= img._height) {
-                    hh = 0;
+                    hh = 1;
                     sp = ++x;
                 }
                 dst.data[dp++] = img.data[sp];
@@ -3724,7 +3887,7 @@ var pxsim;
             let hh = 0;
             while (len--) {
                 if (hh++ >= img._height) {
-                    hh = 0;
+                    hh = 1;
                     dp = ++x;
                 }
                 img.data[dp] = src.data[sp++];
@@ -4260,6 +4423,9 @@ var pxsim;
         }
         image.isValidImage = isValidImage;
         function create(w, h) {
+            // truncate decimal sizes
+            w |= 0;
+            h |= 0;
             return new pxsim.RefImage(w, h, pxsim.getScreenState().bpp());
         }
         image.create = create;
@@ -4419,7 +4585,6 @@ var pxsim;
 (function (pxsim) {
     function htmlColorToUint32(hexColor) {
         const ca = new Uint8ClampedArray(4);
-        const ui = new Uint32Array(ca.buffer);
         const v = parseInt(hexColor.replace(/#/, ""), 16);
         ca[0] = (v >> 16) & 0xff;
         ca[1] = (v >> 8) & 0xff;
@@ -4428,6 +4593,12 @@ var pxsim;
         // convert to uint32 using target endian
         return new Uint32Array(ca.buffer)[0];
     }
+    function UInt32ToRGB(col) {
+        const ui = new Uint32Array(1);
+        ui[0] = col;
+        const ca = new Uint8ClampedArray(ui.buffer);
+        return [ca[0], ca[1], ca[2]];
+    }
     class ScreenState {
         constructor(paletteSrc, w = 0, h = 0) {
             this.width = 0;
@@ -4439,9 +4610,7 @@ var pxsim;
             if (!paletteSrc)
                 paletteSrc = ["#000000", "#ffffff"];
             this.palette = new Uint32Array(paletteSrc.length);
-            for (let i = 0; i < this.palette.length; ++i) {
-                this.palette[i] = htmlColorToUint32(paletteSrc[i]);
-            }
+            this.setPaletteFromHtmlColors(paletteSrc);
             if (w) {
                 this.width = w;
                 this.height = h;
@@ -4452,6 +4621,22 @@ var pxsim;
         setScreenBrightness(b) {
             this.brightness = b | 0;
         }
+        paletteToUint8Array() {
+            const out = new Uint8Array(this.palette.length * 3);
+            for (let i = 0; i < this.palette.length; ++i) {
+                const [r, g, b] = UInt32ToRGB(this.palette[i]);
+                const s = 3 * i;
+                out[s] = r;
+                out[s + 1] = g;
+                out[s + 2] = b;
+            }
+            return out;
+        }
+        setPaletteFromHtmlColors(src) {
+            for (let i = 0; i < this.palette.length; ++i) {
+                this.palette[i] = htmlColorToUint32(src[i]);
+            }
+        }
         setPalette(buf) {
             const ca = new Uint8ClampedArray(4);
             const rd = new Uint32Array(ca.buffer);

package/built/editor.js

@@ -3373,7 +3373,18 @@ class DAPWrapper {
     isConnecting() {
         return this.io.isConnecting() || (this.io.isConnected() && !this.initialized);
     }
+    async getBaudRate() {
+        const readSerialSettings = new Uint8Array([0x81]); // get serial settings
+        const serialSettings = await this.dapCmd(readSerialSettings);
+        const baud = (serialSettings[4] << 24) + (serialSettings[3] << 16) + (serialSettings[2] << 8) + serialSettings[1];
+        return baud;
+    }
     async setBaudRate() {
+        const currentBaudRate = await this.getBaudRate();
+        if (currentBaudRate === 115200) {
+            log(`baud rate already set to 115200`);
+            return;
+        }
         log(`set baud rate to 115200`);
         const baud = new Uint8Array(5);
         baud[0] = 0x82; // set baud