pxt-common-packages 9.4.1 → 9.4.5

package/libs/game/sprites.ts

@@ -72,6 +72,22 @@ namespace sprites {
         else return spritesByKind[kind].sprites();
     }
 
+    /**
+     * Destroys all sprites of the given kind.
+     */
+    //% group="Effects"
+    //% weight=79
+    //% blockId=sprites_destroy_all_sprites_of_kind
+    //% block="destroy all sprites of kind $kind || with $effect effect for $duration ms"
+    //% kind.shadow=spritekind
+    //% duration.shadow=timePicker
+    //% expandableArgumentMode="toggle"
+    export function destroyAllSpritesOfKind(kind: number, effect?: effects.ParticleEffect, duration?: number) {
+        for (const sprite of allOfKind(kind)) {
+            sprite.destroy(effect, duration);
+        }
+    }
+
     /**
      * Create a new sprite with a given speed, and place it at the edge of the screen so it moves towards the middle.
      * The sprite auto-destroys when it leaves the screen. You can modify position after it's created.

package/libs/game/spritesay.ts

@@ -17,6 +17,206 @@ namespace sprites {
     }
 
     export class SpriteSayRenderer extends BaseSpriteSayRenderer {
+        static drawSayFrame(textLeft: number, textTop: number, textWidth: number, textHeight: number, speakerX: number, speakerY: number, color: number, canvas: Image) {
+            if (textLeft + textWidth < 0 || textTop + textHeight < 0 || textLeft > canvas.width || textTop > canvas.height) return;
+
+            if (textHeight) {
+                // Draw main rectangle
+                canvas.fillRect(
+                    textLeft,
+                    textTop,
+                    textWidth,
+                    textHeight,
+                    color
+                );
+
+                // Draw lines around the rectangle to give it a bubble shape
+                canvas.fillRect(
+                    textLeft - 1,
+                    textTop + 1,
+                    1,
+                    textHeight - 2,
+                    color
+                );
+                canvas.fillRect(
+                    textLeft + textWidth,
+                    textTop + 1,
+                    1,
+                    textHeight - 2,
+                    color
+                );
+                canvas.fillRect(
+                    textLeft + 1,
+                    textTop - 1,
+                    textWidth - 2,
+                    1,
+                    color
+                );
+                canvas.fillRect(
+                    textLeft + 1,
+                    textTop + textHeight,
+                    textWidth - 2,
+                    1,
+                    color
+                );
+
+                // If the speaker location is within the bubble, don't draw an arrow
+                if (speakerX > textLeft && speakerX < textLeft + textWidth && speakerY > textTop && speakerY < textTop + textHeight) return;
+
+                const xDiff = Math.max(
+                    Math.abs(speakerX - textLeft),
+                    Math.abs(speakerX - (textLeft + textWidth))
+                );
+
+                const yDiff = Math.max(
+                    Math.abs(speakerY - textHeight),
+                    Math.abs(speakerY - (textHeight + textHeight))
+                );
+
+                // Draw the arrow
+                if (xDiff > yDiff) {
+                    if (speakerX > textLeft + textWidth) {
+                        const anchorY = Math.max(Math.min(speakerY, textTop + textHeight - 4), textTop + 5);
+                        canvas.fillRect(
+                            textLeft + textWidth + 1,
+                            anchorY - 2,
+                            1,
+                            3,
+                            color
+                        );
+                        canvas.fillRect(
+                            textLeft + textWidth + 2,
+                            anchorY - 1,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerX < textLeft) {
+                        const anchorY = Math.max(Math.min(speakerY, textTop + textHeight - 4), textTop + 5);
+                        canvas.fillRect(
+                            textLeft - 2,
+                            anchorY - 2,
+                            1,
+                            3,
+                            color
+                        );
+                        canvas.fillRect(
+                            textLeft - 3,
+                            anchorY - 1,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerY > textTop + textHeight) {
+                        const anchorX = Math.max(Math.min(speakerX, textLeft + textWidth - 4), textLeft + 5);
+                        canvas.fillRect(
+                            anchorX - 2,
+                            textTop + textHeight + 1,
+                            3,
+                            1,
+                            color
+                        );
+                        canvas.fillRect(
+                            anchorX - 1,
+                            textTop + textHeight + 2,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerY < textTop) {
+                        const anchorX = Math.max(Math.min(speakerX, textLeft + textWidth - 4), textLeft + 5);
+                        canvas.fillRect(
+                            anchorX - 2,
+                            textTop - 2,
+                            3,
+                            1,
+                            color
+                        );
+                        canvas.fillRect(
+                            anchorX - 1,
+                            textTop - 3,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                }
+                else {
+                    if (speakerY > textTop + textHeight) {
+                        const anchorX = Math.max(Math.min(speakerX, textLeft + textWidth - 4), textLeft + 5);
+                        canvas.fillRect(
+                            anchorX - 2,
+                            textTop + textHeight + 1,
+                            3,
+                            1,
+                            color
+                        );
+                        canvas.fillRect(
+                            anchorX - 1,
+                            textTop + textHeight + 2,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerY < textTop) {
+                        const anchorX = Math.max(Math.min(speakerX, textLeft + textWidth - 4), textLeft + 5);
+                        canvas.fillRect(
+                            anchorX - 2,
+                            textTop - 2,
+                            3,
+                            1,
+                            color
+                        );
+                        canvas.fillRect(
+                            anchorX - 1,
+                            textTop - 3,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerX > textLeft + textWidth) {
+                        const anchorY = Math.max(Math.min(speakerY, textTop + textHeight - 4), textTop + 5);
+                        canvas.fillRect(
+                            textLeft + textWidth + 1,
+                            anchorY - 2,
+                            1,
+                            3,
+                            color
+                        );
+                        canvas.fillRect(
+                            textLeft + textWidth + 2,
+                            anchorY - 1,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                    else if (speakerX < textLeft) {
+                        const anchorY = Math.max(Math.min(speakerY, textTop + textHeight - 4), textTop + 5);
+                        canvas.fillRect(
+                            textLeft - 2,
+                            anchorY - 2,
+                            1,
+                            3,
+                            color
+                        );
+                        canvas.fillRect(
+                            textLeft - 3,
+                            anchorY - 1,
+                            1,
+                            1,
+                            color
+                        );
+                    }
+                }
+            }
+        }
+
         protected renderText: RenderText;
         protected animation: RenderTextAnimation;
 
@@ -45,62 +245,15 @@ namespace sprites {
             const t = Math.floor(owner.top - oy);
 
             const height = this.animation ? this.animation.currentHeight() : this.renderText.height;
-            const sayLeft = l + (owner.width >> 1) - (this.renderText.width >> 1);
+            const width = this.animation ? this.animation.currentWidth() : this.renderText.width;
+            const sayLeft = l + (owner.width >> 1) - (width >> 1);
             const sayTop =  t - height - 4;
 
+            if (sayLeft + width < 0 || sayTop + height < 0 || sayLeft > screen.width || sayTop > screen.height) return;
 
-            if (sayLeft + this.renderText.width < 0 || sayTop + height < 0 || sayLeft > screen.width || sayTop > screen.height) return;
+            SpriteSayRenderer.drawSayFrame(sayLeft, sayTop, width, height, owner.x, owner.y, this.bgColor, screen);
 
             if (height) {
-                screen.fillRect(
-                    sayLeft,
-                    sayTop,
-                    this.renderText.width,
-                    height,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft - 1,
-                    sayTop + 1,
-                    1,
-                    height - 2,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft + this.renderText.width,
-                    sayTop + 1,
-                    1,
-                    height - 2,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft + 1,
-                    sayTop - 1,
-                    this.renderText.width - 2,
-                    1,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft + 1,
-                    sayTop + height,
-                    this.renderText.width - 2,
-                    1,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft + (this.renderText.width >> 1) - 2,
-                    sayTop + height + 1,
-                    3,
-                    1,
-                    this.bgColor
-                );
-                screen.fillRect(
-                    sayLeft + (this.renderText.width >> 1) - 1,
-                    sayTop + height + 2,
-                    1,
-                    1,
-                    this.bgColor
-                );
                 if (this.animation) {
                     this.animation.draw(screen, sayLeft, sayTop, this.fgColor);
                 }

package/libs/game/tilemap.ts

@@ -6,45 +6,124 @@ enum TileScale {
     //% block="32x32"
     ThirtyTwo = 5
 }
+
 namespace tiles {
 
     /**
      * A (col, row) location in the tilemap
      **/
-    //% blockNamespace=scene color="#401255" blockGap=8
+    //% blockNamespace=scene color="#401255"
     export class Location {
         protected _row: number;
         protected _col: number;
-        protected tileMap: TileMap;
 
-        get col() {
+        constructor(col: number, row: number, map: TileMap) {
+            this._col = col;
+            this._row = row;
+        }
+
+        get tileMap() {
+            return game.currentScene().tileMap;
+        }
+
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="column"
+        //% weight=100
+        get column() {
             return this._col;
         }
 
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="row"
+        //% weight=100
         get row() {
             return this._row;
         }
 
-        constructor(col: number, row: number, map: TileMap) {
-            this._col = col;
-            this._row = row;
-            this.tileMap = map;
-        }
-
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="x"
+        //% weight=100
         get x(): number {
             const scale = this.tileMap.scale;
             return (this._col << scale) + (1 << (scale - 1));
         }
 
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="y"
+        //% weight=100
         get y(): number {
             const scale = this.tileMap.scale;
             return (this._row << scale) + (1 << (scale - 1));
         }
 
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="left"
+        //% weight=100
+        get left(): number {
+            return (this._col << this.tileMap.scale);
+        }
+
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="top"
+        //% weight=100
+        get top(): number {
+            return (this._row << this.tileMap.scale);
+        }
+
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="right"
+        //% weight=100
+        get right(): number {
+            return this.left + (1 << this.tileMap.scale);
+        }
+
+        //% group="Locations" blockSetVariable="location"
+        //% blockCombine block="bottom"
+        //% weight=100
+        get bottom(): number {
+            return this.top + (1 << this.tileMap.scale);
+        }
+
         get tileSet(): number {
             return this.tileMap.getTileIndex(this._col, this._row);
         }
 
+        // deprecated
+        get col() {
+            return this.column;
+        }
+
+        public isWall(): boolean {
+            return this.tileMap.isObstacle(this._col, this._row);
+        }
+
+        public getImage(): Image {
+            return this.tileMap.getTileImage(this.tileSet);
+        }
+
+        /**
+         * Returns the neighboring location in a specifc direction from a location in a tilemap
+         * @param direction The direction to fetch the location in
+         */
+        //% blockId=tiles_location_get_neighboring_location
+        //% block="tilemap location $direction of $this"
+        //% this.defl=location
+        //% this.shadow=variables_get
+        //% group="Locations" blockGap=8
+        //% weight=10
+        public getNeighboringLocation(direction: CollisionDirection): Location {
+            switch (direction) {
+                case CollisionDirection.Top:
+                    return this.tileMap.getTile(this._col, this._row - 1);
+                case CollisionDirection.Right:
+                    return this.tileMap.getTile(this._col + 1, this._row);
+                case CollisionDirection.Bottom:
+                    return this.tileMap.getTile(this._col, this._row + 1);
+                case CollisionDirection.Left:
+                    return this.tileMap.getTile(this._col - 1, this._row);
+            }
+        }
+
         /**
          * Center the given sprite on this tile
          * @param sprite
@@ -94,7 +173,7 @@ namespace tiles {
          * @param sprite
          */
         //% blockId=gameplaceontile block="on top of %tile(myTile) place %sprite=variables_get(mySprite)"
-        //% blockNamespace="scene" group="Tiles"
+        //% blockNamespace="scene" group="Tilemap Operations"
         //% weight=25
         //% help=tiles/place
         //% deprecated=1
@@ -465,9 +544,24 @@ namespace tiles {
     //% tilemap.fieldOptions.decompileArgumentAsString="true"
     //% tilemap.fieldOptions.filter="tile"
     //% tilemap.fieldOptions.taggedTemplate="tilemap"
-    //% blockNamespace="scene" group="Tiles" duplicateShadowOnDrag
-    //% help=tiles/set-tile-map
+    //% blockNamespace="scene" duplicateShadowOnDrag
+    //% help=scene/set-tilemap
+    //% deprecated=1
     export function setTilemap(tilemap: TileMapData) {
+        setCurrentTilemap(tilemap);
+    }
+
+    /**
+     * Sets the given tilemap to be the current active tilemap in the game
+     *
+     * @param tilemap The tilemap to set as the current tilemap
+     */
+    //% blockId=set_current_tilemap block="set tilemap to $tilemap"
+    //% weight=201 blockGap=8
+    //% tilemap.shadow=tiles_tilemap_editor
+    //% blockNamespace="scene" group="Tilemaps" duplicateShadowOnDrag
+    //% help=tiles/set-tile-map
+    export function setCurrentTilemap(tilemap: TileMapData) {
         scene.setTileMapLevel(tilemap);
     }
 
@@ -479,8 +573,9 @@ namespace tiles {
     //% blockId=mapsettileat block="set $tile at $loc=mapgettile"
     //% tile.shadow=tileset_tile_picker
     //% tile.decompileIndirectFixedInstances=true
-    //% blockNamespace="scene" group="Tiles" blockGap=8
-    //% help=tiles/set-tile-at
+    //% blockNamespace="scene" group="Tilemap Operations" blockGap=8
+    //% help=scene/set-tile-at
+    //% weight=70
     export function setTileAt(loc: Location, tile: Image): void {
         const scene = game.currentScene();
         if (!loc || !tile || !scene.tileMap) return null;
@@ -496,8 +591,9 @@ namespace tiles {
      */
     //% blockId=mapsetwallat block="set wall $on at $loc"
     //% on.shadow=toggleOnOff loc.shadow=mapgettile
-    //% blockNamespace="scene" group="Tiles" blockGap=8
-    //% help=tiles/set-wall-at
+    //% blockNamespace="scene" group="Tilemap Operations"
+    //% help=scene/set-wall-at
+    //% weight=60
     export function setWallAt(loc: Location, on: boolean): void {
         const scene = game.currentScene();
         if (!loc || !scene.tileMap) return null;
@@ -511,9 +607,9 @@ namespace tiles {
      * @param row
      */
     //% blockId=mapgettile block="tilemap col $col row $row"
-    //% blockNamespace="scene" group="Tiles"
-    //% weight=25 blockGap=8
-    //% help=tiles/get-tile-location
+    //% blockNamespace="scene" group="Locations"
+    //% weight=100 blockGap=8
+    //% help=scene/get-tile-location
     export function getTileLocation(col: number, row: number): Location {
         const scene = game.currentScene();
         if (col == undefined || row == undefined || !scene.tileMap) return null;
@@ -549,13 +645,45 @@ namespace tiles {
     //% blockId=maplocationistile block="tile at $location is $tile"
     //% location.shadow=mapgettile
     //% tile.shadow=tileset_tile_picker tile.decompileIndirectFixedInstances=true
-    //% blockNamespace="scene" group="Collisions" blockGap=8
+    //% blockNamespace="scene" group="Locations" blockGap=8
+    //% weight=40 help=scene/tile-at-location-equals
     export function tileAtLocationEquals(location: Location, tile: Image): boolean {
         const scene = game.currentScene();
         if (!location || !tile || !scene.tileMap) return false;
         return location.tileSet === scene.tileMap.getImageType(tile);
     }
 
+    /**
+     * Returns true if the tile at the given location is a wall in the current tilemap;
+     * otherwise returns false
+     * @param location The location to check for a wall
+     */
+    //% blockId=tiles_tile_at_location_is_wall
+    //% block="tile at $location is wall"
+    //% location.shadow=mapgettile
+    //% blockNamespace="scene" group="Locations" blockGap=8
+    //% weight=30
+    export function tileAtLocationIsWall(location: Location): boolean {
+        if (!location || !location.tileMap) return false;
+        return location.isWall();
+    }
+
+    /**
+     * Returns the image of the tile at the given location in the current tilemap
+     *
+     * @param location The location of the image to fetch
+     */
+    //% blockId=tiles_image_at_location
+    //% block="tile image at $location"
+    //% location.shadow=mapgettile
+    //% weight=0
+    //% blockNamespace="scene" group="Locations"
+    export function tileImageAtLocation(location: Location): Image {
+        const scene = game.currentScene();
+        if (!location || !scene.tileMap) return img``;
+        return location.getImage();
+    }
+
     /**
      * Center the given sprite on a given location
      * @param sprite
@@ -563,10 +691,11 @@ namespace tiles {
      */
     //% blockId=mapplaceontile block="place $sprite=variables_get(mySprite) on top of $loc"
     //% loc.shadow=mapgettile
-    //% blockNamespace="scene" group="Tiles" blockGap=8
-    //% help=tiles/place
+    //% blockNamespace="scene" group="Tilemap Operations" blockGap=8
+    //% help=scene/place
+    //% weight=100
     export function placeOnTile(sprite: Sprite, loc: Location): void {
-        if (!sprite || !loc || !game.currentScene().tileMap) return;
+        if (!sprite || !loc || !loc.tileMap) return;
         loc.place(sprite);
     }
 
@@ -578,8 +707,9 @@ namespace tiles {
     //% blockId=mapplaceonrandomtile block="place $sprite=variables_get(mySprite) on top of random $tile"
     //% tile.shadow=tileset_tile_picker
     //% tile.decompileIndirectFixedInstances=true
-    //% blockNamespace="scene" group="Tiles" blockGap=8
-    //% help=tiles/place-on-random-tile
+    //% blockNamespace="scene" group="Tilemap Operations"
+    //% help=scene/place-on-random-tile
+    //% weight=90
     export function placeOnRandomTile(sprite: Sprite, tile: Image): void {
         if (!sprite || !game.currentScene().tileMap) return;
         const loc = getRandomTileByType(tile);
@@ -594,8 +724,9 @@ namespace tiles {
     //% blockId=mapgettilestype block="array of all $tile locations"
     //% tile.shadow=tileset_tile_picker
     //% tile.decompileIndirectFixedInstances=true
-    //% blockNamespace="scene" group="Tiles" blockGap=8
-    //% help=tiles/get-tiles-by-type
+    //% blockNamespace="scene" group="Locations" blockGap=8
+    //% help=scene/get-tiles-by-type
+    //% weight=10
     export function getTilesByType(tile: Image): Location[] {
         const scene = game.currentScene();
         if (!tile || !scene.tileMap) return [];
@@ -615,4 +746,19 @@ namespace tiles {
         const sample = scene.tileMap.sampleTilesByType(index, 1);
         return sample[0];
     }
+
+    /**
+     * A tilemap
+     */
+    //% blockId=tiles_tilemap_editor shim=TD_ID
+    //% weight=200 blockGap=8
+    //% block="tilemap $tilemap"
+    //% tilemap.fieldEditor="tilemap"
+    //% tilemap.fieldOptions.decompileArgumentAsString="true"
+    //% tilemap.fieldOptions.filter="tile"
+    //% tilemap.fieldOptions.taggedTemplate="tilemap"
+    //% blockNamespace="scene" group="Tilemaps" duplicateShadowOnDrag
+    export function _tilemapEditor(tilemap: TileMapData): TileMapData {
+        return tilemap;
+    }
 }

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

@@ -56,7 +56,7 @@ const pxsim_pxtrt = pxsim.pxtrt;
 const pxsim_numops = pxsim.numops;
 
 
-function _main___P48394(s) {
+function _main___P48426(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___48635 = (undefined);
-    globals._pollEventQueue___48648 = (undefined);
+    globals._intervals___48667 = (undefined);
+    globals._pollEventQueue___48680 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P48394.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
-_main___P48394.continuations = [  ]
+_main___P48426.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"characterlcd.ts","functionName":"<main>","argumentNames":[]}
+_main___P48426.continuations = [  ]
 
-function _main___P48394_mk(s) {
+function _main___P48426_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P48394, depth: s.depth + 1,
+        parent: s, fn: _main___P48426, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P48394_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P48394
+return _main___P48426
 })

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___P95856(s) {
+function _main___P95952(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___96097 = (undefined);
-    globals._pollEventQueue___96110 = (undefined);
+    globals._intervals___96193 = (undefined);
+    globals._pollEventQueue___96206 = (undefined);
     r0 = undefined;
     return leave(s, r0)
   default: oops()
 } } }
-_main___P95856.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
-_main___P95856.continuations = [  ]
+_main___P95952.info = {"start":0,"length":0,"line":0,"column":0,"endLine":0,"endColumn":0,"fileName":"tsl2591.ts","functionName":"<main>","argumentNames":[]}
+_main___P95952.continuations = [  ]
 
-function _main___P95856_mk(s) {
+function _main___P95952_mk(s) {
     checkStack(s.depth);
     return {
-        parent: s, fn: _main___P95856, depth: s.depth + 1,
+        parent: s, fn: _main___P95952, depth: s.depth + 1,
         pc: 0, retval: undefined, r0: undefined, overwrittenPC: false, lambdaArgs: null,
 } }
 
@@ -88,5 +88,5 @@ function _main___P95856_mk(s) {
 
 const breakpoints = setupDebugger(1, [])
 
-return _main___P95856
+return _main___P95952
 })