roguish/map.cpp

#include "map.hpp"
#include "dbc.hpp"
#include <vector>
#include <fmt/core.h>
#include <random>
#include <utility>

using std::vector, std::pair;
using namespace fmt;

void dump_map(const std::string &msg, Matrix &map) {
  println("----------------- {}", msg);
  for(auto row : map) {
    for(auto col : row) {
      print("{} ", col);
    }
    print("\n");
  }
}

inline void add_neighbors(PairList &neighbors, Matrix &closed, size_t j, size_t i) {
  size_t h = closed.size();
  size_t w = closed[0].size();
  vector<size_t> rows{j - 1, j, j + 1};
  vector<size_t> cols{i - 1, i, i + 1};

  for(auto row : rows) {
    for(auto col : cols) {
      if((0 <= row && row < h) &&
          (0 <= col && col < w) &&
          closed[row][col] == 0)
      {
        closed[row][col] = 1;
        neighbors.push_back({.j=row, .i=col});
      }
    }
  }
}

Map::Map(size_t width, size_t height) : m_limit(1000) {
  m_walls = Matrix(height, MatrixRow(width, 1));
  m_input_map = Matrix(height, MatrixRow(width, 1));
}

void Map::make_paths() {
  size_t h = m_input_map.size();
  size_t w = m_input_map[0].size();

  // Initialize the new array with every pixel at limit distance
  // NOTE: this is normally ones() * limit
  int limit = m_limit == 0 ? h * w : m_limit;
  Matrix new_arr = Matrix(h, MatrixRow(w, limit));
  Matrix closed = m_walls;
  PairList starting_pixels;
  PairList open_pixels;

  // First pass: Add starting pixels and put them in closed
 for(size_t counter = 0; counter < h * w; counter++) {
    size_t i = counter % w;
    size_t j = counter / w;
    if(m_input_map[j][i] == 0) {
      new_arr[j][i] = 0;
      closed[j][i] = 1;
      starting_pixels.push_back({.j=j,.i=i});
    }
  }

  // Second pass: Add border to open
  for(auto sp : starting_pixels) {
    add_neighbors(open_pixels, closed, sp.j, sp.i);
  }

  // Third pass: Iterate filling in the open list
  int counter = 1; // leave this here so it's available below
  for(; counter < limit && !open_pixels.empty(); ++counter) {
    PairList next_open;
    for(auto sp : open_pixels) {
      new_arr[sp.j][sp.i] = counter;
      add_neighbors(next_open, closed, sp.j, sp.i);
    }
    open_pixels = next_open;
  }

  // Last pass: flood last pixels
  for(auto sp : open_pixels) {
    new_arr[sp.j][sp.i] = counter;
  }

  m_paths = new_arr;
}

void Map::make_room(size_t origin_x, size_t origin_y, size_t w, size_t h) {
  println("MAKE ROOM x={}, y={}, w={}, h={}", origin_x, origin_y, w, h);
  dbc::pre("x out of bounds", origin_x < width());
  dbc::pre("y out of bounds", origin_y < height());
  dbc::pre("w out of bounds", w <= width());
  dbc::pre("h out of bounds", h <= height());

  for(size_t y = origin_y; y < origin_y + h; ++y) {
    dbc::check(y < m_walls.size(), "y is out of bounds");
    for(size_t x = origin_x; x < origin_x + w; ++x) {
      dbc::check(x < m_walls[y].size(), "x is out of bounds");
      m_walls[y][x] = 0;
    }
  }
}

struct Partition;

struct Partition {
  size_t x = 0;
  size_t y = 0;
  size_t width = 0;
  size_t height = 0;

  std::vector<Partition> next;
};

inline int make_split(std::mt19937 &gen, Partition &cur, bool horiz) {
  println("MAKE SPLIT horiz={}, y={}, w={}, h={}", horiz,
        cur.y, cur.width, cur.height);
  size_t dimension = horiz ? cur.height : cur.width;
  int min = dimension / 4; // 25% of the dimension
  int max = dimension - min; // 25% off the other side
  println("dimension={}, min={}, max={}", dimension, min, max);
  std::uniform_int_distribution<int> rand_dim(min, max);
  return rand_dim(gen);
}

void partition_map(std::mt19937 &gen, Partition &cur, int depth) {
  println(">>>> DEPTH: {}", depth);
  std::uniform_int_distribution<int> rsplit(0, 1);
  bool horiz = rsplit(gen);
  int split = make_split(gen, cur, horiz);
  Partition left;
  Partition right;

  if(horiz) {
    println("HORIZ split={}, x={}, y={}, w={}, h={}",
        split, cur.x, cur.y, cur.width, cur.height);

    dbc::check(split > 0, "split is not > 0");
    dbc::check(split < int(cur.height), "split is too big!");

    left = {
      .x = cur.x,
      .y = cur.y,
      .width = cur.width,
      .height = size_t(split - 1)
    };

    right = {
      .x = cur.x,
      .y = cur.y + split,
      .width = cur.width,
      .height = size_t(cur.height - split)
    };
  } else {
    println("VERT split={}, x={}, y={}, w={}, h={}", split, cur.x, cur.y, cur.width, cur.height);

    dbc::check(split > 0, "split is not > 0");
    dbc::check(split < int(cur.width), "split is too big!");

    left = {
      .x = cur.x,
      .y = cur.y,
      .width = size_t(split-1),
      .height = cur.height
    };

    right = {
      .x = cur.x + split,
      .y = cur.y,
      .width = size_t(cur.width - split),
      .height = cur.height
    };
  }

  if(depth > 0  && left.width > 5 && left.height > 5) {
    println("### LEFT h={}, w={}", left.width, left.height);
    partition_map(gen, left, depth-1);
    cur.next.push_back(left);
  }

  if(depth > 0 && right.width > 5 && right.height > 5) {
    println("### RIGHT h={}, w={}", right.width, right.height);
    partition_map(gen, right, depth-1);
    cur.next.push_back(right);
  }
}

void draw_map(Map *map, Partition &cur) {
  if(cur.x + cur.width <= map->width()
      && cur.y + cur.height <= map->height())
  {
    map->make_room(cur.x, cur.y, cur.width, cur.height);

    if(cur.next.size() == 2) {
      draw_map(map, cur.next[0]); // left
      draw_map(map, cur.next[1]); // right
    } else {
      println("LEAF NODE NO CHILDREN");
    }
  } else {
    println("ABORT in draw_map, x={}, y={}, w={}, h={}, map.w={}, map.h={}",
        cur.x, cur.y, cur.width, cur.height, map->width(), map->height());
  }
}

void Map::generate() {
  std::random_device rd;
  std::mt19937 gen(rd());

  Partition root{
    .x = 0,
    .y = 0,
    .width = width(),
    .height = height()
  };

  partition_map(gen, root, 5);
  draw_map(this, root); // left
}