Make game state more obvious, playable

Author: lefticus

src/main.cpp

@@ -26,22 +26,29 @@ static constexpr auto USAGE =
 )";
 
 
-struct GameBoard
+template<std::size_t Width, std::size_t Height> struct GameBoard
 {
-  static constexpr std::size_t width = 5;
-  static constexpr std::size_t height = 5;
+  static constexpr std::size_t width = Width;
+  static constexpr std::size_t height = Height;
 
   std::array<std::array<std::string, height>, width> strings;
   std::array<std::array<bool, height>, width> values{};
 
+  std::size_t move_count{0};
+
+  std::string &get_string(std::size_t x, std::size_t y) {
+  return      strings.at(x).at(y);
+  }
+
+
   void set(std::size_t x, std::size_t y, bool new_value)
   {
-    values[x][y] = new_value;
+    get(x,y) = new_value;
 
     if (new_value) {
-      strings[x][y] = " ON";
+      get_string(x,y) = " ON";
     } else {
-      strings[x][y] = "OFF";
+      get_string(x,y) = "OFF";
     }
   }
 
@@ -52,7 +59,9 @@ struct GameBoard
     }
   }
 
-  bool get(std::size_t x, std::size_t y) const { return values[x][y]; }
+  [[nodiscard]] bool get(std::size_t x, std::size_t y) const { return values.at(x).at(y); }
+
+  [[nodiscard]] bool &get(std::size_t x, std::size_t y) { return values.at(x).at(y); }
 
   GameBoard()
   {
@@ -70,13 +79,15 @@ struct GameBoard
 
   void press(std::size_t x, std::size_t y)
   {
+    ++move_count;
+    toggle(x, y);
     if (x > 0) { toggle(x - 1, y); }
     if (y > 0) { toggle(x, y - 1); }
     if (x < width - 1) { toggle(x + 1, y); }
     if (y < height - 1) { toggle(x, y + 1); }
   }
 
-  bool solved() const
+  [[nodiscard]] bool solved() const
   {
     for (std::size_t x = 0; x < width; ++x) {
       for (std::size_t y = 0; y < height; ++y) {
@@ -99,18 +110,24 @@ int main(int argc, const char **argv)
         myproject::cmake::project_version));// version string, acquired
                                             // from config.hpp via CMake
 
-    using namespace ftxui;
-    auto screen = ScreenInteractive::TerminalOutput();
+    auto screen = ftxui::ScreenInteractive::TerminalOutput();
+
+    GameBoard<3, 3> gb;
 
-    GameBoard gb;
+    std::string quit_text;
+
+    const auto update_quit_text = [&quit_text](const auto &game_board) {
+      quit_text = fmt::format("Quit ({} moves)", game_board.move_count);
+      if (game_board.solved()) { quit_text += " Solved!"; }
+    };
 
     const auto make_buttons = [&] {
       std::vector<ftxui::Component> buttons;
       for (std::size_t x = 0; x < gb.width; ++x) {
         for (std::size_t y = 0; y < gb.height; ++y) {
-          buttons.push_back(ftxui::Button(&gb.strings[x][y], [x, y, &gb, &screen] {
-            gb.press(x, y);
-            if (gb.solved()) { screen.ExitLoopClosure()(); }
+          buttons.push_back(ftxui::Button(&gb.get_string(x,y), [=, &gb] {
+            if (!gb.solved()) { gb.press(x, y); }
+            update_quit_text(gb);
           }));
         }
       }
@@ -119,10 +136,10 @@ int main(int argc, const char **argv)
 
     auto buttons = make_buttons();
 
-    auto container = Container::Horizontal(buttons);
+    auto quit_button = ftxui::Button(&quit_text, screen.ExitLoopClosure());
 
     auto make_layout = [&] {
-      std::vector<ftxui::Element> columns;
+      std::vector<ftxui::Element> rows;
 
       std::size_t idx = 0;
 
@@ -132,23 +149,35 @@ int main(int argc, const char **argv)
           row.push_back(buttons[idx]->Render());
           ++idx;
         }
-        columns.push_back(ftxui::hbox(std::move(row)));
+        rows.push_back(ftxui::hbox(std::move(row)));
       }
 
-      return ftxui::vbox(std::move(columns));
+      rows.push_back(ftxui::hbox({ quit_button->Render() }));
+
+      return ftxui::vbox(std::move(rows));
     };
 
-    std::mt19937 gen32;
+
+    static constexpr int randomization_iterations = 100;
+    static constexpr int random_seed = 42;
+
+    std::mt19937 gen32{random_seed}; // NOLINT
     std::uniform_int_distribution<std::size_t> x(static_cast<std::size_t>(0), gb.width - 1);
     std::uniform_int_distribution<std::size_t> y(static_cast<std::size_t>(0), gb.height - 1);
 
-    for (int i = 0; i < 100; ++i) { gb.press(x(gen32), y(gen32)); }
+    for (int i = 0; i < randomization_iterations; ++i) { gb.press(x(gen32), y(gen32)); }
+    gb.move_count = 0;
+    update_quit_text(gb);
 
-    auto renderer = Renderer(container, make_layout);
+    auto all_buttons = buttons;
+    all_buttons.push_back(quit_button);
+    auto container = ftxui::Container::Horizontal(all_buttons);
 
+    auto renderer = ftxui::Renderer(container, make_layout);
 
     screen.Loop(renderer);
 
+
   } catch (const std::exception &e) {
     fmt::print("Unhandled exception in main: {}", e.what());
   }