Added LineType enum, diagonal line and line block

Author: johnjuuljensen

main.ts

@@ -24,11 +24,26 @@ let mySprite = sprites.create(img`
     ........................
     ........................
     ........................
-    `, SpriteKind.Player)
-    tiles.placeOnTile(mySprite, tiles.getTileLocation(2, 2))controller.moveSprite(mySprite)
-scene.cameraFollowSprite(mySprite)
+    `, SpriteKind.Player);
+tiles.placeOnTile(mySprite, tiles.getTileLocation(2, 2));
+controller.moveSprite(mySprite);
+scene.cameraFollowSprite(mySprite);
 for (let value of tilesExt.getRandomTilesByType(sprites.castle.tileGrass2, 10)) {
     tiles.setTileAt(value, sprites.dungeon.chestClosed)
 }
 //tilesExt.setTileBetweenLocations(new tiles.Location(0,0,undefined), new tiles.Location(5,6,undefined), sprites.builtin.brick);
+
+// tilesExt.line(
+//     LineType.Diagonal, 
+//     new tiles.Location(0,0,undefined), 
+//     new tiles.Location(7,5,undefined), 
+//     true, 
+//     (x,y) => tiles.setTileAt(new tiles.Location(x,y,undefined), sprites.builtin.brick));
+
+// tilesExt.line(
+//     LineType.Diagonal, 
+//     new tiles.Location(0,1,undefined), 
+//     new tiles.Location(7,6,undefined), 
+//     true, 
+//     (x,y) => tiles.setTileAt(new tiles.Location(x,y,undefined), sprites.builtin.brick));
 game.debug = true;

tilemapExt.ts

@@ -5,10 +5,59 @@ enum LineType {
 
 //% blockNamespace=scene
 namespace tilesExt {
+    import TL = tiles.Location;
 
+    /**
+     * Iterates over a line between two locations. If the handler returns Truelike, then the iteration is stopped
+     * and the handlers return value is returned, otherwise the iteration runs to completion and returns undefined.
+     * @param lineType width of maze
+     * @param l1 start
+     * @param l2 end
+     * @param exclusive exclude the endpoints
+     * @param handler a handler which is invoked for each point
+     * @returns undefined if the whole line was iterated
+     */
+    //% blickId=tilesExt_line
+    //% block="A $lineType line from $l1 to $l2 || exclusive $exclusive"
+    //% exclusive.defl=false
+    //% inlineInputMode=inline
     //% l1.shadow=mapgettile
     //% l2.shadow=mapgettile
-    export function coveringLineBetweenTiles<T>(l1: tiles.Location, l2: tiles.Location, exclusive: boolean, handler: (col: number, row: number) => T): T {
+    //% draggableParameters="reporter"
+    export function line<T>(lineType: LineType, l1: TL, l2: TL, exclusive: boolean, handler: (col: number, row: number) => T): T {
+        return lineType === LineType.Diagonal ? diagonalLine(l1,l2,exclusive,handler) :
+            lineType === LineType.Covering ? coveringLine(l1,l2,exclusive,handler) :
+            undefined;
+    }
+
+    function lerp(start: number, end: number, t: number) {
+        return start * (1.0 - t) + t * end;
+    }
+
+    function diagonalLine<T>(l1: TL, l2: TL, exclusive: boolean, handler: (col: number, row: number) => T): T {
+        const dx = l2.col-l1.col, dy = l2.row-l1.row;
+        const N = Math.max(Math.abs(dx), Math.abs(dy));
+        if (N <= 0) {
+            return exclusive ? undefined : handler(l1.col, l1.row);
+        } else {
+            const lastN = N  - (exclusive ? 1 : 0);
+            for (let step = (exclusive ? 1 : 0); step <= lastN; step++) {
+                let t = step / N;
+                const res = handler(
+                    Math.round(lerp(l1.col, l2.col, t)),
+                    Math.round(lerp(l1.row, l2.row, t))
+                    );
+                if (res) return res;
+            }
+        }
+
+        return undefined;
+    }
+  
+  
+    
+
+    export function coveringLine<T>(l1: TL, l2: TL, exclusive: boolean, handler: (col: number, row: number) => T): T {
         // https://www.redblobgames.com/grids/line-drawing/#stepping
         const dx = l2.col-l1.col, dy = l2.row-l1.row;
         const absx = Math.abs(dx), absy = Math.abs(dy);
@@ -45,16 +94,16 @@ namespace tilesExt {
         return undefined;
     }
 
-    export function isWallBetweenLocations(l1: tiles.Location, l2: tiles.Location, tileMap?: tiles.TileMap): tiles.Location | undefined {
+    export function isWallBetweenLocations(l1: TL, l2: TL, tileMap?: tiles.TileMap): TL | undefined {
         tileMap = tileMap || game.currentScene().tileMap;
-        return coveringLineBetweenTiles(l1, l2, true, (x,y) => tileMap.isObstacle(x,y) ? new tiles.Location(x,y,l1.tileMap) : undefined);
+        return coveringLine(l1, l2, true, (x,y) => tileMap.isObstacle(x,y) ? new TL(x,y,l1.tileMap) : undefined);
     }
 
 
-    export function setTileBetweenLocations(l1: tiles.Location, l2: tiles.Location, im: Image, tileMap?: tiles.TileMap): void {
+    export function setTileBetweenLocations(l1: TL, l2: TL, im: Image, tileMap?: tiles.TileMap): void {
         tileMap = tileMap || game.currentScene().tileMap;
         const index = tileMap.getImageType(im);
-        coveringLineBetweenTiles(l1, l2, false, (x,y) => tileMap.setTileAt(x,y,index));
+        coveringLine(l1, l2, false, (x,y) => tileMap.setTileAt(x,y,index));
     }
 
 
@@ -66,7 +115,7 @@ namespace tilesExt {
     //% group=Locations
     //% block="array of max $maxCount $tile locations"
     //% tile.shadow=tileset_tile_picker
-    export function getRandomTilesByType(tile: Image, maxCount: number): tiles.Location[] {
+    export function getRandomTilesByType(tile: Image, maxCount: number): TL[] {
         const scene = game.currentScene();
         if (!tile || !scene.tileMap)
             return undefined;