perf: Circle search algorithm to replace bfs

Author: bibizu

src/core/execution/NukeExecution.ts

@@ -50,15 +50,14 @@ export class NukeExecution implements Execution {
     const tilesInRange = new Map<TileRef, number>();
     const magnitude = this.mg.config().nukeMagnitudes(this.nuke.type());
     const inner2 = magnitude.inner * magnitude.inner;
-    const outer2 = magnitude.outer * magnitude.outer;
-    this.mg.bfs(this.dst, (_, n: TileRef) => {
-      const d2 = this.mg?.euclideanDistSquared(this.dst, n) ?? 0;
-      if (d2 <= outer2) {
-        tilesInRange.set(n, d2 <= inner2 ? 1 : 0.5);
+    this.mg.circleSearch(
+      this.dst,
+      magnitude.outer,
+      (t: TileRef, d2: number) => {
+        tilesInRange.set(t, d2 <= inner2 ? 1 : 0.5);
         return true;
-      }
-      return false;
-    });
+      },
+    );
     return tilesInRange;
   }
 

src/core/game/GameImpl.ts

@@ -882,6 +882,13 @@ export class GameImpl implements Game {
   euclideanDistSquared(c1: TileRef, c2: TileRef): number {
     return this._map.euclideanDistSquared(c1, c2);
   }
+  circleSearch(
+    tile: TileRef,
+    radius: number,
+    filter?: (tile: TileRef, d2: number) => boolean,
+  ): Set<TileRef> {
+    return this._map.circleSearch(tile, radius, filter);
+  }
   bfs(
     tile: TileRef,
     filter: (gm: GameMap, tile: TileRef) => boolean,

src/core/game/GameMap.ts

@@ -39,6 +39,11 @@ export interface GameMap {
 
   manhattanDist(c1: TileRef, c2: TileRef): number;
   euclideanDistSquared(c1: TileRef, c2: TileRef): number;
+  circleSearch(
+    tile: TileRef,
+    radius: number,
+    filter?: (tile: TileRef, d2: number) => boolean,
+  ): Set<TileRef>;
   bfs(
     tile: TileRef,
     filter: (gm: GameMap, tile: TileRef) => boolean,
@@ -288,6 +293,25 @@ export class GameMapImpl implements GameMap {
     const y = this.y(c1) - this.y(c2);
     return x * x + y * y;
   }
+  circleSearch(
+    tile: TileRef,
+    radius: number,
+    filter?: (tile: TileRef, d2: number) => boolean,
+  ): Set<TileRef> {
+    const center = { x: this.x(tile), y: this.y(tile) };
+    const tiles: Set<TileRef> = new Set<TileRef>();
+    for (let i = center.x - radius; i <= center.x + radius; ++i) {
+      for (let j = center.y - radius; j <= center.y + radius; j++) {
+        const t = this.ref(i, j);
+        const d2 = this.euclideanDistSquared(tile, t);
+        if (d2 > radius * radius) continue;
+        if (!filter || filter(t, d2)) {
+          tiles.add(t);
+        }
+      }
+    }
+    return tiles;
+  }
   bfs(
     tile: TileRef,
     filter: (gm: GameMap, tile: TileRef) => boolean,

src/core/game/GameView.ts

@@ -762,6 +762,13 @@ export class GameView implements GameMap {
   euclideanDistSquared(c1: TileRef, c2: TileRef): number {
     return this._map.euclideanDistSquared(c1, c2);
   }
+  circleSearch(
+    tile: TileRef,
+    radius: number,
+    filter?: (tile: TileRef, d2: number) => boolean,
+  ): Set<TileRef> {
+    return this._map.circleSearch(tile, radius, filter);
+  }
   bfs(
     tile: TileRef,
     filter: (gm: GameMap, tile: TileRef) => boolean,