From 8bf7f0f151a6b9d417457dc94d796405fc0cef55 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:47:15 -0800
Subject: [PATCH 01/13] improve errors

---
 src/mapgen.ts | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 6debb86..781d9db 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -99,6 +99,11 @@ export function generateMap(): LoadedNewMap {
       if (e instanceof TryAgainException) {
         continue;
       }
+      if (e instanceof BadMapError) {
+        console.log(`Bad map generated: ${e.message}:`);
+        showDebug(e.badMap);
+        continue;
+      }
       throw e;
     }
   }
@@ -108,7 +113,7 @@ export function tryGenerateMap(vaultTemplates: VaultTemplate[]): LoadedNewMap {
   let width = WIDTH;
   let height = HEIGHT;
   if (width % 2 == 0 || height % 2 == 0) {
-    throw "must be odd-sized";
+    throw new Error("map bounds must be odd-sized");
   }
 
   let grid = new LoadedNewMap("generated", new Size(width, height));
@@ -498,7 +503,7 @@ function connectRegions(knife: Knife) {
     let sources: number[] = dedup(basicRegions.map((i) => merged[i]));
     let dest: number | undefined = sources.pop();
     if (dest == undefined) {
-      throw "each connector should touch more than one region";
+      throw new BadMapError(`each connector should touch more than one region but ${connector} does not`, knife.map);
     }
 
     if (Math.random() > EXTRA_CONNECTOR_CHANCE) {
@@ -624,7 +629,7 @@ function decorateRoom(_map: LoadedNewMap, _rect: Rect) {}
 
 function randrange(lo: number, hi: number) {
   if (lo >= hi) {
-    throw `randrange: hi must be >= lo, ${hi}, ${lo}`;
+    throw new Error(`randrange: hi must be >= lo, ${hi}, ${lo}`);
   }
 
   return lo + Math.floor(Math.random() * (hi - lo));
@@ -658,3 +663,11 @@ function showDebug(grid: LoadedNewMap) {
 }
 
 class TryAgainException extends Error {}
+class BadMapError extends Error{
+  badMap: LoadedNewMap;
+
+  constructor(msg: string, badMap: LoadedNewMap) {
+    super(msg);
+    this.badMap = badMap;
+  }
+}
-- 
2.43.0


From 234a42b1e3b1f1fa0f0c40e38b3cbc8bd2f95da6 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:48:00 -0800
Subject: [PATCH 02/13] merge state debug dumper

---
 src/mapgen.ts | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 781d9db..259e477 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -89,6 +89,72 @@ class Knife {
       }
     }
   }
+
+  showDebug(merged: Record<number, number>) {
+    if (true) {
+      let out = "";
+      let errors: string[] = [];
+      const size = this.#regions.size;
+      for (let y = 0; y < size.h; y++) {
+        for (let x = 0; x < size.w; x++) {
+          const loc = new Point(x, y);
+          out += (() => {
+            if (this.#sealedWalls.get(loc)) {
+              return "█";
+            }
+            if (this.#map.get(loc).architecture == Architecture.Wall) {
+              return "#";
+            }
+            let r = this.#regions.get(loc);
+            if(typeof r === "number") {
+              const resolved = merged[r];
+              if (typeof resolved === "number") {
+                r = resolved;
+              } else {
+                errors.push(`${loc} is region ${r}, not found in merged`)
+              }
+              // 0...9 and lowercase
+              if (r < 36) {
+                return r.toString(36)
+              }
+              // uppercase
+              r -= 26;
+              if (r < 36) {
+                return r.toString(36).toUpperCase()
+              }
+              // Greek lowercase
+              r -= 36;
+              if (r < 25) {
+                return String.fromCodePoint(r + 0x3b1);
+              }
+              // Greek uppercase (there is a hole at 0x3a2)
+              r -= 25;
+              if (r < 17) {
+                return String.fromCodePoint(r + 0x391);
+              }
+              r -= 17;
+              if (r < 7) {
+                return String.fromCodePoint(r + 0x3a3);
+              }
+              // Hebrew
+              r -= 7
+              if (r < 27) {
+                return String.fromCodePoint(r+0x5d0);
+              }
+              // give up
+              return "?"
+            }
+            return ".";  // room without region
+          })();
+        }
+        out += "\n";
+      }
+      console.log(out);
+      if (errors.length > 0) {
+        console.log(`uh-oh: \n\t${errors.join("\n\t")}`);
+      }
+    }
+  }
 }
 
 export function generateMap(): LoadedNewMap {
-- 
2.43.0


From 898a93d8e576bf30c49e6d303b41bc61919fb3a4 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:48:52 -0800
Subject: [PATCH 03/13] use detailed debugging in map gen

---
 src/mapgen.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 259e477..446be55 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -555,7 +555,7 @@ function connectRegions(knife: Knife) {
       );
     }
     iter++;
-    showDebug(knife.map);
+    knife.showDebug(merged);
     if (connectors.length == 0) {
       throw new TryAgainException(
         "couldn't figure out how to connect sections",
-- 
2.43.0


From ba151a76fda684101c8d6f7270e1885defd9c8a3 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:55:00 -0800
Subject: [PATCH 04/13] more distinct wall chars

---
 src/mapgen.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 446be55..cb1ebf6 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -103,7 +103,7 @@ class Knife {
               return "█";
             }
             if (this.#map.get(loc).architecture == Architecture.Wall) {
-              return "#";
+              return "▓";
             }
             let r = this.#regions.get(loc);
             if(typeof r === "number") {
-- 
2.43.0


From 4117608073db90fb891d1e4bd0ee35f5e0726a61 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:56:33 -0800
Subject: [PATCH 05/13] not all sealed walls are walls. okay

---
 src/mapgen.ts | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index cb1ebf6..abaed29 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -99,11 +99,8 @@ class Knife {
         for (let x = 0; x < size.w; x++) {
           const loc = new Point(x, y);
           out += (() => {
-            if (this.#sealedWalls.get(loc)) {
-              return "█";
-            }
             if (this.#map.get(loc).architecture == Architecture.Wall) {
-              return "▓";
+              return this.#sealedWalls.get(loc) ? "█" : "▓";
             }
             let r = this.#regions.get(loc);
             if(typeof r === "number") {
-- 
2.43.0


From 764d1e4892984ead6774bbcbd035cc6e0f5f6bfa Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 19:59:04 -0800
Subject: [PATCH 06/13] handle negative region IDs

also catches some missed semis
---
 src/mapgen.ts | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index abaed29..9ac1dfb 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -110,14 +110,17 @@ class Knife {
               } else {
                 errors.push(`${loc} is region ${r}, not found in merged`)
               }
+              if (r < 0) {
+                return "!";
+              }
               // 0...9 and lowercase
               if (r < 36) {
-                return r.toString(36)
+                return r.toString(36);
               }
               // uppercase
               r -= 26;
               if (r < 36) {
-                return r.toString(36).toUpperCase()
+                return r.toString(36).toUpperCase();
               }
               // Greek lowercase
               r -= 36;
@@ -134,12 +137,12 @@ class Knife {
                 return String.fromCodePoint(r + 0x3a3);
               }
               // Hebrew
-              r -= 7
+              r -= 7;
               if (r < 27) {
                 return String.fromCodePoint(r+0x5d0);
               }
               // give up
-              return "?"
+              return "?";
             }
             return ".";  // room without region
           })();
-- 
2.43.0


From b302538adef9d5572c146d2d3ebe2548a7a4c4d6 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 20:05:34 -0800
Subject: [PATCH 07/13] stop using the "dark shade" character for standard
 walls

now uses inverse bullet for sealed walls and full block otherwise
---
 src/mapgen.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 9ac1dfb..dc5b986 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -100,7 +100,7 @@ class Knife {
           const loc = new Point(x, y);
           out += (() => {
             if (this.#map.get(loc).architecture == Architecture.Wall) {
-              return this.#sealedWalls.get(loc) ? "█" : "▓";
+              return this.#sealedWalls.get(loc) ? "◘" : "█";
             }
             let r = this.#regions.get(loc);
             if(typeof r === "number") {
-- 
2.43.0


From e2aa4a3ee769e111c9db2b3de442aa620e834996 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 20:06:31 -0800
Subject: [PATCH 08/13] also show final result with region numbers

---
 src/mapgen.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index dc5b986..0b0f73c 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -603,6 +603,7 @@ function connectRegions(knife: Knife) {
     }
     connectors = connectors2;
   }
+  knife.showDebug(merged);
 }
 
 function growMaze(knife: Knife, start: Point) {
-- 
2.43.0


From 025b1c93335b6b454810ad195be35342a926491e Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 20:32:35 -0800
Subject: [PATCH 09/13] fix fencepost error when merging regions

---
 src/mapgen.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 0b0f73c..2b0d924 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -574,7 +574,7 @@ function connectRegions(knife: Knife) {
 
     if (Math.random() > EXTRA_CONNECTOR_CHANCE) {
       // at random, don't regard them as merged
-      for (let i = 0; i < knife.region; i++) {
+      for (let i = 0; i <= knife.region; i++) {
         if (sources.indexOf(merged[i]) != -1) {
           merged[i] = dest;
         }
-- 
2.43.0


From 0b7d447c5b0dbeb9f7d81a20eb1d81bb582f0ebc Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 21:09:11 -0800
Subject: [PATCH 10/13] map connectedness checker (floodfill)

---
 src/engine/datatypes.ts | 27 ++++++++++++++++++++-----
 src/newmap.ts           | 45 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 5 deletions(-)

diff --git a/src/engine/datatypes.ts b/src/engine/datatypes.ts
index 6b012c1..61f440c 100644
--- a/src/engine/datatypes.ts
+++ b/src/engine/datatypes.ts
@@ -111,6 +111,15 @@ export class Point {
     let dy = other.y - this.y;
     return Math.sqrt(dx * dx + dy * dy);
   }
+
+  neighbors() : Point[] {
+    return [
+      new Point(this.x, this.y-1),
+      new Point(this.x-1, this.y),
+      new Point(this.x, this.y+1),
+      new Point(this.x+1, this.y),
+    ];
+  }
 }
 
 export class Size {
@@ -264,19 +273,27 @@ export class Grid<T> {
     return new Grid(this.size, (xy) => cbCell(this.get(xy), xy));
   }
 
-  #checkPosition(position: Point) {
-    if (
-      position.x < 0 ||
+  #invalidPosition(position: Point) : boolean {
+    return position.x < 0 ||
       position.x >= this.size.w ||
       Math.floor(position.x) != position.x ||
       position.y < 0 ||
       position.y >= this.size.h ||
-      Math.floor(position.y) != position.y
-    ) {
+      Math.floor(position.y) != position.y;;
+  }
+  #checkPosition(position: Point) {
+    if (this.#invalidPosition(position)) {
       throw new Error(`invalid position for ${this.size}: ${position}`);
     }
   }
 
+  maybeGet(position: Point): T | null {
+    if (this.#invalidPosition(position)) {
+      return null;
+    }
+    return this.#data[position.y][position.x];
+  }
+
   get(position: Point): T {
     this.#checkPosition(position);
     return this.#data[position.y][position.x];
diff --git a/src/newmap.ts b/src/newmap.ts
index a8fc213..d97fdaf 100644
--- a/src/newmap.ts
+++ b/src/newmap.ts
@@ -105,6 +105,51 @@ export class LoadedNewMap {
   getZoneLabel(point: Point): string | null {
     return this.#zoneLabels.get(point);
   }
+
+  isConnected(): boolean {
+    const size = this.#size;
+    let reached = new Grid<boolean>(size, ()=>false);
+
+    // find starting location
+    const found: Point | null = (()=>{
+      for(let x = 0; x < size.w; x++) {
+        for(let y = 0; y < size.w; y++) {
+          const p = new Point(x, y)
+          if (this.#architecture.get(p) == Architecture.Floor) {
+            return p;
+          }
+        }
+      }
+      return null;
+    })();
+    if (found === null) {
+      // technically, all open floors on the map are indeed connected
+      return true
+    }
+
+    let stack : Point[] = [found];
+    reached.set(found, true);
+    while (stack.length > 0) {
+      const loc = stack.pop() as Point;
+      for (var p of loc.neighbors()) {
+        if ((this.#architecture.maybeGet(p) === Architecture.Floor) && !reached.get(p)) {
+          reached.set(p, true);
+          stack.push(p);
+        }
+      }
+    }
+
+    for(let x = 0; x < size.w; x++) {
+      for(let y = 0; y < size.w; y++) {
+        const p = new Point(x, y)
+        if (this.#architecture.get(p) == Architecture.Floor && !reached.get(p)) {
+          return false;
+        }
+      }
+    }
+
+    return true;
+  }
 }
 
 export class CellView {
-- 
2.43.0


From ec2e21c712e8fc32fbc42736f751de59da6d0642 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 21:11:24 -0800
Subject: [PATCH 11/13] check for connectedness in mapgen

---
 src/mapgen.ts | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/mapgen.ts b/src/mapgen.ts
index 2b0d924..bc1d004 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -168,7 +168,7 @@ export function generateMap(): LoadedNewMap {
       if (e instanceof BadMapError) {
         console.log(`Bad map generated: ${e.message}:`);
         showDebug(e.badMap);
-        continue;
+        // continue;
       }
       throw e;
     }
@@ -604,6 +604,11 @@ function connectRegions(knife: Knife) {
     connectors = connectors2;
   }
   knife.showDebug(merged);
+
+  // The map should now be fully connected.
+  if (!knife.map.isConnected()) {
+    throw new BadMapError("unconnected", knife.map);
+  }
 }
 
 function growMaze(knife: Knife, start: Point) {
-- 
2.43.0


From b4aa9329adc9a82ed4fd2cd7c50bc8ad0a3f72cb Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 21:36:55 -0800
Subject: [PATCH 12/13] add commented-out cheat and test buttons

looks like mapgen is now fixed. here are the buttons I used to test it
---
 src/hotbar.ts | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/src/hotbar.ts b/src/hotbar.ts
index 6c54b38..e396d7c 100644
--- a/src/hotbar.ts
+++ b/src/hotbar.ts
@@ -6,6 +6,8 @@ import { addButton } from "./button.ts";
 import { getPlayerProgress } from "./playerprogress.ts";
 import { getStateManager } from "./statemanager.ts";
 import { getCheckModal } from "./checkmodal.ts";
+//import { LadderPickup } from "./pickups.ts";
+// import { generateMap } from "./mapgen.ts";
 
 type Button = {
   label: string;
@@ -53,6 +55,32 @@ export class Hotbar {
       enabled: true,
       endorse: getPlayerProgress().getBlood() < 100,
     });
+    /*
+    buttons.push({
+      label:"Cheat",
+      cbClick: () => {
+       new LadderPickup().onClick();
+      },
+      enabled: true,
+      endorse: false,
+    })
+    buttons.push({
+      label:"Dig for bad maps",
+      cbClick: () => {
+        let i = 0;
+        try {
+          for(; i < 10000; i++) {
+            generateMap();
+          }
+        } catch(e) {
+          console.log(`Map gen failed after ${i} tries.`);
+        }
+        console.log("Ten thousand maps generated successfully.");
+      },
+      enabled: true,
+      endorse: true,
+    })
+    */
     return buttons;
   }
 
-- 
2.43.0


From 70c2fcc491d7a81993493a00f36b09d6a79e35e1 Mon Sep 17 00:00:00 2001
From: Kistaro Windrider <kistaro@gmail.com>
Date: Sat, 22 Feb 2025 21:39:45 -0800
Subject: [PATCH 13/13] autoformat code

---
 src/engine/datatypes.ts | 18 ++++++++++--------
 src/mapgen.ts           | 15 +++++++++------
 src/newmap.ts           | 30 ++++++++++++++++++------------
 3 files changed, 37 insertions(+), 26 deletions(-)

diff --git a/src/engine/datatypes.ts b/src/engine/datatypes.ts
index 61f440c..273e5e4 100644
--- a/src/engine/datatypes.ts
+++ b/src/engine/datatypes.ts
@@ -112,12 +112,12 @@ export class Point {
     return Math.sqrt(dx * dx + dy * dy);
   }
 
-  neighbors() : Point[] {
+  neighbors(): Point[] {
     return [
-      new Point(this.x, this.y-1),
-      new Point(this.x-1, this.y),
-      new Point(this.x, this.y+1),
-      new Point(this.x+1, this.y),
+      new Point(this.x, this.y - 1),
+      new Point(this.x - 1, this.y),
+      new Point(this.x, this.y + 1),
+      new Point(this.x + 1, this.y),
     ];
   }
 }
@@ -273,13 +273,15 @@ export class Grid<T> {
     return new Grid(this.size, (xy) => cbCell(this.get(xy), xy));
   }
 
-  #invalidPosition(position: Point) : boolean {
-    return position.x < 0 ||
+  #invalidPosition(position: Point): boolean {
+    return (
+      position.x < 0 ||
       position.x >= this.size.w ||
       Math.floor(position.x) != position.x ||
       position.y < 0 ||
       position.y >= this.size.h ||
-      Math.floor(position.y) != position.y;;
+      Math.floor(position.y) != position.y
+    );
   }
   #checkPosition(position: Point) {
     if (this.#invalidPosition(position)) {
diff --git a/src/mapgen.ts b/src/mapgen.ts
index bc1d004..c275a5e 100644
--- a/src/mapgen.ts
+++ b/src/mapgen.ts
@@ -103,12 +103,12 @@ class Knife {
               return this.#sealedWalls.get(loc) ? "◘" : "█";
             }
             let r = this.#regions.get(loc);
-            if(typeof r === "number") {
+            if (typeof r === "number") {
               const resolved = merged[r];
               if (typeof resolved === "number") {
                 r = resolved;
               } else {
-                errors.push(`${loc} is region ${r}, not found in merged`)
+                errors.push(`${loc} is region ${r}, not found in merged`);
               }
               if (r < 0) {
                 return "!";
@@ -139,12 +139,12 @@ class Knife {
               // Hebrew
               r -= 7;
               if (r < 27) {
-                return String.fromCodePoint(r+0x5d0);
+                return String.fromCodePoint(r + 0x5d0);
               }
               // give up
               return "?";
             }
-            return ".";  // room without region
+            return "."; // room without region
           })();
         }
         out += "\n";
@@ -569,7 +569,10 @@ function connectRegions(knife: Knife) {
     let sources: number[] = dedup(basicRegions.map((i) => merged[i]));
     let dest: number | undefined = sources.pop();
     if (dest == undefined) {
-      throw new BadMapError(`each connector should touch more than one region but ${connector} does not`, knife.map);
+      throw new BadMapError(
+        `each connector should touch more than one region but ${connector} does not`,
+        knife.map,
+      );
     }
 
     if (Math.random() > EXTRA_CONNECTOR_CHANCE) {
@@ -735,7 +738,7 @@ function showDebug(grid: LoadedNewMap) {
 }
 
 class TryAgainException extends Error {}
-class BadMapError extends Error{
+class BadMapError extends Error {
   badMap: LoadedNewMap;
 
   constructor(msg: string, badMap: LoadedNewMap) {
diff --git a/src/newmap.ts b/src/newmap.ts
index d97fdaf..0b667c8 100644
--- a/src/newmap.ts
+++ b/src/newmap.ts
@@ -108,13 +108,13 @@ export class LoadedNewMap {
 
   isConnected(): boolean {
     const size = this.#size;
-    let reached = new Grid<boolean>(size, ()=>false);
+    let reached = new Grid<boolean>(size, () => false);
 
     // find starting location
-    const found: Point | null = (()=>{
-      for(let x = 0; x < size.w; x++) {
-        for(let y = 0; y < size.w; y++) {
-          const p = new Point(x, y)
+    const found: Point | null = (() => {
+      for (let x = 0; x < size.w; x++) {
+        for (let y = 0; y < size.w; y++) {
+          const p = new Point(x, y);
           if (this.#architecture.get(p) == Architecture.Floor) {
             return p;
           }
@@ -124,25 +124,31 @@ export class LoadedNewMap {
     })();
     if (found === null) {
       // technically, all open floors on the map are indeed connected
-      return true
+      return true;
     }
 
-    let stack : Point[] = [found];
+    let stack: Point[] = [found];
     reached.set(found, true);
     while (stack.length > 0) {
       const loc = stack.pop() as Point;
       for (var p of loc.neighbors()) {
-        if ((this.#architecture.maybeGet(p) === Architecture.Floor) && !reached.get(p)) {
+        if (
+          this.#architecture.maybeGet(p) === Architecture.Floor &&
+          !reached.get(p)
+        ) {
           reached.set(p, true);
           stack.push(p);
         }
       }
     }
 
-    for(let x = 0; x < size.w; x++) {
-      for(let y = 0; y < size.w; y++) {
-        const p = new Point(x, y)
-        if (this.#architecture.get(p) == Architecture.Floor && !reached.get(p)) {
+    for (let x = 0; x < size.w; x++) {
+      for (let y = 0; y < size.w; y++) {
+        const p = new Point(x, y);
+        if (
+          this.#architecture.get(p) == Architecture.Floor &&
+          !reached.get(p)
+        ) {
           return false;
         }
       }
-- 
2.43.0