Conver to using \ for member variables in classes. In structs just use the name.
This commit is contained in:
Zed A. Shaw
parent
187edb898e
commit
5cf66aad02
8 changed files with 143 additions and 144 deletions
|
|
@ -5,7 +5,7 @@ void Entity::move(Point loc) {
|
|||
}
|
||||
|
||||
void Entity::event(EntityEvent ev) {
|
||||
switch(_state) {
|
||||
switch($state) {
|
||||
FSM_STATE(EntityState, START, ev);
|
||||
FSM_STATE(EntityState, HUNTING, ev);
|
||||
FSM_STATE(EntityState, DEAD, ev);
|
||||
|
|
|
|||
|
|
@ -11,8 +11,7 @@ enum class EntityEvent {
|
|||
};
|
||||
|
||||
|
||||
class Entity : public DeadSimpleFSM<EntityState, EntityEvent> {
|
||||
public:
|
||||
struct Entity : public DeadSimpleFSM<EntityState, EntityEvent> {
|
||||
Point location{0,0};
|
||||
int hp = 20;
|
||||
int damage = 10;
|
||||
|
|
|
|||
6
fsm.hpp
6
fsm.hpp
|
|
@ -12,17 +12,17 @@ template<typename S, typename E>
|
|||
class DeadSimpleFSM {
|
||||
protected:
|
||||
// BUG: don't put this in your class because state() won't work
|
||||
S _state = S::START;
|
||||
S $state = S::START;
|
||||
|
||||
public:
|
||||
template<typename... Types>
|
||||
void event(E event, Types... args);
|
||||
|
||||
void state(S next_state) {
|
||||
_state = next_state;
|
||||
$state = next_state;
|
||||
}
|
||||
|
||||
bool in_state(S state) {
|
||||
return _state == state;
|
||||
return $state == state;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
116
gui.cpp
116
gui.cpp
|
|
@ -40,80 +40,80 @@ sf::Color GUI::color(Value val) {
|
|||
return VALUES[size_t(val)];
|
||||
}
|
||||
|
||||
GUI::GUI() : game_map_(50, 20),
|
||||
canvas_(60 * 2, 20 * 4),
|
||||
window_(sf::VideoMode(1600,900), "Roguish"),
|
||||
screen_(0,0)
|
||||
GUI::GUI() : $game_map(50, 20),
|
||||
$canvas(60 * 2, 20 * 4),
|
||||
$window(sf::VideoMode(1600,900), "Roguish"),
|
||||
$screen(0,0)
|
||||
{
|
||||
int res = hit_buf_.loadFromFile("./assets/hit.wav");
|
||||
int res = $hit_buf.loadFromFile("./assets/hit.wav");
|
||||
dbc::check(res, "failed to load hit.wav");
|
||||
hit_sound_.setBuffer(hit_buf_);
|
||||
$hit_sound.setBuffer($hit_buf);
|
||||
|
||||
font_.loadFromFile("./assets/text.otf");
|
||||
text_.setFont(font_);
|
||||
text_.setCharacterSize(30);
|
||||
text_.setFillColor(color(Value::LIGHT_DARK));
|
||||
game_map_.generate();
|
||||
player_.location = game_map_.place_entity(0);
|
||||
enemy_.location = game_map_.place_entity(1);
|
||||
goal_ = game_map_.place_entity(game_map_.room_count() - 1);
|
||||
screen_ = Screen::Create(Dimension::Full());
|
||||
$font.loadFromFile("./assets/text.otf");
|
||||
$text.setFont($font);
|
||||
$text.setCharacterSize(30);
|
||||
$text.setFillColor(color(Value::LIGHT_DARK));
|
||||
$game_map.generate();
|
||||
$player.location = $game_map.place_entity(0);
|
||||
$enemy.location = $game_map.place_entity(1);
|
||||
$goal = $game_map.place_entity($game_map.room_count() - 1);
|
||||
$screen = Screen::Create(Dimension::Full());
|
||||
}
|
||||
|
||||
void GUI::create_renderer() {
|
||||
map_view_ = Renderer([&] {
|
||||
Matrix &walls = game_map_.walls();
|
||||
game_map_.set_target(player_.location);
|
||||
game_map_.make_paths();
|
||||
Matrix &paths = game_map_.paths();
|
||||
$map_view = Renderer([&] {
|
||||
Matrix &walls = $game_map.walls();
|
||||
$game_map.set_target($player.location);
|
||||
$game_map.make_paths();
|
||||
Matrix &paths = $game_map.paths();
|
||||
|
||||
if(player_.in_state(EntityState::DEAD)) {
|
||||
status_text_ = "DEAD!";
|
||||
if($player.in_state(EntityState::DEAD)) {
|
||||
$status_text = "DEAD!";
|
||||
}
|
||||
|
||||
for(size_t x = 0; x < walls[0].size(); ++x) {
|
||||
for(size_t y = 0; y < walls.size(); ++y) {
|
||||
string tile = walls[y][x] == 1 ? "#" : format("{}", paths[y][x]);
|
||||
if(tile == "#") {
|
||||
canvas_.DrawText(x*2, y*4, tile);
|
||||
} else if(show_paths_) {
|
||||
$canvas.DrawText(x*2, y*4, tile);
|
||||
} else if($show_paths) {
|
||||
//int pnum = paths[y][x];
|
||||
canvas_.DrawText(x*2, y*4, tile);
|
||||
$canvas.DrawText(x*2, y*4, tile);
|
||||
} else {
|
||||
canvas_.DrawText(x*2, y*4, ".");
|
||||
$canvas.DrawText(x*2, y*4, ".");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
canvas_.DrawText(enemy_.location.x*2, enemy_.location.y*4, "!");
|
||||
canvas_.DrawText(player_.location.x*2, player_.location.y*4, "@");
|
||||
canvas_.DrawText(goal_.x*2, goal_.y*4, "$");
|
||||
$canvas.DrawText($enemy.location.x*2, $enemy.location.y*4, "!");
|
||||
$canvas.DrawText($player.location.x*2, $player.location.y*4, "@");
|
||||
$canvas.DrawText($goal.x*2, $goal.y*4, "$");
|
||||
|
||||
return canvas(canvas_);
|
||||
return canvas($canvas);
|
||||
});
|
||||
|
||||
document_ = Renderer([&]{
|
||||
$document = Renderer([&]{
|
||||
return hbox({
|
||||
hflow(
|
||||
vbox(
|
||||
text(format("HP: {}", player_.hp)) | border,
|
||||
text(status_text_) | border
|
||||
text(format("HP: {}", $player.hp)) | border,
|
||||
text($status_text) | border
|
||||
) | xflex_grow
|
||||
),
|
||||
separator(),
|
||||
hbox(map_view_->Render()),
|
||||
hbox($map_view->Render()),
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
void GUI::handle_events() {
|
||||
sf::Event event;
|
||||
while(window_.pollEvent(event)) {
|
||||
while($window.pollEvent(event)) {
|
||||
if(event.type == sf::Event::Closed) {
|
||||
window_.close();
|
||||
$window.close();
|
||||
} else if(event.type == sf::Event::KeyPressed) {
|
||||
size_t x = player_.location.x;
|
||||
size_t y = player_.location.y;
|
||||
size_t x = $player.location.x;
|
||||
size_t y = $player.location.y;
|
||||
|
||||
if(sf::Keyboard::isKeyPressed(sf::Keyboard::Left)) {
|
||||
x -= 1;
|
||||
|
|
@ -125,44 +125,44 @@ void GUI::handle_events() {
|
|||
y += 1;
|
||||
}
|
||||
|
||||
if(game_map_.inmap(x,y) && !game_map_.iswall(x,y)) {
|
||||
game_map_.clear_target(player_.location);
|
||||
player_.move({x, y});
|
||||
if($game_map.inmap(x,y) && !$game_map.iswall(x,y)) {
|
||||
$game_map.clear_target($player.location);
|
||||
$player.move({x, y});
|
||||
} else {
|
||||
hit_sound_.play();
|
||||
$hit_sound.play();
|
||||
}
|
||||
|
||||
// move enemy_ here
|
||||
bool found = game_map_.neighbors(enemy_.location, true);
|
||||
// move $enemy here
|
||||
bool found = $game_map.neighbors($enemy.location, true);
|
||||
if(!found) {
|
||||
status_text_ = "ENEMY STUCK!";
|
||||
$status_text = "ENEMY STUCK!";
|
||||
}
|
||||
|
||||
if(enemy_.location.x == player_.location.x && enemy_.location.y == player_.location.y) {
|
||||
player_.event(EntityEvent::HIT);
|
||||
} else if(goal_.x == player_.location.x && goal_.y == player_.location.y) {
|
||||
status_text_ = "YOU WIN!";
|
||||
if($enemy.location.x == $player.location.x && $enemy.location.y == $player.location.y) {
|
||||
$player.event(EntityEvent::HIT);
|
||||
} else if($goal.x == $player.location.x && $goal.y == $player.location.y) {
|
||||
$status_text = "YOU WIN!";
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GUI::render_scene() {
|
||||
Render(screen_, document_->Render());
|
||||
std::string screen_out = screen_.ToString();
|
||||
std::wstring utf8 = converter_.from_bytes(screen_out);
|
||||
text_.setString(utf8);
|
||||
text_.setPosition({0,0});
|
||||
Render($screen, $document->Render());
|
||||
std::string $screenout = $screen.ToString();
|
||||
std::wstring utf8 = $converter.from_bytes($screenout);
|
||||
$text.setString(utf8);
|
||||
$text.setPosition({0,0});
|
||||
|
||||
window_.clear();
|
||||
window_.draw(text_);
|
||||
window_.display();
|
||||
$window.clear();
|
||||
$window.draw($text);
|
||||
$window.display();
|
||||
}
|
||||
|
||||
int GUI::main() {
|
||||
create_renderer();
|
||||
|
||||
while(window_.isOpen()) {
|
||||
while($window.isOpen()) {
|
||||
render_scene();
|
||||
handle_events();
|
||||
}
|
||||
|
|
|
|||
32
gui.hpp
32
gui.hpp
|
|
@ -24,22 +24,22 @@ enum class Value {
|
|||
|
||||
class GUI {
|
||||
sf::Color color(Value val);
|
||||
Map game_map_;
|
||||
sf::SoundBuffer hit_buf_;
|
||||
sf::Sound hit_sound_;
|
||||
bool show_paths_ = false;
|
||||
string status_text_ = "NOT DEAD";
|
||||
Entity player_;
|
||||
Entity enemy_;
|
||||
Point goal_;
|
||||
Component document_;
|
||||
Component map_view_;
|
||||
Canvas canvas_;
|
||||
sf::Font font_;
|
||||
sf::Text text_;
|
||||
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter_;
|
||||
sf::RenderWindow window_;
|
||||
Screen screen_;
|
||||
Map $game_map;
|
||||
sf::SoundBuffer $hit_buf;
|
||||
sf::Sound $hit_sound;
|
||||
bool $show_paths = false;
|
||||
string $status_text = "NOT DEAD";
|
||||
Entity $player;
|
||||
Entity $enemy;
|
||||
Point $goal;
|
||||
Component $document;
|
||||
Component $map_view;
|
||||
Canvas $canvas;
|
||||
sf::Font $font;
|
||||
sf::Text $text;
|
||||
std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> $converter;
|
||||
sf::RenderWindow $window;
|
||||
Screen $screen;
|
||||
|
||||
public:
|
||||
GUI();
|
||||
|
|
|
|||
96
map.cpp
96
map.cpp
|
|
@ -5,8 +5,8 @@
|
|||
#include <random>
|
||||
#include <utility>
|
||||
|
||||
std::random_device g_rng;
|
||||
std::mt19937 g_generator(g_rng());
|
||||
std::random_device $RNG;
|
||||
std::mt19937 $GENERATOR($RNG());
|
||||
|
||||
using std::vector, std::pair;
|
||||
using namespace fmt;
|
||||
|
|
@ -45,20 +45,20 @@ inline void add_neighbors(PointList &neighbors, Matrix &closed, size_t y, size_t
|
|||
* can run make_rooms and generate on. It will
|
||||
* NOT be valid until you actually run generate.
|
||||
*/
|
||||
Map::Map(size_t width, size_t height) : limit_(1000) {
|
||||
walls_ = Matrix(height, MatrixRow(width, INV_WALL));
|
||||
input_map_ = Matrix(height, MatrixRow(width, 1));
|
||||
Map::Map(size_t width, size_t height) : $limit(1000) {
|
||||
$walls = Matrix(height, MatrixRow(width, INV_WALL));
|
||||
$input_map = Matrix(height, MatrixRow(width, 1));
|
||||
}
|
||||
|
||||
void Map::make_paths() {
|
||||
size_t h = input_map_.size();
|
||||
size_t w = input_map_[0].size();
|
||||
size_t h = $input_map.size();
|
||||
size_t w = $input_map[0].size();
|
||||
|
||||
// Initialize the new array with every pixel at limit distance
|
||||
// NOTE: this is normally ones() * limit
|
||||
int limit = limit_ == 0 ? h * w : limit_;
|
||||
int limit = $limit == 0 ? h * w : $limit;
|
||||
Matrix new_arr = Matrix(h, MatrixRow(w, limit));
|
||||
Matrix closed = walls_;
|
||||
Matrix closed = $walls;
|
||||
PointList starting_pixels;
|
||||
PointList open_pixels;
|
||||
|
||||
|
|
@ -66,7 +66,7 @@ void Map::make_paths() {
|
|||
for(size_t counter = 0; counter < h * w; counter++) {
|
||||
size_t x = counter % w;
|
||||
size_t y = counter / w;
|
||||
if(input_map_[y][x] == 0) {
|
||||
if($input_map[y][x] == 0) {
|
||||
new_arr[y][x] = 0;
|
||||
closed[y][x] = 1;
|
||||
starting_pixels.push_back({.x=x,.y=y});
|
||||
|
|
@ -94,7 +94,7 @@ void Map::make_paths() {
|
|||
new_arr[sp.y][sp.x] = counter;
|
||||
}
|
||||
|
||||
paths_ = new_arr;
|
||||
$paths = new_arr;
|
||||
}
|
||||
|
||||
void Map::make_room(size_t origin_x, size_t origin_y, size_t w, size_t h) {
|
||||
|
|
@ -104,10 +104,10 @@ void Map::make_room(size_t origin_x, size_t origin_y, size_t w, size_t h) {
|
|||
dbc::pre("h out of bounds", h <= height());
|
||||
|
||||
for(size_t y = origin_y; y < origin_y + h; ++y) {
|
||||
dbc::check(y < walls_.size(), "y is out of bounds");
|
||||
dbc::check(y < $walls.size(), "y is out of bounds");
|
||||
for(size_t x = origin_x; x < origin_x + w; ++x) {
|
||||
dbc::check(x < walls_[y].size(), "x is out of bounds");
|
||||
walls_[y][x] = INV_SPACE;
|
||||
dbc::check(x < $walls[y].size(), "x is out of bounds");
|
||||
$walls[y][x] = INV_SPACE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -117,13 +117,13 @@ inline int make_split(Room &cur, bool horiz) {
|
|||
int min = dimension / 4;
|
||||
int max = dimension - min;
|
||||
std::uniform_int_distribution<int> rand_dim(min, max);
|
||||
return rand_dim(g_generator);
|
||||
return rand_dim($GENERATOR);
|
||||
}
|
||||
|
||||
void Map::partition_map(Room &cur, int depth) {
|
||||
if(cur.width >= 5 && cur.width <= 10 &&
|
||||
cur.height >= 5 && cur.height <= 10) {
|
||||
rooms_.push_back(cur);
|
||||
$rooms.push_back(cur);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -158,7 +158,7 @@ void Map::partition_map(Room &cur, int depth) {
|
|||
}
|
||||
|
||||
void Map::place_rooms(Room &cur) {
|
||||
for(auto &cur : rooms_) {
|
||||
for(auto &cur : $rooms) {
|
||||
cur.x += 2;
|
||||
cur.y += 2;
|
||||
cur.width -= 4;
|
||||
|
|
@ -178,7 +178,7 @@ bool Map::neighbors(Point &out, bool greater) {
|
|||
}};
|
||||
|
||||
int zero_i = -1;
|
||||
int cur = paths_[out.y][out.x];
|
||||
int cur = $paths[out.y][out.x];
|
||||
|
||||
if(cur == 1000) {
|
||||
// BUG: sometimes the generation clips a door and we
|
||||
|
|
@ -188,7 +188,7 @@ bool Map::neighbors(Point &out, bool greater) {
|
|||
|
||||
for(int i = 0; i < 4; ++i) {
|
||||
Point dir = dirs[i];
|
||||
int diff = inmap(dir.x, dir.y) ? cur - paths_[dir.y][dir.x] : -1000;
|
||||
int diff = inmap(dir.x, dir.y) ? cur - $paths[dir.y][dir.x] : -1000;
|
||||
|
||||
if(diff == 1) {
|
||||
out = {.x=dir.x, .y=dir.y};
|
||||
|
|
@ -211,8 +211,8 @@ bool Map::inmap(size_t x, size_t y) {
|
|||
}
|
||||
|
||||
void Map::set_door(Room &room, int value) {
|
||||
walls_[room.entry.y][room.entry.x] = value;
|
||||
walls_[room.exit.y][room.exit.x] = value;
|
||||
$walls[room.entry.y][room.entry.x] = value;
|
||||
$walls[room.exit.y][room.exit.x] = value;
|
||||
}
|
||||
|
||||
void rand_side(Room &room, Point &door) {
|
||||
|
|
@ -220,22 +220,22 @@ void rand_side(Room &room, Point &door) {
|
|||
std::uniform_int_distribution<int> rand_x(0, room.width - 1);
|
||||
std::uniform_int_distribution<int> rand_y(0, room.height - 1);
|
||||
|
||||
switch(rand_side(g_generator)) {
|
||||
switch(rand_side($GENERATOR)) {
|
||||
case 0: // north
|
||||
door.x = room.x + rand_x(g_generator);
|
||||
door.x = room.x + rand_x($GENERATOR);
|
||||
door.y = room.y-1;
|
||||
break;
|
||||
case 1: // south
|
||||
door.x = room.x + rand_x(g_generator);
|
||||
door.x = room.x + rand_x($GENERATOR);
|
||||
door.y = room.y + room.height;
|
||||
break;
|
||||
case 2: // east
|
||||
door.x = room.x + room.width;
|
||||
door.y = room.y + rand_y(g_generator);
|
||||
door.y = room.y + rand_y($GENERATOR);
|
||||
break;
|
||||
case 3: // west
|
||||
door.x = room.x - 1;
|
||||
door.y = room.y + rand_y(g_generator);
|
||||
door.y = room.y + rand_y($GENERATOR);
|
||||
break;
|
||||
default:
|
||||
dbc::sentinel("impossible side");
|
||||
|
|
@ -249,15 +249,15 @@ void Map::add_door(Room &room) {
|
|||
|
||||
bool Map::walk(Point &src, Point &target) {
|
||||
// this sets the target for the path
|
||||
dbc::check(input_map_[target.y][target.x] == 0, "target point not set to 0");
|
||||
dbc::check($input_map[target.y][target.x] == 0, "target point not set to 0");
|
||||
|
||||
walls_[src.y][src.x] = INV_WALL;
|
||||
walls_[target.y][target.x] = INV_WALL;
|
||||
$walls[src.y][src.x] = INV_WALL;
|
||||
$walls[target.y][target.x] = INV_WALL;
|
||||
|
||||
// for the walk this needs to be walls since it's inverted?
|
||||
dbc::check(walls_[src.y][src.x] == INV_WALL,
|
||||
dbc::check($walls[src.y][src.x] == INV_WALL,
|
||||
"src room has a wall at exit door");
|
||||
dbc::check(walls_[target.y][target.x] == INV_WALL,
|
||||
dbc::check($walls[target.y][target.x] == INV_WALL,
|
||||
"target room has a wall at entry door");
|
||||
|
||||
make_paths();
|
||||
|
|
@ -266,11 +266,11 @@ bool Map::walk(Point &src, Point &target) {
|
|||
int count = 0;
|
||||
|
||||
do {
|
||||
walls_[out.y][out.x] = INV_SPACE;
|
||||
$walls[out.y][out.x] = INV_SPACE;
|
||||
found = neighbors(out, true);
|
||||
|
||||
if(paths_[out.y][out.x] == 0) {
|
||||
walls_[out.y][out.x] = INV_SPACE;
|
||||
if($paths[out.y][out.x] == 0) {
|
||||
$walls[out.y][out.x] = INV_SPACE;
|
||||
return true;
|
||||
}
|
||||
} while(found && out.x > 0 && out.y > 0 && ++count < 100);
|
||||
|
|
@ -279,17 +279,17 @@ bool Map::walk(Point &src, Point &target) {
|
|||
}
|
||||
|
||||
void Map::set_target(Point &at, int value) {
|
||||
input_map_[at.y][at.x] = 0;
|
||||
$input_map[at.y][at.x] = 0;
|
||||
}
|
||||
|
||||
void Map::clear_target(Point &at) {
|
||||
input_map_[at.y][at.x] = 1;
|
||||
$input_map[at.y][at.x] = 1;
|
||||
}
|
||||
|
||||
Point Map::place_entity(size_t room_index) {
|
||||
dbc::check(room_index < rooms_.size(), "room_index is out of bounds, not enough rooms");
|
||||
dbc::check(room_index < $rooms.size(), "room_index is out of bounds, not enough rooms");
|
||||
|
||||
Room &start = rooms_[room_index];
|
||||
Room &start = $rooms[room_index];
|
||||
return {start.x+1, start.y+1};
|
||||
}
|
||||
|
||||
|
|
@ -304,9 +304,9 @@ void Map::generate() {
|
|||
partition_map(root, 10);
|
||||
place_rooms(root);
|
||||
|
||||
for(size_t i = 0; i < rooms_.size() - 1; i++) {
|
||||
Room &src = rooms_[i];
|
||||
Room &target = rooms_[i+1];
|
||||
for(size_t i = 0; i < $rooms.size() - 1; i++) {
|
||||
Room &src = $rooms[i];
|
||||
Room &target = $rooms[i+1];
|
||||
set_target(target.entry);
|
||||
bool found = walk(src.exit, target.entry);
|
||||
if(!found) {
|
||||
|
|
@ -315,8 +315,8 @@ void Map::generate() {
|
|||
clear_target(target.entry);
|
||||
}
|
||||
|
||||
Room &src = rooms_.back();
|
||||
Room &target = rooms_.front();
|
||||
Room &src = $rooms.back();
|
||||
Room &target = $rooms.front();
|
||||
|
||||
set_target(target.entry);
|
||||
walk(src.exit, target.entry);
|
||||
|
|
@ -324,17 +324,17 @@ void Map::generate() {
|
|||
|
||||
for(size_t y = 0; y < height(); ++y) {
|
||||
for(size_t x = 0; x < width(); ++x) {
|
||||
walls_[y][x] = !walls_[y][x];
|
||||
$walls[y][x] = !$walls[y][x];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool Map::iswall(size_t x, size_t y) {
|
||||
return walls_[y][x] == WALL_VALUE;
|
||||
return $walls[y][x] == WALL_VALUE;
|
||||
}
|
||||
|
||||
void Map::dump() {
|
||||
dump_map("PATHS", paths_);
|
||||
dump_map("WALLS", walls_);
|
||||
dump_map("INPUT", input_map_);
|
||||
dump_map("PATHS", $paths);
|
||||
dump_map("WALLS", $walls);
|
||||
dump_map("INPUT", $input_map);
|
||||
}
|
||||
|
|
|
|||
30
map.hpp
30
map.hpp
|
|
@ -34,17 +34,17 @@ void dump_map(const std::string &msg, Matrix &map);
|
|||
void add_neighbors(Matrix &closed, size_t j, size_t i);
|
||||
|
||||
class Map {
|
||||
Matrix input_map_;
|
||||
Matrix walls_;
|
||||
Matrix paths_;
|
||||
std::vector<Room> rooms_;
|
||||
int limit_ = 0;
|
||||
Matrix $input_map;
|
||||
Matrix $walls;
|
||||
Matrix $paths;
|
||||
std::vector<Room> $rooms;
|
||||
int $limit = 0;
|
||||
public:
|
||||
|
||||
// make explicit
|
||||
Map(Matrix input_map, Matrix walls_map, int limit) :
|
||||
input_map_(input_map),
|
||||
walls_(walls_map), limit_(limit) {
|
||||
$input_map(input_map),
|
||||
$walls(walls_map), $limit(limit) {
|
||||
}
|
||||
|
||||
// make random
|
||||
|
|
@ -53,18 +53,18 @@ public:
|
|||
// disable copying
|
||||
Map(Map &map) = delete;
|
||||
|
||||
Matrix& paths() { return paths_; }
|
||||
Matrix& input_map() { return input_map_; }
|
||||
Matrix& walls() { return walls_; }
|
||||
int limit() { return limit_; }
|
||||
size_t width() { return walls_[0].size(); }
|
||||
size_t height() { return walls_.size(); }
|
||||
Matrix& paths() { return $paths; }
|
||||
Matrix& input_map() { return $input_map; }
|
||||
Matrix& walls() { return $walls; }
|
||||
int limit() { return $limit; }
|
||||
size_t width() { return $walls[0].size(); }
|
||||
size_t height() { return $walls.size(); }
|
||||
Room &room(size_t at) {
|
||||
return rooms_[at];
|
||||
return $rooms[at];
|
||||
}
|
||||
|
||||
size_t room_count() {
|
||||
return rooms_.size();
|
||||
return $rooms.size();
|
||||
}
|
||||
|
||||
void make_room(size_t origin_y, size_t origin_x, size_t width, size_t height);
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ enum class MyEvent {
|
|||
class MyFSM : public DeadSimpleFSM<MyState, MyEvent> {
|
||||
public:
|
||||
void event(MyEvent ev, string data="") {
|
||||
switch(_state) {
|
||||
switch($state) {
|
||||
FSM_STATE(MyState, START, ev);
|
||||
FSM_STATE(MyState, RUNNING, ev, data);
|
||||
FSM_STATE(MyState, END, ev);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue