Vast improvement in the world generation, with more reliable pathing, cleaner generation code, and an ability to do a random or direct walk to create paths. This also works with enemies if I want.

map.cpp

@@ -1,5 +1,6 @@
 #include "map.hpp"
 #include "dbc.hpp"
+#include "rand.hpp"
 #include <vector>
 #include <array>
 #include <fmt/core.h>
@@ -8,11 +9,21 @@
 using std::vector, std::pair;
 using namespace fmt;
 
-void dump_map(const std::string &msg, Matrix &map) {
+void dump_map(const std::string &msg, Matrix &map, int show_x, int show_y) {
   println("----------------- {}", msg);
-  for(auto row : map) {
-    for(auto col : row) {
-      print("{} ", col);
+  for(size_t y = 0; y < map.size(); y++) {
+    for(size_t x = 0; x < map[y].size(); x++) {
+      int col = map[y][x];
+
+      if(int(x) == show_x && int(y) == show_y) {
+        print("{:x}<", col);
+      } else if(col == 1000) {
+        print("# ");
+      } else if(col > 15) {
+        print("* ");
+      } else {
+        print("{:x} ", col);
+      }
     }
     print("\n");
   }
@@ -62,8 +73,9 @@ bool Map::iswall(size_t x, size_t y) {
   return $walls[y][x] == WALL_VALUE;
 }
 
-void Map::dump() {
-  dump_map("WALLS", $walls);
+void Map::dump(int show_x, int show_y) {
+  dump_map("WALLS", walls(), show_x, show_y);
+  dump_map("PATHS", paths(), show_x, show_y);
 }
 
 bool Map::can_move(Point move_to) {
@@ -81,57 +93,99 @@ Point Map::center_camera(const Point &around, size_t view_x, size_t view_y) {
   int center_x = int(around.x - view_x / 2);
   int center_y = int(around.y - view_y / 2);
 
-  // BUG: is clamp really the best thing here? this seems wrong.
   size_t start_x = high_x > 0 ? std::clamp(center_x, 0, high_x) : 0;
   size_t start_y = high_y > 0 ? std::clamp(center_y, 0, high_y) : 0;
 
   return {start_x, start_y};
 }
 
-bool Map::neighbors(Point &out, bool greater) {
+/*
+ * Finds the next optimal neighbor in the path
+ * using either a direct or random method.
+ *
+ * Both modes will pick a random direction to start
+ * looking for the next path, then it goes clock-wise
+ * from there.
+ *
+ * In the direct method it will attempt to find
+ * a path that goes 1 lower in the dijkstra map
+ * path, and if it can't find that it will go to
+ * a 0 path (same number).
+ *
+ * In random mode it will pick either the next lower
+ * or the same level depending on what it finds first.
+ * Since the starting direction is random this will
+ * give it a semi-random walk that eventually gets to
+ * the target.
+ *
+ * In map generation this makes random paths and carves
+ * up the space to make rooms more irregular.
+ *
+ * When applied to an enemy they will either go straight
+ * to the player (random=false) or they'll wander around
+ * drunkenly gradually reaching the player, and dodging
+ * in and out.
+ */
+bool Map::neighbors(Point &out, bool random) {
   Matrix &paths = $paths.$paths;
+  bool zero_found = false;
 
+  // just make a list of the four directions
   std::array<Point, 4> dirs{{
-      {out.x,out.y-1},
-      {out.x+1,out.y},
-      {out.x,out.y+1},
-      {out.x-1,out.y}
+      {out.x,out.y-1}, // north
+      {out.x+1,out.y}, // east
+      {out.x,out.y+1}, // south
+      {out.x-1,out.y} // west
   }};
 
-  int zero_i = -1;
+  // get the current dijkstra number
   int cur = paths[out.y][out.x];
 
-  // BUG: sometimes cur is in a wall so finding neighbors fails
-  for(size_t i = 0; i < dirs.size(); ++i) {
-    Point dir = dirs[i];
-    int target = inmap(dir.x, dir.y) ? paths[dir.y][dir.x] : $limit;
+  // pick a random start of directions
+  int rand_start = Random::uniform<int>(0, dirs.size());
 
-    if(target == $limit) continue; // skip unpathable stuff
+  // go through all possible directions
+  for(size_t i = 0; i < dirs.size(); i++) {
+    // but start at the random start, effectively randomizing
+    // which valid direction to go
+    Point dir = dirs[(i + rand_start) % dirs.size()];
+    if(!inmap(dir.x, dir.y)) continue; //skip unpathable stuff
+    int weight = cur - paths[dir.y][dir.x];
 
-    int diff = cur - target;
-
-    if(diff == 1) {
-      out = {.x=dir.x, .y=dir.y};
+    if(weight == 1) {
+      // no matter what we follow direct paths
+      out = dir;
       return true;
-    } else if(diff == 0) {
-      zero_i = i;
+    } else if(random && weight == 0) {
+      // if random is selected and it's a 0 path take it
+      out = dir;
+      return true;
+    } else if(weight == 0) {
+      // otherwise keep the last zero path for after
+      out = dir;
+      zero_found = true;
     }
   }
 
-  if(zero_i != -1) {
-    out = {.x=dirs[zero_i].x, .y=dirs[zero_i].y};
-    return true;
-  } else {
-    return false;
-  }
+  // if we reach this then either zero was found and
+  // zero_found is set true, or it wasn't and nothing found
+  return zero_found;
 }
 
-
 bool Map::INVARIANT() {
   using dbc::check;
 
   check($walls.size() == height(), "walls wrong height");
   check($walls[0].size() == width(), "walls wrong width");
 
+  for(auto room : $rooms) {
+    check(int(room.x) >= 0 && int(room.y) >= 0,
+        format("room depth={} has invalid position {},{}",
+          room.depth, room.x, room.y));
+    check(int(room.width) > 0 && int(room.height) > 0,
+        format("room depth={} has invalid dims {},{}",
+          room.depth, room.width, room.height));
+  }
+
   return true;
 }