Brought over a bunch of code from the roguelike and now will use it to generate a random map.

map.cpp

@@ -0,0 +1,235 @@
+#include "map.hpp"
+#include "dbc.hpp"
+#include "rand.hpp"
+#include <vector>
+#include <array>
+#include <fmt/core.h>
+#include <utility>
+#include "matrix.hpp"
+
+using std::vector, std::pair;
+using namespace fmt;
+
+Map::Map(size_t width, size_t height) :
+  $width(width),
+  $height(height),
+  $tiles(width, height),
+  $walls(height, matrix::Row(width, SPACE_VALUE)),
+  $paths(width, height)
+{}
+
+Map::Map(Matrix &walls, Pathing &paths) :
+  $tiles(matrix::width(walls), matrix::height(walls)),
+  $walls(walls),
+  $paths(paths)
+{
+  $width = matrix::width(walls);
+  $height = matrix::height(walls);
+}
+
+void Map::make_paths() {
+  INVARIANT();
+  $paths.compute_paths($walls);
+}
+
+bool Map::inmap(size_t x, size_t y) {
+  return x < $width && y < $height;
+}
+
+void Map::set_target(const Point &at, int value) {
+  $paths.set_target(at, value);
+}
+
+void Map::clear_target(const Point &at) {
+  $paths.clear_target(at);
+}
+
+bool Map::place_entity(size_t room_index, Point &out) {
+  dbc::check(room_index < $rooms.size(), "room_index is out of bounds, not enough rooms");
+
+  Room &start = $rooms[room_index];
+
+  for(matrix::rando_rect it{$walls, start.x, start.y, start.width, start.height}; it.next();) {
+    if(!iswall(it.x, it.y)) {
+      out.x = it.x;
+      out.y = it.y;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool Map::iswall(size_t x, size_t y) {
+  return $walls[y][x] == WALL_VALUE;
+}
+
+void Map::dump(int show_x, int show_y) {
+  matrix::dump("WALLS", walls(), show_x, show_y);
+  matrix::dump("PATHS", paths(), show_x, show_y);
+}
+
+bool Map::can_move(Point move_to) {
+  return inmap(move_to.x, move_to.y) &&
+    !iswall(move_to.x, move_to.y);
+}
+
+Point Map::map_to_camera(const Point &loc, const Point &cam_orig) {
+  return {loc.x - cam_orig.x, loc.y - cam_orig.y};
+}
+
+Point Map::center_camera(const Point &around, size_t view_x, size_t view_y) {
+  int high_x = int(width() - view_x);
+  int high_y = int(height() - view_y);
+  int center_x = int(around.x - view_x / 2);
+  int center_y = int(around.y - view_y / 2);
+
+  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};
+}
+
+/*
+ * 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}, // north
+      {out.x+1,out.y}, // east
+      {out.x,out.y+1}, // south
+      {out.x-1,out.y} // west
+  }};
+
+  // get the current dijkstra number
+  int cur = paths[out.y][out.x];
+
+  // pick a random start of directions
+  // BUG: is uniform inclusive of the dir.size()?
+  int rand_start = Random::uniform<int>(0, dirs.size());
+
+  // 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
+    // BUG: this might be wrong given the above ranom from 0-size
+    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];
+
+    if(weight == 1) {
+      // no matter what we follow direct paths
+      out = dir;
+      return true;
+    } 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 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");
+  check($paths.$width == width(), "in Map paths width don't match map width");
+  check($paths.$height == height(), "in Map paths height don't match map height");
+
+  for(auto room : $rooms) {
+    check(int(room.x) >= 0 && int(room.y) >= 0,
+        format("room invalid position {},{}",
+          room.x, room.y));
+    check(int(room.width) > 0 && int(room.height) > 0,
+        format("room has invalid dims {},{}",
+          room.width, room.height));
+  }
+
+  return true;
+}
+
+void Map::load_tiles() {
+  $tiles.load($walls);
+}
+
+void Map::expand() {
+  // adjust width first
+  for(auto &row : $walls) {
+    row.insert(row.begin(), WALL_VALUE);
+    row.push_back(WALL_VALUE);
+  }
+  $width = matrix::width($walls);
+
+  // then add two new rows top/bottom of that new width
+  $walls.insert($walls.begin(), matrix::Row($width, WALL_VALUE));
+  $walls.push_back(matrix::Row($width, WALL_VALUE));
+  // now we have the new height
+  $height = matrix::height($walls);
+
+  // reset the pathing and tiles and done
+  $paths = Pathing($width, $height);
+  $tiles = TileMap($width, $height);
+}
+
+void Map::add_room(Room &room) {
+  room.x++;
+  room.y++;
+  room.width--;
+  room.height--;
+
+  if(room.x + room.width >= $width) {
+    // fix the width
+    room.x--;
+  }
+
+  if(room.y + room.height >= $height) {
+    // fix the height
+    room.y--;
+  }
+
+  $rooms.push_back(room);
+}
+
+void Map::invert_space() {
+  for(matrix::each_cell it{$walls}; it.next();) {
+    int is_wall = !$walls[it.y][it.x];
+    $walls[it.y][it.x] = is_wall;
+  }
+}