pxt-microbit 4.1.11 → 4.1.14

package/built/common-sim.d.ts

@@ -882,6 +882,8 @@ declare namespace pxsim.radio {
     function sendRawPacket(buf: RefBuffer): void;
     function readRawPacket(): RefBuffer;
     function onDataReceived(handler: RefAction): void;
+    function off(): void;
+    function on(): void;
 }
 declare namespace pxsim {
     interface RadioBoard extends EventBusBoard {
@@ -924,12 +926,15 @@ declare namespace pxsim {
         datagram: RadioDatagram;
         groupId: number;
         band: number;
+        enable: boolean;
         constructor(runtime: Runtime, board: BaseBoard, dal: RadioDAL);
         private handleMessage;
         setGroup(id: number): void;
         setTransmitPower(power: number): void;
         setTransmitSerialNumber(sn: boolean): void;
         setFrequencyBand(band: number): void;
+        off(): void;
+        on(): void;
         raiseEvent(id: number, eventid: number): void;
         receivePacket(packet: SimulatorRadioPacketMessage): void;
     }
@@ -1007,8 +1012,8 @@ declare namespace pxsim.ImageMethods {
     function _fillCircle(img: RefImage, cxy: number, r: number, c: number): void;
     function _blitRow(img: RefImage, xy: number, from: RefImage, xh: number): void;
     function blitRow(img: RefImage, x: number, y: number, from: RefImage, fromX: number, fromH: number): void;
-    function _blit(img: RefImage, src: RefImage, args: RefCollection): void;
-    function blit(dst: RefImage, src: RefImage, args: RefCollection): void;
+    function _blit(img: RefImage, src: RefImage, args: RefCollection): boolean;
+    function blit(dst: RefImage, src: RefImage, args: RefCollection): boolean;
 }
 declare namespace pxsim.image {
     function byteHeight(h: number, bpp: number): number;
@@ -1119,6 +1124,14 @@ declare namespace pxsim.input {
     function onSwitchMoved(direction: number, body: RefAction): void;
     function switchRight(): boolean;
 }
+declare namespace pxsim.tts {
+    function _getLanguageCode(): string;
+    function _speakAsync(text: string, pitch?: number, rate?: number, volume?: number, language?: string, onStart?: RefAction, onBoundary?: RefAction): Promise<void>;
+    function _pause(): void;
+    function _isPaused(): boolean;
+    function _resume(): void;
+    function _cancel(): void;
+}
 declare namespace pxsim {
     interface TemperatureBoard extends CommonBoard {
         thermometerState: AnalogSensorState;
@@ -1220,6 +1233,7 @@ declare namespace pxsim._wifi {
     export function socketClose(fd: int32): int32;
     export function eventID(): int32;
     export function scanStart(): void;
+    export function startLoginServer(): void;
     export function scanResults(): RefBuffer;
     export function connect(ssid: string, pass: string): int32;
     export function disconnect(): int32;

package/built/common-sim.js

@@ -3119,11 +3119,13 @@ var pxsim;
         function sendRawPacket(buf) {
             let cb = pxsim.getResume();
             const state = pxsim.getRadioState();
-            state.datagram.send({
-                type: 0,
-                groupId: state.groupId,
-                bufferData: buf.data
-            });
+            if (state.enable) {
+                state.datagram.send({
+                    type: 0,
+                    groupId: state.groupId,
+                    bufferData: buf.data
+                });
+            }
             setTimeout(cb, 1);
         }
         radio.sendRawPacket = sendRawPacket;
@@ -3147,6 +3149,16 @@ var pxsim;
             state.datagram.onReceived(handler);
         }
         radio.onDataReceived = onDataReceived;
+        function off() {
+            const state = pxsim.getRadioState();
+            state.off();
+        }
+        radio.off = off;
+        function on() {
+            const state = pxsim.getRadioState();
+            state.on();
+        }
+        radio.on = on;
     })(radio = pxsim.radio || (pxsim.radio = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
@@ -3215,6 +3227,7 @@ var pxsim;
             this.power = 6; // default value
             this.groupId = 0;
             this.band = 7; // https://github.com/lancaster-university/microbit-dal/blob/master/inc/core/MicroBitConfig.h#L320
+            this.enable = true;
             this.board.addMessageListener(this.handleMessage.bind(this));
         }
         handleMessage(msg) {
@@ -3224,34 +3237,51 @@ var pxsim;
             }
         }
         setGroup(id) {
-            this.groupId = id & 0xff; // byte only
+            if (this.enable) {
+                this.groupId = id & 0xff; // byte only
+            }
         }
         setTransmitPower(power) {
-            power = power | 0;
-            this.power = Math.max(0, Math.min(7, power));
+            if (this.enable) {
+                power = power | 0;
+                this.power = Math.max(0, Math.min(7, power));
+            }
         }
         setTransmitSerialNumber(sn) {
             this.transmitSerialNumber = !!sn;
         }
         setFrequencyBand(band) {
-            band = band | 0;
-            if (band < 0 || band > 83)
-                return;
-            this.band = band;
+            if (this.enable) {
+                band = band | 0;
+                if (band < 0 || band > 83)
+                    return;
+                this.band = band;
+            }
+        }
+        off() {
+            this.enable = false;
+        }
+        on() {
+            this.enable = true;
         }
         raiseEvent(id, eventid) {
-            pxsim.Runtime.postMessage({
-                type: "eventbus",
-                broadcast: true,
-                id,
-                eventid,
-                power: this.power,
-                group: this.groupId
-            });
+            if (this.enable) {
+                pxsim.Runtime.postMessage({
+                    type: "eventbus",
+                    broadcast: true,
+                    id,
+                    eventid,
+                    power: this.power,
+                    group: this.groupId
+                });
+            }
         }
         receivePacket(packet) {
-            if (this.groupId == packet.payload.groupId)
-                this.datagram.queue(packet);
+            if (this.enable) {
+                if (this.groupId == packet.payload.groupId) {
+                    this.datagram.queue(packet);
+                }
+            }
         }
     }
     pxsim.RadioState = RadioState;
@@ -3905,7 +3935,7 @@ var pxsim;
         }
         ImageMethods.blitRow = blitRow;
         function _blit(img, src, args) {
-            blit(img, src, args);
+            return blit(img, src, args);
         }
         ImageMethods._blit = _blit;
         function blit(dst, src, args) {
@@ -3918,6 +3948,7 @@ var pxsim;
             const wSrc = args.getAt(6);
             const hSrc = args.getAt(7);
             const transparent = args.getAt(8);
+            const check = args.getAt(9);
             const xSrcStep = ((wSrc << 16) / wDst) | 0;
             const ySrcStep = ((hSrc << 16) / hDst) | 0;
             const xDstClip = Math.abs(Math.min(0, xDst));
@@ -3930,16 +3961,26 @@ var pxsim;
             const ySrcStart = Math.max(0, (ySrc << 16) + yDstClip * ySrcStep);
             const xSrcEnd = Math.min(src._width, xSrc + wSrc) << 16;
             const ySrcEnd = Math.min(src._height, ySrc + hSrc) << 16;
+            if (!check)
+                dst.makeWritable();
             for (let yDstCur = yDstStart, ySrcCur = ySrcStart; yDstCur < yDstEnd && ySrcCur < ySrcEnd; ++yDstCur, ySrcCur += ySrcStep) {
                 const ySrcCurI = ySrcCur >> 16;
                 for (let xDstCur = xDstStart, xSrcCur = xSrcStart; xDstCur < xDstEnd && xSrcCur < xSrcEnd; ++xDstCur, xSrcCur += xSrcStep) {
                     const xSrcCurI = xSrcCur >> 16;
                     const cSrc = getPixel(src, xSrcCurI, ySrcCurI);
+                    if (check && cSrc) {
+                        const cDst = getPixel(dst, xDstCur, yDstCur);
+                        if (cDst) {
+                            return true;
+                        }
+                        continue;
+                    }
                     if (!transparent || cSrc) {
                         setPixel(dst, xDstCur, yDstCur, cSrc);
                     }
                 }
             }
+            return false;
         }
         ImageMethods.blit = blit;
     })(ImageMethods = pxsim.ImageMethods || (pxsim.ImageMethods = {}));
@@ -4568,6 +4609,80 @@ var pxsim;
     })(input = pxsim.input || (pxsim.input = {}));
 })(pxsim || (pxsim = {}));
 var pxsim;
+(function (pxsim) {
+    var tts;
+    (function (tts) {
+        function _getLanguageCode() {
+            return window.navigator.language;
+        }
+        tts._getLanguageCode = _getLanguageCode;
+        function _speakAsync(text, pitch, rate, volume, language, onStart, onBoundary) {
+            return new Promise((resolve, reject) => {
+                const utterance = new SpeechSynthesisUtterance(text);
+                utterance.voice = getVoiceForLanguage(language || _getLanguageCode());
+                if (pitch != undefined)
+                    utterance.pitch = pitch;
+                if (rate != undefined)
+                    utterance.rate = rate;
+                if (volume != undefined)
+                    utterance.volume = volume;
+                utterance.onend = () => resolve();
+                utterance.onerror = reject;
+                if (onStart) {
+                    utterance.onstart = () => pxsim.runtime.runFiberAsync(onStart);
+                }
+                if (onBoundary) {
+                    utterance.onboundary = event => {
+                        const offset = event.charIndex;
+                        const nextWord = text.substring(offset).split(/\s/).shift();
+                        pxsim.runtime.runFiberAsync(onBoundary, offset, nextWord, text);
+                    };
+                }
+                speechSynthesis.speak(utterance);
+            });
+        }
+        tts._speakAsync = _speakAsync;
+        function _pause() {
+            speechSynthesis.pause();
+        }
+        tts._pause = _pause;
+        function _isPaused() {
+            return speechSynthesis.paused;
+        }
+        tts._isPaused = _isPaused;
+        function _resume() {
+            speechSynthesis.resume();
+        }
+        tts._resume = _resume;
+        function _cancel() {
+            speechSynthesis.cancel();
+        }
+        tts._cancel = _cancel;
+        function getVoiceForLanguage(language) {
+            language = language.toLowerCase();
+            const generalCode = language.substring(0, 2);
+            let bestMatch;
+            let bestNonlocalMatch;
+            for (const voice of speechSynthesis.getVoices()) {
+                const current = voice.lang.toLowerCase();
+                if (current === language) {
+                    if (voice.localService)
+                        return voice;
+                    else
+                        bestNonlocalMatch = voice;
+                }
+                else if (current.substring(0, 2) === generalCode) {
+                    if (!bestMatch && voice.localService)
+                        bestMatch = voice;
+                    if (!bestNonlocalMatch && !voice.localService)
+                        bestNonlocalMatch = voice;
+                }
+            }
+            return bestMatch || bestNonlocalMatch || (language !== "en-us" ? getVoiceForLanguage("en-US") : undefined);
+        }
+    })(tts = pxsim.tts || (pxsim.tts = {}));
+})(pxsim || (pxsim = {}));
+var pxsim;
 (function (pxsim) {
     function thermometerState() {
         return pxsim.board().thermometerState;
@@ -4967,6 +5082,9 @@ var pxsim;
             _raiseEvent(1 /* ScanDone */);
         }
         _wifi.scanStart = scanStart;
+        function startLoginServer() {
+        }
+        _wifi.startLoginServer = startLoginServer;
         function scanResults() {
             const b = new Uint8Array(7);
             b[0] = -20; // rssi