Enact game actions on locations

Author: lefticus

src/CMakeLists.txt

@@ -4,7 +4,7 @@ find_package(docopt CONFIG)
 find_package(lodepng CONFIG)
 
 # Generic test that uses conan libs
-add_executable(intro main.cpp color.hpp size.hpp point.hpp vector2d.hpp bitmap.hpp bitmap.cpp game_components.hpp)
+add_executable(intro main.cpp color.hpp size.hpp point.hpp vector2d.hpp bitmap.hpp bitmap.cpp game_components.hpp game.cpp game.hpp)
 target_link_libraries(
   intro
   PRIVATE project_options

src/game.cpp

@@ -0,0 +1,91 @@
+#include "game.hpp"
+#include "bitmap.hpp"
+#include "game_components.hpp"
+
+
+namespace lefticus::my_awesome_game {
+Game_Map make_map()// NOLINT cognitive complexity
+{
+  Game_Map map{ Size{ 10, 10 } };// NOLINT magic numbers
+
+  auto solid_draw = []([[maybe_unused]] Vector2D_Span<Color> &pixels,
+                      [[maybe_unused]] const Game &game,
+                      [[maybe_unused]] Point map_location) {
+    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
+      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
+        if (cur_x == 0 || cur_y == 0 || cur_x == pixels.size().width - 1 || cur_y == pixels.size().height - 1) {
+          pixels.at(Point{ cur_x, cur_y }) = Color{ 128, 128, 128, 255 };// NOLINT Magic numbers
+        } else {
+          switch ((game.clock.count() / 1000) % 2) {// NOLINT Magic numbers
+          case 0:
+            pixels.at(Point{ cur_x, cur_y }) = Color{ 255, 255, 255, 255 };// NOLINT Magic numbers
+            break;
+          case 1:// NOLINT Magic Numbers
+            pixels.at(Point{ cur_x, cur_y }) = Color{ 200, 240, 240, 255 };// NOLINT Magic numbers
+            break;
+          }
+        }
+      }
+    }
+  };
+
+  auto cannot_enter = [](const Game &, Point, Direction) -> bool { return false; };
+
+  auto empty_draw = []([[maybe_unused]] Vector2D_Span<Color> &pixels,
+                      [[maybe_unused]] const Game &game,
+                      [[maybe_unused]] Point map_location) {
+    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
+      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
+        pixels.at(Point{ cur_x, cur_y }) = Color{ 10, 10, 10, 255 };// NOLINT Magic numbers
+      }
+    }
+  };
+
+  for (std::size_t cur_x = 0; cur_x < map.locations.size().width; ++cur_x) {
+    for (std::size_t cur_y = 0; cur_y < map.locations.size().height; ++cur_y) {
+      map.locations.at(Point{ cur_x, cur_y }).draw = empty_draw;
+    }
+  }
+
+  map.locations.at(Point{ 2, 3 }).draw = solid_draw;
+  map.locations.at(Point{ 2, 3 }).can_enter = cannot_enter;
+  map.locations.at(Point{ 1, 4 }).draw = solid_draw;
+  map.locations.at(Point{ 1, 4 }).can_enter = cannot_enter;
+  map.locations.at(Point{ 0, 2 }).draw = solid_draw;
+  map.locations.at(Point{ 0, 2 }).can_enter = [](const Game &, Point, Direction direction) {
+    return direction == Direction::South;
+  };
+
+  map.locations.at(Point{0,3}).action = [](Game &game, Point, Direction) {
+    game.last_message = "There is a secret entrance to the north";
+  };
+
+
+  return map;
+}
+
+Game make_game()
+{
+  Game retval;
+  retval.maps.emplace("main", make_map());
+  retval.current_map = "main";
+  retval.tile_size = Size{ 8, 8 };// NOLINT Magic Number
+
+  Character player;
+  player.draw = [player_bitmap = load_png("player.png")]([[maybe_unused]] Vector2D_Span<Color> &pixels,
+                  [[maybe_unused]] const Game &game,
+                  [[maybe_unused]] Point map_location) {
+    // with with a fully saturated red at 50% alpha
+    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
+      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
+        pixels.at(Point{ cur_x, cur_y }) += player_bitmap.at(Point{ cur_x, cur_y });
+      }
+    }
+  };
+
+
+  retval.player = player;
+
+  return retval;
+}
+}// namespace lefticus::my_awesome_game

src/game.hpp

@@ -0,0 +1,11 @@
+#ifndef MY_AWESOME_GAME_GAME_HPP
+#define MY_AWESOME_GAME_GAME_HPP
+
+namespace lefticus::my_awesome_game {
+struct Game;
+Game make_game();
+}
+
+
+
+#endif// MY_AWESOME_GAME_GAME_HPP

src/game_components.hpp

@@ -60,6 +60,8 @@ struct Game
   std::string current_map;
   std::chrono::milliseconds clock;
   Size tile_size;
+
+  std::string last_message;
 };
 
 }

src/main.cpp

@@ -11,6 +11,7 @@
 
 #include "bitmap.hpp"
 #include "color.hpp"
+#include "game.hpp"
 #include "game_components.hpp"
 #include "point.hpp"
 #include "size.hpp"
@@ -22,86 +23,6 @@
 
 
 namespace lefticus::my_awesome_game {
-Game_Map make_map()// NOLINT congetive complexity
-{
-  Game_Map map{ Size{ 10, 10 } };// NOLINT magic numbers
-
-  auto solid_draw = []([[maybe_unused]] Vector2D_Span<Color> &pixels,
-                      [[maybe_unused]] const Game &game,
-                      [[maybe_unused]] Point map_location) {
-    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
-      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
-        if (cur_x == 0 || cur_y == 0 || cur_x == pixels.size().width - 1 || cur_y == pixels.size().height - 1) {
-          pixels.at(Point{ cur_x, cur_y }) = Color{ 128, 128, 128, 255 };// NOLINT Magic numbers
-        } else {
-          switch ((game.clock.count() / 1000) % 2) {// NOLINT Magic numbers
-          case 0:
-            pixels.at(Point{ cur_x, cur_y }) = Color{ 255, 255, 255, 255 };// NOLINT Magic numbers
-            break;
-          case 1:// NOLINT Magic Numbers
-            pixels.at(Point{ cur_x, cur_y }) = Color{ 200, 240, 240, 255 };// NOLINT Magic numbers
-            break;
-          }
-        }
-      }
-    }
-  };
-
-  auto cannot_enter = [](const Game &, Point, Direction) -> bool { return false; };
-
-  auto empty_draw = []([[maybe_unused]] Vector2D_Span<Color> &pixels,
-                      [[maybe_unused]] const Game &game,
-                      [[maybe_unused]] Point map_location) {
-    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
-      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
-        pixels.at(Point{ cur_x, cur_y }) = Color{ 10, 10, 10, 255 };// NOLINT Magic numbers
-      }
-    }
-  };
-
-  for (std::size_t cur_x = 0; cur_x < map.locations.size().width; ++cur_x) {
-    for (std::size_t cur_y = 0; cur_y < map.locations.size().height; ++cur_y) {
-      map.locations.at(Point{ cur_x, cur_y }).draw = empty_draw;
-    }
-  }
-
-  map.locations.at(Point{ 2, 3 }).draw = solid_draw;
-  map.locations.at(Point{ 2, 3 }).can_enter = cannot_enter;
-  map.locations.at(Point{ 1, 4 }).draw = solid_draw;
-  map.locations.at(Point{ 1, 4 }).can_enter = cannot_enter;
-  map.locations.at(Point{ 0, 2 }).draw = solid_draw;
-  map.locations.at(Point{ 0, 2 }).can_enter = [](const Game &, Point, Direction direction) {
-    return direction == Direction::South;
-  };
-
-
-  return map;
-}
-
-Game make_game()
-{
-  Game retval;
-  retval.maps.emplace("main", make_map());
-  retval.current_map = "main";
-  retval.tile_size = Size{ 8, 8 };// NOLINT Magic Number
-
-  Character player;
-  player.draw = [player_bitmap = load_png("player.png")]([[maybe_unused]] Vector2D_Span<Color> &pixels,
-                  [[maybe_unused]] const Game &game,
-                  [[maybe_unused]] Point map_location) {
-    // with with a fully saturated red at 50% alpha
-    for (std::size_t cur_x = 0; cur_x < pixels.size().width; ++cur_x) {
-      for (std::size_t cur_y = 0; cur_y < pixels.size().height; ++cur_y) {
-        pixels.at(Point{ cur_x, cur_y }) += player_bitmap.at(Point{ cur_x, cur_y });
-      }
-    }
-  };
-
-
-  retval.player = player;
-
-  return retval;
-}
 
 
 void draw(Bitmap &viewport, Point map_center, const Game &game, const Game_Map &map)
@@ -203,6 +124,9 @@ void game_iteration_canvas()
 
         if (game.maps.at(game.current_map).can_enter_from(game, location, from)) {
           game.player.map_location = location;
+          auto action = game.maps.at(game.current_map).locations.at(location).action;
+
+          if (action) { action(game, location, from); }
         }
       }
     }();
@@ -229,11 +153,11 @@ void game_iteration_canvas()
     last_time = new_time;
 
     // now actually draw the game elements
-    return ftxui::hbox({ bm | ftxui::border,
+    return ftxui::vbox({ftxui::hbox({ bm | ftxui::border,
       ftxui::vbox({ ftxui::text("Frame: " + std::to_string(counter)),
         ftxui::text("FPS: " + std::to_string(fps)),
         ftxui::text("Character: " + last_character),
-        small_bm | ftxui::border }) });
+        small_bm | ftxui::border }) }), ftxui::text("Message: " + game.last_message)});
   };
 
   auto container = ftxui::Container::Vertical({});