Refactored the maze functions to be a builder that can do different things to the maze. Also when I hit p in the game it'll save the map to a file. This was extremely hard for no reason.

gui/fsm.cpp

@@ -320,6 +320,8 @@ namespace gui {
             sound::mute(false);
             $debug_ui.debug();
             shaders::reload();
+            dbc::log("save map!");
+            $map_ui.save_map("map.txt", $main_ui.$compass_dir);
             break;
           case KEY::O:
             autowalking = true;

gui/map_view.cpp

@@ -10,6 +10,7 @@
 #include <codecvt>
 #include <iostream>
 #include <fmt/xchar.h>
+#include <fstream>
 
 namespace gui {
   using namespace components;
@@ -58,6 +59,19 @@ namespace gui {
     // $gui.debug_layout(window);
   }
 
+  void MapViewUI::save_map(const std::string& outfile, int compass_dir) {
+    std::wstring map_out = System::draw_map(
+        $level, $level.map->width(), $level.map->height(), compass_dir);
+    dbc::check(map_out.size() > 0, "WHAT? printed map has nothing in it.");
+
+    std::wofstream out(outfile, std::ios::binary);
+    std::locale loc(std::locale::classic(), new std::codecvt_utf8<wchar_t>);
+    out.imbue(loc);
+
+    out << map_out;
+    dbc::check(out.good(), "failed to write map file");
+  }
+
   void MapViewUI::update() {
     if($gui.has<Textual>($log_to)) {
       auto& text = $gui.get<Textual>($log_to);

gui/map_view.hpp

@@ -20,5 +20,6 @@ namespace gui {
       void update_level(GameLevel &level);
       void log(std::wstring msg);
       void update();
+      void save_map(const std::string& outfile, int compass_dir);
   };
 }

map.cpp

@@ -45,12 +45,11 @@ void Map::clear_target(const Point &at) {
 }
 
 bool Map::place_entity(size_t room_index, Point &out) {
+  dbc::check($dead_ends.size() != 0, "no dead ends?!");
   if($rooms.size() == 0) {
-    dbc::log("fucking dead end?");
     out = $dead_ends.at(room_index % $dead_ends.size());
     return true;
   } else {
-    dbc::log("fucking fuckng fuck fuck");
     dbc::check(room_index < $rooms.size(), "room_index is out of bounds, not enough rooms");
 
     Room &start = $rooms.at(room_index);

maze.cpp

@@ -7,7 +7,8 @@
 using std::string;
 using matrix::Matrix;
 
-inline size_t rand(size_t i, size_t j) {
+namespace maze {
+  inline size_t rand(size_t i, size_t j) {
     if(i < j) {
       return Random::uniform(i, j);
     } else if(j < i) {
@@ -15,10 +16,10 @@ inline size_t rand(size_t i, size_t j) {
     } else {
       return i;
     }
-}
+  }
 
 
-inline bool complete(Matrix& maze) {
+  inline bool complete(Matrix& maze) {
     size_t width = matrix::width(maze);
     size_t height = matrix::height(maze);
 
@@ -29,9 +30,9 @@ inline bool complete(Matrix& maze) {
     }
 
     return true;
-}
+  }
 
-std::vector<Point> neighborsAB(Matrix& maze, Point on) {
+  std::vector<Point> neighborsAB(Matrix& maze, Point on) {
     std::vector<Point> result;
 
     std::array<Point, 4> points{{
@@ -48,9 +49,9 @@ std::vector<Point> neighborsAB(Matrix& maze, Point on) {
     }
 
     return result;
-}
+  }
 
-std::vector<Point> neighbors(Matrix& maze, Point on) {
+  std::vector<Point> neighbors(Matrix& maze, Point on) {
     std::vector<Point> result;
 
     std::array<Point, 4> points{{
@@ -69,9 +70,9 @@ std::vector<Point> neighbors(Matrix& maze, Point on) {
     }
 
     return result;
-}
+  }
 
-inline std::pair<Point, Point> find_coord(Matrix& maze) {
+  inline std::pair<Point, Point> find_coord(Matrix& maze) {
     size_t width = matrix::width(maze);
     size_t height = matrix::height(maze);
 
@@ -91,132 +92,136 @@ inline std::pair<Point, Point> find_coord(Matrix& maze) {
 
     matrix::dump("BAD MAZE", maze);
     dbc::sentinel("failed to find coord?");
-}
+  }
 
-void maze::randomize_rooms(std::vector<Room>& rooms_out, std::vector<Point>& maybe_here) {
+  void Builder::randomize_rooms() {
-  dbc::check(maybe_here.size() >= 2, "must have at least two possible points to place rooms");
+    dbc::check($dead_ends.size() >= 2, "must have at least two possible points to place rooms");
 
-  while(rooms_out.size() < 2) {
+    while($rooms.size() < 2) {
       // use those dead ends to randomly place rooms
-    for(auto at : maybe_here) {
+      for(auto at : $dead_ends) {
         if(Random::uniform(0,1)) {
           size_t offset = Random::uniform(0,1);
           Room cur{at.x+offset, at.y+offset, 1, 1};
-        rooms_out.push_back(cur);
+          $rooms.push_back(cur);
+        }
       }
     }
   }
-}
 
-void maze::init(Matrix& maze) {
+  void Builder::init() {
-  matrix::assign(maze, WALL_VALUE);
+    matrix::assign($walls, WALL_VALUE);
-}
+  }
 
-void maze::divide(Matrix& maze, Point start, Point end) {
+  void Builder::divide(Point start, Point end) {
     for(matrix::line it{start, end}; it.next();) {
-    maze[it.y][it.x] = 0;
+      $walls[it.y][it.x] = 0;
-    maze[it.y+1][it.x] = 0;
+      $walls[it.y+1][it.x] = 0;
+    }
   }
-}
 
-void maze::hunt_and_kill(Matrix& maze, std::vector<Room>& rooms, std::vector<Point>& dead_ends) {
+  void Builder::hunt_and_kill() {
-
+    for(auto& room : $rooms) {
-  for(auto& room : rooms) {
+      for(matrix::box it{$walls, room.x, room.y, room.width}; it.next();) {
-    for(matrix::box it{maze, room.x, room.y, room.width}; it.next();) {
+        $walls[it.y][it.x] = 0;
-      maze[it.y][it.x] = 0;
       }
     }
 
     Point on{1,1};
 
-  while(!complete(maze)) {
+    while(!complete($walls)) {
-    auto n = neighbors(maze, on);
+      auto n = neighbors($walls, on);
       if(n.size() == 0) {
-      dead_ends.push_back(on);
+        $dead_ends.push_back(on);
-      auto t = find_coord(maze);
+        auto t = find_coord($walls);
         on = t.first;
-      maze[on.y][on.x] = 0;
+        $walls[on.y][on.x] = 0;
         size_t row = (on.y + t.second.y) / 2;
         size_t col = (on.x + t.second.x) / 2;
-      maze[row][col] = 0;
+        $walls[row][col] = 0;
       } else {
         auto nb = n[rand(size_t(0), n.size() - 1)];
-      maze[nb.y][nb.x] = 0;
+        $walls[nb.y][nb.x] = 0;
 
         size_t row = (nb.y + on.y) / 2;
         size_t col = (nb.x + on.x) / 2;
-      maze[row][col] = 0;
+        $walls[row][col] = 0;
         on = nb;
       }
     }
 
-  for(auto at : dead_ends) {
+    for(auto at : $dead_ends) {
-    for(auto& room : rooms) {
+      for(auto& room : $rooms) {
         Point room_ul{room.x - room.width - 1, room.y - room.height - 1};
         Point room_lr{room.x + room.width - 1, room.y + room.height - 1};
 
         if(at.x >= room_ul.x && at.y >= room_ul.y &&
             at.x <= room_lr.x && at.y <= room_lr.y)
         {
-        for(matrix::compass it{maze, at.x, at.y}; it.next();) {
+          for(matrix::compass it{$walls, at.x, at.y}; it.next();) {
-          if(maze[it.y][it.x] == 1) {
+            if($walls[it.y][it.x] == 1) {
-            maze[it.y][it.x] = 0;
+              $walls[it.y][it.x] = 0;
               break;
             }
           }
         }
       }
     }
-}
+  }
 
-void maze::inner_donut(Matrix& maze, float outer_rad, float inner_rad) {
+  void Builder::inner_donut(float outer_rad, float inner_rad) {
-  size_t x = matrix::width(maze) / 2;
+    size_t x = matrix::width($walls) / 2;
-  size_t y = matrix::height(maze) / 2;
+    size_t y = matrix::height($walls) / 2;
 
-  for(matrix::circle it{maze, {x, y}, outer_rad};
+    for(matrix::circle it{$walls, {x, y}, outer_rad};
         it.next();)
     {
       for(int x = it.left; x < it.right; x++) {
-      maze[it.y][x] = 0;
+        $walls[it.y][x] = 0;
       }
     }
 
-  for(matrix::circle it{maze, {x, y}, inner_rad};
+    for(matrix::circle it{$walls, {x, y}, inner_rad};
         it.next();)
     {
       for(int x = it.left; x < it.right; x++) {
-      maze[it.y][x] = 1;
+        $walls[it.y][x] = 1;
+      }
     }
   }
-}
 
-void maze::inner_box(Matrix& maze, size_t outer_size, size_t inner_size) {
+  void Builder::inner_box(size_t outer_size, size_t inner_size) {
+    size_t x = matrix::width($walls) / 2;
+    size_t y = matrix::height($walls) / 2;
 
-  size_t x = matrix::width(maze) / 2;
+    for(matrix::box it{$walls, x, y, outer_size};
-  size_t y = matrix::height(maze) / 2;
-
-  for(matrix::box it{maze, x, y, outer_size};
         it.next();)
     {
-    maze[it.y][it.x] = 0;
+      $walls[it.y][it.x] = 0;
     }
 
-  for(matrix::box it{maze, x, y, inner_size};
+    for(matrix::box it{$walls, x, y, inner_size};
         it.next();)
     {
-    maze[it.y][it.x] = 1;
+      $walls[it.y][it.x] = 1;
+    }
   }
-}
 
 
-void maze::remove_dead_ends(Matrix& maze, std::vector<Point>& dead_ends) {
+  void Builder::remove_dead_ends() {
-  for(auto at : dead_ends) {
+    dbc::check($dead_ends.size() > 0, "you have to run an algo first, no dead_ends to remove");
-    for(matrix::compass it{maze, at.x, at.y}; it.next();) {
+    for(auto at : $dead_ends) {
-      if(maze[it.y][it.x] == 0) {
+      for(matrix::compass it{$walls, at.x, at.y}; it.next();) {
+        if($walls[it.y][it.x] == 0) {
           int diff_x = at.x - it.x;
           int diff_y = at.y - it.y;
-        maze[at.y + diff_y][at.x + diff_x] = 0;
+          $walls[at.y + diff_y][at.x + diff_x] = 0;
         }
       }
     }
+  }
+
+  void Builder::dump(const std::string& msg) {
+    matrix::dump(msg, $walls);
+  }
 }

maze.hpp

@@ -4,16 +4,26 @@
 
 namespace maze {
 
-  void init(Matrix& maze);
 
-  void hunt_and_kill(Matrix& maze, std::vector<Room>& rooms, std::vector<Point>& dead_ends);
+  struct Builder {
+    Matrix& $walls;
+    std::vector<Room>& $rooms;
+    std::vector<Point>& $dead_ends;
 
-  void randomize_rooms(std::vector<Room>& rooms_out, std::vector<Point>& maybe_here);
+    Builder(Map& map) :
+      $walls(map.$walls), $rooms(map.$rooms), $dead_ends(map.$dead_ends)
+    {
+      init();
+    }
 
-  void inner_donut(Matrix& maze, float outer_rad, float inner_rad);
+    void hunt_and_kill();
-  void inner_box(Matrix& map, size_t outer_size, size_t inner_size);
 
-  void divide(Matrix& maze, Point start, Point end);
+    void init();
-
+    void randomize_rooms();
-  void remove_dead_ends(Matrix& maze, std::vector<Point>& dead_ends);
+    void inner_donut(float outer_rad, float inner_rad);
+    void inner_box(size_t outer_size, size_t inner_size);
+    void divide(Point start, Point end);
+    void remove_dead_ends();
+    void dump(const std::string& msg);
+  };
 }

tests/mazes.cpp

@@ -9,112 +9,98 @@
 using std::string;
 using matrix::Matrix;
 
-
 TEST_CASE("hunt-and-kill", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.hunt_and_kill();
-  maze::hunt_and_kill(map, rooms, dead_ends);
+  maze.dump("BASIC MAZE");
-  matrix::dump("BASIC MAZE", map);
 
-  maze::randomize_rooms(rooms, dead_ends);
+  maze.randomize_rooms();
-  maze::hunt_and_kill(map, rooms, dead_ends);
+  maze.hunt_and_kill();
 
-  for(auto& room : rooms) {
+  REQUIRE(map.$dead_ends.size() > 0);
-    for(matrix::box it{map, room.x, room.y, room.width};
+  REQUIRE(map.$rooms.size() > 0);
+
+  for(auto& room : maze.$rooms) {
+    for(matrix::box it{maze.$walls, room.x, room.y, room.width};
         it.next();)
     {
-      map[it.y][it.x] = WALL_PATH_LIMIT;
+      maze.$walls[it.y][it.x] = WALL_PATH_LIMIT;
     }
   }
 
-  matrix::dump("MAZE WITH ROOMS", map);
+  maze.dump("MAZE WITH ROOMS");
 }
 
 TEST_CASE("hunt-and-kill box", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.inner_box(5, 3);
-  maze::inner_box(map, 5, 3);
+  maze.hunt_and_kill();
-  maze::hunt_and_kill(map, rooms, dead_ends);
 
-  for(auto at : dead_ends) {
+  for(auto at : maze.$dead_ends) {
-    map[at.y][at.x]=32;
+    maze.$walls[at.y][at.x]=32;
   }
-  matrix::dump("INNER BOX", map);
+  maze.dump("INNER BOX");
 
-  REQUIRE(rooms.size() == 0);
+  REQUIRE(maze.$rooms.size() == 0);
 }
 
 TEST_CASE("hunt-and-kill ring", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.inner_donut(5.5, 3.5);
-  maze::inner_donut(map, 5.5, 3.5);
+  maze.hunt_and_kill();
-  maze::hunt_and_kill(map, rooms, dead_ends);
 
-  for(auto at : dead_ends) {
+  for(auto at : maze.$dead_ends) {
-    map[at.y][at.x]=32;
+    maze.$walls[at.y][at.x]=32;
   }
-  matrix::dump("INNER RING", map);
+  maze.dump("INNER RING");
 
-  REQUIRE(rooms.size() == 0);
+  REQUIRE(maze.$rooms.size() == 0);
 }
 
 TEST_CASE("hunt-and-kill fissure", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.divide({3,3}, {19,18});
-  maze::divide(map, {3,3}, {19,18});
+  maze.hunt_and_kill();
-  maze::hunt_and_kill(map, rooms, dead_ends);
 
-  for(auto at : dead_ends) {
+  for(auto at : maze.$dead_ends) {
-    map[at.y][at.x]=32;
+    maze.$walls[at.y][at.x]=32;
   }
-  matrix::dump("FISSURE MAZE", map);
+  maze.dump("FISSURE MAZE");
 
-  REQUIRE(rooms.size() == 0);
+  REQUIRE(maze.$rooms.size() == 0);
 }
 
 
 
 TEST_CASE("hunt-and-kill no-dead-ends", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.hunt_and_kill();
 
-  maze::hunt_and_kill(map, rooms, dead_ends);
+  maze.remove_dead_ends();
 
-  maze::remove_dead_ends(map, dead_ends);
+  maze.dump("NO DEAD ENDS");
-
-  matrix::dump("NO DEAD ENDS", map);
 }
 
 TEST_CASE("hunt-and-kill too much", "[mazes]") {
-  auto map = matrix::make(21, 21);
+  Map map(21, 21);
-  std::vector<Room> rooms;
+  maze::Builder maze(map);
-  std::vector<Point> dead_ends;
 
-  maze::init(map);
+  maze.hunt_and_kill();
-  maze::inner_donut(map, 4, 2);
+  maze.randomize_rooms();
-  maze::divide(map, {3,3}, {19,18});
+  maze.init();
-  auto copy = map;
+  maze.inner_donut(4, 2);
+  maze.divide({3,3}, {19,18});
+  maze.hunt_and_kill();
 
-  maze::hunt_and_kill(copy, rooms, dead_ends);
+  maze.dump("COMBINED");
-
-  map = copy;
-  maze::randomize_rooms(rooms, dead_ends);
-  maze::hunt_and_kill(map, rooms, dead_ends);
-
-  matrix::dump("COMBINED", map);
 }

worldbuilder.cpp

@@ -11,17 +11,20 @@ using namespace fmt;
 using namespace components;
 
 void WorldBuilder::generate_map() {
-  maze::init($map.$walls);
+  maze::Builder maze($map);
-  maze::hunt_and_kill($map.$walls, $map.$rooms, $map.$dead_ends);
+  size_t x_diff = $map.width() / 4;
-  maze::randomize_rooms($map.$rooms, $map.$dead_ends);
+  size_t y_diff = $map.height() / 4;
-  maze::hunt_and_kill($map.$walls, $map.$rooms, $map.$dead_ends);
+
+  maze.divide({x_diff, y_diff}, {$map.width() - x_diff, $map.height() - y_diff});
+  maze.hunt_and_kill();
+
+  dbc::check($map.$dead_ends.size() > 0, "world builder/maze builder made a map with no dead ends.");
 
   $map.expand();
   $map.load_tiles();
 }
 
 DinkyECS::Entity WorldBuilder::configure_entity_in_map(DinkyECS::World &world, json &entity_data, Point pos_out) {
-  dbc::log(">>>>>>>>>>> ENTER");
   auto item = world.entity();
   world.set<Position>(item, {pos_out.x+1, pos_out.y+1});
 
@@ -33,17 +36,14 @@ DinkyECS::Entity WorldBuilder::configure_entity_in_map(DinkyECS::World &world, j
     components::configure_entity($components, world, item, entity_data["components"]);
   }
 
-  dbc::log("<<<<<<<<<<<<< EXIT");
   return item;
 }
 
 DinkyECS::Entity WorldBuilder::configure_entity_in_room(DinkyECS::World &world, json &entity_data, int in_room) {
   Point pos_out;
-  dbc::log("is it configure_entity_in_map's fault?");
   bool placed = $map.place_entity(in_room, pos_out);
   dbc::check(placed, "failed to randomly place item in room");
   auto entity = configure_entity_in_map(world, entity_data, pos_out);
-  dbc::log("<<<<<<<<<<<<<<<<<<<<<<<<<<< leaving configure_entity_in_room");
   return entity;
 }
 
@@ -118,7 +118,6 @@ void WorldBuilder::place_entities(DinkyECS::World &world) {
   if(world.has_the<Player>()) {
     auto& player = world.get_the<Player>();
     Point pos_out;
-    dbc::log("or is it in place_entities placing the player?");
     bool placed = $map.place_entity(0, pos_out);
     dbc::check(placed, "failed to randomly place item in room");
     world.set<Position>(player.entity, {pos_out.x+1, pos_out.y+1});