Code reorganization

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)
+add_executable(intro main.cpp color.hpp size.hpp point.hpp vector2d.hpp bitmap.hpp bitmap.cpp game_components.hpp)
 target_link_libraries(
   intro
   PRIVATE project_options

src/bitmap.cpp

@@ -0,0 +1,38 @@
+#include <lodepng.h>
+
+#include "bitmap.hpp"
+
+namespace lefticus::my_awesome_game {
+Vector2D<Color> load_png(const std::filesystem::path &filename)
+{
+  std::vector<unsigned char> image;// the raw pixels
+  unsigned width{};
+  unsigned height{};
+
+  // decode
+  unsigned error = lodepng::decode(image, width, height, filename.string());
+
+  // if there's an error, display it
+  if (error != 0) {
+    throw std::runtime_error(fmt::format("lodepng decoder error {}: {}", error, lodepng_error_text(error)));
+  }
+
+  // the pixels are now in the vector "image", 4 bytes per pixel, ordered RGBARGBA..., use it as texture, draw it, ...
+  //
+  Vector2D<Color> results{ Size{ static_cast<std::size_t>(width), static_cast<std::size_t>(height) } };
+
+  std::size_t position = 0;
+  for (std::size_t cur_y = 0; cur_y < results.size().height; ++cur_y) {
+    for (std::size_t cur_x = 0; cur_x < results.size().width; ++cur_x) {
+      auto &color = results.at(Point{ cur_x, cur_y });
+      // cppcheck is wrong about this.
+      color.R = image[position++];// cppcheck-suppress danglingTempReference
+      color.G = image[position++];// cppcheck-suppress danglingTempReference
+      color.B = image[position++];// cppcheck-suppress danglingTempReference
+      color.A = image[position++];// cppcheck-suppress danglingTempReference
+    }
+  }
+
+  return results;
+}
+}// namespace lefticus::my_awesome_game

src/bitmap.hpp

@@ -0,0 +1,47 @@
+#ifndef MY_AWESOME_GAME_BITMAP_HPP
+#define MY_AWESOME_GAME_BITMAP_HPP
+
+#include <filesystem>
+#include <ftxui/dom/node.hpp>
+
+#include "color.hpp"
+#include "size.hpp"
+#include "vector2d.hpp"
+#include <fmt/format.h>
+
+namespace lefticus::my_awesome_game {
+
+// A simple way of representing a bitmap on screen using only characters
+struct Bitmap : ftxui::Node
+{
+  explicit Bitmap(const Size size) : pixels(size) {}
+
+  void ComputeRequirement() override
+  {
+    requirement_ = ftxui::Requirement{ .min_x = static_cast<int>(pixels.size().width),
+      .min_y = static_cast<int>(pixels.size().height / 2),
+      .selected_box{ 0, 0, 0, 0 } };
+  }
+
+  void Render(ftxui::Screen &screen) override
+  {
+    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 / 2; ++cur_y) {
+        auto &ftxui_pixel = screen.PixelAt(box_.x_min + static_cast<int>(cur_x), box_.y_min + static_cast<int>(cur_y));
+        ftxui_pixel.character = "▄";
+        const auto &top_color = pixels.at(Point{ cur_x, cur_y * 2 });
+        const auto &bottom_color = pixels.at(Point{ cur_x, cur_y * 2 + 1 });
+        ftxui_pixel.background_color = ftxui::Color{ top_color.R, top_color.G, top_color.B };
+        ftxui_pixel.foreground_color = ftxui::Color{ bottom_color.R, bottom_color.G, bottom_color.B };
+      }
+    }
+  }
+
+  Vector2D<Color> pixels;
+};
+
+Vector2D<Color> load_png(const std::filesystem::path &filename);
+
+}// namespace lefticus::my_awesome_game
+
+#endif// MY_AWESOME_GAME_BITMAP_HPP

src/color.hpp

@@ -0,0 +1,88 @@
+#ifndef MY_AWESOME_GAME_COLOR_HPP
+#define MY_AWESOME_GAME_COLOR_HPP
+
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+
+// Todo: move this into `tools` project?
+namespace lefticus::my_awesome_game {
+template<typename Type> struct Basic_Color;
+
+template<typename OutType, typename InType>
+[[nodiscard]] constexpr Basic_Color<OutType> color_cast(Basic_Color<InType> input) noexcept
+{
+  if constexpr (std::is_same_v<OutType, InType>) { return input; }
+
+  constexpr auto to_function = [] {
+    if constexpr (std::is_floating_point_v<InType>) {
+      if constexpr (std::is_floating_point_v<OutType>) {
+        // just static cast from one floating point to_function another
+        return [](const auto input_color_component) { return static_cast<OutType>(input_color_component); };
+      } else {
+        // from floating point to_function integral
+        // we want to_function scale 0-1 to_function 0-maxint for given type
+        return [](const auto input_color_component) {
+          return static_cast<OutType>(std::llround(input_color_component * std::numeric_limits<OutType>::max()));
+        };
+      }
+    } else {
+      // input is not floating point
+      if constexpr (std::is_integral_v<OutType>) {
+        // and neither is output
+        return [](const auto input_color_component) {
+          // scale 0-1, then scale that to_function output type
+          return static_cast<OutType>(std::llround(
+            (static_cast<double>(input_color_component) / static_cast<double>(std::numeric_limits<InType>::max()))
+            * static_cast<double>(std::numeric_limits<OutType>::max())));
+        };
+      } else {
+        // output is floating point
+        return [](const auto input_color_component) {
+          return static_cast<OutType>(input_color_component) / static_cast<OutType>(std::numeric_limits<InType>::max());
+        };
+      }
+    }
+  }();
+
+  return Basic_Color<OutType>{ to_function(input.R), to_function(input.G), to_function(input.B), to_function(input.A) };
+}
+
+template<typename Type> struct Basic_Color
+{
+  Type R{};
+  Type G{};
+  Type B{};
+  Type A{};
+
+
+  template<typename RHS> constexpr auto &operator+=(Basic_Color<RHS> rhs) noexcept
+  {
+    // from stackoverflow
+    // Short answer:
+    // if we want to overlay color0 over color1 both with some alpha then
+    // a01 = (1 - a0)·a1 + a0
+    // r01 = ((1 - a0)·a1·r1 + a0·r0) / a01
+    // g01 = ((1 - a0)·a1·g1 + a0·g0) / a01
+    // b01 = ((1 - a0)·a1·b1 + a0·b0) / a01
+
+    const auto color1 = color_cast<double>(*this);
+    const auto color0 = color_cast<double>(rhs);
+    auto color01 = Basic_Color<double>{};
+
+    color01.A = (1 - color0.A) * color1.A + color0.A;
+    color01.R = ((1 - color0.A) * color1.A * color1.R + color0.A * color0.R) / color01.A;
+    color01.G = ((1 - color0.A) * color1.A * color1.G + color0.A * color0.G) / color01.A;
+    color01.B = ((1 - color0.A) * color1.A * color1.B + color0.A * color0.B) / color01.A;
+
+    *this = color_cast<Type>(color01);
+    return *this;
+  }
+};
+
+using Color = Basic_Color<std::uint8_t>;
+}// namespace lefticus::my_awesome_game
+
+#endif// MY_AWESOME_GAME_COLOR_HPP

src/game_components.hpp

@@ -0,0 +1,56 @@
+#ifndef MY_AWESOME_GAME_GAME_COMPONENTS_HPP
+#define MY_AWESOME_GAME_GAME_COMPONENTS_HPP
+
+#include <functional>
+#include <chrono>
+#include <map>
+
+#include "color.hpp"
+#include "vector2d.hpp"
+
+namespace lefticus::my_awesome_game
+{
+
+enum struct Direction { North, South, East, West };
+
+struct Location
+{
+  std::function<void()> action;
+  std::function<void(Vector2D_Span<Color> &, std::chrono::milliseconds, Point)> draw;
+  std::function<bool(std::chrono::milliseconds, Point, Direction)> can_enter;
+};
+
+struct Character
+{
+  Point map_location{};
+  std::function<void(Vector2D_Span<Color> &, std::chrono::milliseconds, Point)> draw;
+};
+
+
+struct Game_Map
+{
+  explicit Game_Map(const Size size) : locations{ size } {}
+  Vector2D<Location> locations;
+  [[nodiscard]] bool can_enter_from(std::chrono::milliseconds game_clock, Point location, Direction from) const
+  {
+    const auto &map_location = locations.at(location);
+    if (map_location.can_enter) {
+      return map_location.can_enter(game_clock, location, from);
+    } else {
+      return true;
+    }
+  }
+};
+
+struct Game
+{
+  
+  std::map<std::string, Game_Map> maps;
+  Character character;
+  std::function<void (Game &)> start_game;
+
+};
+
+}
+
+#endif// MY_AWESOME_GAME_GAME_COMPONENTS_HPP