Basic learning game working

lefticus · lefticus · commit 22c8a78bd8ae · 2022-05-05T13:04:01.000-06:00
diff --git a/src/game.cpp b/src/game.cpp
@@ -8,36 +8,56 @@ 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 empty_draw =
+    [](Vector2D_Span<Color> &pixels, [[maybe_unused]] const Game &game, [[maybe_unused]] Point map_location) {
+      fill(pixels, Color{ 5, 5, 25, 255 });// NOLINT magic number
+    };
 
   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
-      }
+  auto water = [](
+                 Vector2D_Span<Color> &pixels, [[maybe_unused]] const Game &game, [[maybe_unused]] Point map_location) {
+    fill(pixels, Color{ 0, 0, 250, 255 });// NOLINT magic number
+  };
+
+
+  auto wall_draw = []([[maybe_unused]] Vector2D_Span<Color> &pixels,
+                     [[maybe_unused]] const Game &game,
+                     [[maybe_unused]] Point map_location) {
+    static constexpr auto wall_color = Color{ 100, 100, 100, 128 };
+
+
+    switch ((game.clock.count() / 1000) % 2) {// NOLINT magic number
+    case 0:
+      fill(pixels, Color{ 64, 128, 64, 255 });// NOLINT magic number
+      break;
+    case 1:
+      fill(pixels, Color{ 128, 64, 64, 255 });// NOLINT magic number
+      break;
+    }
+
+
+    if (!game.maps.at(game.current_map).can_enter_from(game, map_location, Direction::East)) {
+      fill_line(pixels,
+        Point{ pixels.size().width - 1, 0 },
+        Point{ pixels.size().width - 1, pixels.size().height - 1 },
+        wall_color);
+    }
+
+    if (!game.maps.at(game.current_map).can_enter_from(game, map_location, Direction::West)) {
+      fill_line(pixels, Point{ 0, 0 }, Point{ 0, pixels.size().height - 1 }, wall_color);
+    }
+
+    if (!game.maps.at(game.current_map).can_enter_from(game, map_location, Direction::North)) {
+      fill_line(pixels, Point{ 0, 0 }, Point{ pixels.size().width - 1, 0 }, wall_color);
+    }
+
+    if (!game.maps.at(game.current_map).can_enter_from(game, map_location, Direction::South)) {
+      fill_line(pixels,
+        Point{ 0, pixels.size().height - 1 },
+        Point{ pixels.size().width - 1, pixels.size().height - 1 },
+        wall_color);
     }
   };
 
@@ -47,26 +67,47 @@ Game_Map make_map()// NOLINT cognitive complexity
     }
   }
 
-  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;
+  fill_border(map.locations, Location{ {}, {}, water, cannot_enter });
+
+  const auto Flashing_Tile = Location{ {}, {}, wall_draw, cannot_enter };
+
+  constexpr static auto special_location = Point{ 8, 8 };
+
+  map.locations.at(Point{ 3, 4 }) = Flashing_Tile;
+  map.locations.at(Point{ 2, 5 }) = Flashing_Tile;// NOLINT magic numbers
+  map.locations.at(Point{ 1, 2 }) = Flashing_Tile;
+  map.locations.at(Point{ 8, 6 }) = Flashing_Tile;// NOLINT magic numbers
+  map.locations.at(Point{ 5, 5 }) = Flashing_Tile;// NOLINT magic numbers
+
+  map.locations.at(Point{ 2, 1 }).enter_action = [](Game &game, Point, Direction) {
+    game.last_message = "Hint: go to location {4,3}";
   };
 
-  map.locations.at(Point{0,3}).enter_action = [](Game &game, Point, Direction) {
-    game.last_message = "There is a secret entrance to the north";
+  map.locations.at(Point{ 4, 3 }).enter_action = [](Game &game, Point, Direction) {
+    game.last_message = "Hint: go to location {8,8}";
   };
-  map.locations.at(Point{ 0, 3 }).exit_action = [](Game &game, Point, Direction) {
-    game.last_message = "";
+
+  map.locations.at(Point{ 7, 7 }).enter_action// NOLINT
+    = [](Game &game, Point, Direction) { game.last_message = "A wall is blocking your way"; };
+  map.locations.at(Point{ 8, 7 }).enter_action// NOLINT
+    = [](Game &game, Point, Direction) { game.last_message = "You need to remove the wall"; };
+  map.locations.at(Point{ 7, 8 }).enter_action// NOLINT
+    = [](Game &game, Point, Direction) { game.last_message = "Look for 'special_location' in the source code"; };
+
+  map.locations.at(special_location) = Flashing_Tile;
+  map.locations.at(special_location).can_enter = [](const Game &, Point, Direction direction) {
+    return direction == Direction::South || direction == Direction::East;
   };
 
-  map.locations.at(Point{2,0}).enter_action = [](Game &game, Point, Direction) {
+  map.locations.at(special_location).exit_action = [](Game &game, Point, Direction) { game.last_message = ""; };
+
+  map.locations.at(special_location).enter_action = [](Game &game, Point, Direction) {
+    game.last_message = "You found the secret room!";
     Menu menu;
-    menu.items.push_back(Menu::MenuItem{"Hello World", [](auto &){}});
-    menu.items.push_back(Menu::MenuItem{ "Exit Menu", [](Game &menu_action_game) {menu_action_game.clear_menu();}});
+    menu.items.push_back(
+      Menu::MenuItem{ "Continue Game", [](Game &menu_action_game) { menu_action_game.clear_menu(); } });
+    menu.items.push_back(
+      Menu::MenuItem{ "Exit Game", [](Game &menu_action_game) { menu_action_game.exit_game = true; } });
     game.set_menu(menu);
   };
 
@@ -76,26 +117,38 @@ Game_Map make_map()// NOLINT cognitive complexity
 
 Game make_game()
 {
-  Game retval;
+  Game retval{};
   retval.maps.emplace("main", make_map());
   retval.current_map = "main";
   retval.tile_size = Size{ 8, 8 };// NOLINT Magic Number
 
+  retval.variables["Task"] = "Exit game";
+  retval.display_variables.emplace_back("Task");
+
   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 });
+  player.map_location = { 1, 1 };
+  player.draw =
+    [](Vector2D_Span<Color> &pixels, [[maybe_unused]] const Game &game, [[maybe_unused]] Point map_location) {
+      for (std::size_t cur_x = 2; cur_x < pixels.size().width - 2; ++cur_x) {
+        for (std::size_t cur_y = 2; cur_y < pixels.size().height - 2; ++cur_y) {
+          if ((cur_x == 2 && cur_y == 2) || (cur_x == 2 && cur_y == pixels.size().height - 3)
+              || (cur_x == pixels.size().width - 3 && cur_y == pixels.size().height - 3)
+              || (cur_x == pixels.size().width - 3 && cur_y == 2)) {
+            pixels.at(Point{ cur_x, cur_y }) += Color{ 128, 128, 0, 64 };// NOLINT
+          } else {
+            pixels.at(Point{ cur_x, cur_y }) += Color{ 128, 128, 0, 255 };// NOLINT
+          }
+        }
       }
-    }
-  };
+    };
 
 
   retval.player = player;
 
+  retval.popup_message =
+    "Welcome to 'Learning C++ With Game Hacking!' Your job is to get into the special square in the bottom right "
+    "corner of the map. But to do that you'll need to modify the source code!";
+
   return retval;
 }
 }// namespace lefticus::my_awesome_game
diff --git a/src/game_components.hpp b/src/game_components.hpp
@@ -59,6 +59,11 @@ struct Menu
 
 using Variable = std::variant<double, std::int64_t, std::string>;
 
+inline std::string to_string(const Variable &variable)
+{
+  return std::visit([](const auto &value) { return fmt::format("{}", value); }, variable);
+}
+
 struct Game
 {
 
@@ -73,6 +78,12 @@ struct Game
   Size tile_size;
 
   std::string last_message;
+  std::string popup_message;
+
+
+  bool exit_game = false;
+
+  [[nodiscard]] bool has_popup_message() const { return !popup_message.empty(); }
 
   [[nodiscard]] bool has_new_menu() const { return menu_is_new; }
 
diff --git a/src/main.cpp b/src/main.cpp
@@ -28,7 +28,7 @@ namespace lefticus::my_awesome_game {
 void draw(Bitmap &viewport, Point map_center, const Game &game, const Game_Map &map)
 {
   const auto num_wide = viewport.pixels.size().width / game.tile_size.width;
-  const auto num_high = viewport.pixels.size().width / game.tile_size.height;
+  const auto num_high = viewport.pixels.size().height / game.tile_size.height;
 
   const auto x_offset = num_wide / 2;
   const auto y_offset = num_high / 2;
@@ -37,7 +37,7 @@ void draw(Bitmap &viewport, Point map_center, const Game &game, const Game_Map &
   const auto min_y = y_offset;
 
   const auto max_x = map.locations.size().width - x_offset - (num_wide % 2);
-  const auto max_y = map.locations.size().height - y_offset - (num_wide % 2);
+  const auto max_y = map.locations.size().height - y_offset - (num_high % 2);
 
   const auto center_map_location =
     Point{ std::clamp(map_center.x, min_x, max_x), std::clamp(map_center.y, min_y, max_y) };
@@ -93,9 +93,11 @@ void game_iteration_canvas()// NOLINT cognitive complexity
 
   Displayed_Menu current_menu{ Menu{}, game };
 
+  auto clear_popup_button = ftxui::Button("OK", [&]() { game.popup_message.clear(); });
+
   // this should probably have a `bitmap` helper function that does what you expect
   // similar to the other parts of FTXUI
-  auto bm = std::make_shared<Bitmap>(Size{ 40, 40 });// NOLINT magic numbers
+  auto bm = std::make_shared<Bitmap>(Size{ 64, 40 });// NOLINT magic numbers
   auto small_bm = std::make_shared<Bitmap>(Size{ 6, 6 });// NOLINT magic numbers
 
   double fps = 0;
@@ -120,9 +122,7 @@ void game_iteration_canvas()// NOLINT cognitive complexity
     game.clock = game_clock;
 
     [&] {
-      if (game.has_menu()) {
-        return;
-      }
+      if (game.has_menu()) { return; }
 
       if (current_event != last_event) {
         auto location = game.player.map_location;
@@ -173,40 +173,88 @@ void game_iteration_canvas()// NOLINT cognitive complexity
   auto container = ftxui::Container::Vertical({});
 
   auto key_press = ftxui::CatchEvent(container, [&](const ftxui::Event &event) {
-    if (game.has_menu()) {
-      return false;
-    } else {
-      last_event = std::exchange(current_event, event);
-      return true;
-    }
+    last_event = std::exchange(current_event, event);
+    return false;
   });
 
   auto make_layout = [&] {
     // This code actually processes the draw event
     const auto new_time = std::chrono::steady_clock::now();
 
-    if (game.has_new_menu()) { current_menu = Displayed_Menu{ game.get_menu(), game };
-      key_press->DetachAllChildren();
-      key_press->Add(current_menu.buttons);
-    }
 
     ++counter;
+
+    if (game.exit_game) { screen.ExitLoopClosure()(); }
+
     // we will dispatch to the game_iteration function, where the work happens
     game_iteration(new_time - last_time);
     last_time = new_time;
 
+
+    ftxui::Elements text_components;
+    text_components.push_back(ftxui::text("Frame: " + std::to_string(counter)));
+    text_components.push_back(
+      ftxui::text(fmt::format("Location: {{{},{}}}", game.player.map_location.x, game.player.map_location.y)));
+
+    for (const auto &variable : game.display_variables) {
+      if (game.variables.contains(variable)) {
+        text_components.push_back(ftxui::text(fmt::format("{}: {}", variable, to_string(game.variables.at(variable)))));
+      }
+    }
+
     // now actually draw the game elements
-    return ftxui::vbox({ ftxui::hbox({ (game.has_menu() ? current_menu.buttons->Render() : 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 }) }),
-      ftxui::text("Message: " + game.last_message) });
+    return ftxui::vbox({ ftxui::hbox({ bm | ftxui::border, ftxui::vbox(std::move(text_components)) | ftxui::border }),
+      ftxui::text("Message: " + game.last_message) | ftxui::border });
   };
 
 
+  auto game_renderer = ftxui::Renderer(key_press, make_layout);
+
+  auto menu_renderer =
+    ftxui::Renderer(current_menu.buttons, [&] { return current_menu.buttons->Render() | ftxui::border; });
+
+  auto popup_renderer = ftxui::Renderer(clear_popup_button, [&] {
+    return ftxui::vbox({ ftxui::paragraphAlignCenter(game.popup_message), clear_popup_button->Render() })
+           | ftxui::border;
+  });
+
+
+  int depth = 0;
+
+  auto main_container = ftxui::Container::Tab({ game_renderer, menu_renderer, popup_renderer }, &depth);
+
+  auto main_renderer = ftxui::Renderer(main_container, [&] {
+    if (game.has_popup_message()) {
+      depth = 2;
+    } else if (game.has_menu()) {
+      depth = 1;
+    } else {
+      depth = 0;
+    }
+
+    if (game.has_new_menu()) {
+      current_menu = Displayed_Menu{ game.get_menu(), game };
+      menu_renderer->DetachAllChildren();
+      menu_renderer->Add(current_menu.buttons);
+    }
+
+    ftxui::Element document = game_renderer->Render();
+
+    if (depth > 0) {
+      if (game.has_menu()) {
+        document = ftxui::dbox({ document, menu_renderer->Render() | ftxui::clear_under | ftxui::center });
+      }
+    }
+
+    if (depth > 1) {
+      if (game.has_popup_message()) {
+        document = ftxui::dbox({ document, popup_renderer->Render() | ftxui::clear_under | ftxui::center });
+      }
+    }
+
+    return document;
+  });
 
-  auto renderer = ftxui::Renderer(game.has_menu() ? current_menu.buttons : key_press, make_layout);
 
   std::atomic<bool> refresh_ui_continue = true;
 
@@ -220,7 +268,7 @@ void game_iteration_canvas()// NOLINT cognitive complexity
     }
   });
 
-  screen.Loop(renderer);
+  screen.Loop(main_renderer);
 
   refresh_ui_continue = false;
   refresh_ui.join();
diff --git a/src/vector2d.hpp b/src/vector2d.hpp
