Merge pull request #11 from daniebker/feature/#10-persistence

Feature/#10 persistence

Author: daniebker

.gitignore

@@ -120,3 +120,5 @@ Temporary Items
 ## Custom
 # Default build directory
 build
+
+game.sav

.vscode/settings.json

@@ -137,7 +137,8 @@
     "cinttypes": "cpp",
     "typeindex": "cpp",
     "valarray": "cpp",
-    "__std_stream": "cpp"
+    "__std_stream": "cpp",
+    "__tree": "cpp"
   },
   "[cpp]": {
     "editor.defaultFormatter": "xaver.clang-format"

include/basic_ai_component.hpp

@@ -1,23 +1,34 @@
 #ifndef INCLUDE_BASIC_AI_COMPONENT_HPP_
 #define INCLUDE_BASIC_AI_COMPONENT_HPP_
 
+#include <libtcod.hpp>
+
+#include "persistent.hpp"
 #include "types/engine_fwd.hpp"
 #include "types/entity_fwd.hpp"
 #include "types/world_fwd.hpp"
 
 namespace cpprl {
 
-class AIComponent {
+class AIComponent : public Persistent {
  public:
   AIComponent(){};
   virtual ~AIComponent() = default;
   virtual void update(World& world, Entity* entity) = 0;
+  static AIComponent* create(TCODZip& zip);
+  virtual void load(TCODZip& zip) = 0;
+  virtual void save(TCODZip& zip) = 0;
+
+ protected:
+  enum AiType { HOSTILE, CONFUSED };
 };
 
 class HostileAI final : public AIComponent {
  public:
   HostileAI() : AIComponent(){};
   void update(World& world, Entity* entity) override;
+  void load(TCODZip& zip) override;
+  void save(TCODZip& zip) override;
 };
 
 class ConfusionAI final : public AIComponent {
@@ -30,6 +41,8 @@ class ConfusionAI final : public AIComponent {
       : AIComponent(), num_turns_(num_turns), old_ai_(old_ai) {}
   ~ConfusionAI() override = default;
   void update(World& world, Entity* entity) override;
+  void load(TCODZip& zip) override;
+  void save(TCODZip& zip) override;
 };
 }  // namespace cpprl
 

include/components.hpp

@@ -5,69 +5,78 @@
 #include <string_view>
 #include <variant>
 
+#include "persistent.hpp"
 #include "types/action_result.hpp"
 #include "types/entity_fwd.hpp"
 #include "types/math.hpp"
 #include "types/world_fwd.hpp"
 
 namespace cpprl {
 
-class AttackComponent {
+class AttackComponent : public Persistent {
  public:
   AttackComponent(int damage) : damage_(damage) {}
   int get_damage() { return damage_; }
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 
  private:
   int damage_;
 };
 
-class DefenseComponent {
+class DefenseComponent : public Persistent {
  public:
   DefenseComponent(int defense, int maxHp)
-      : defense(defense), hp_(maxHp), max_hp_(maxHp) {}
+      : defense_(defense), hp_(maxHp), max_hp_(maxHp) {}
 
   int get_hp() { return hp_; }
   int get_max_hp() { return max_hp_; }
-  int get_defense() { return defense; }
+  int get_defense() { return defense_; }
 
   void take_damage(int damage) { hp_ -= damage; }
   int heal(int amount);
   bool is_dead() { return hp_ <= 0; }
   bool is_not_dead() { return !is_dead(); }
   void die(Entity& owner);
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 
  private:
-  int defense;
+  int defense_;
   int hp_;
   int max_hp_;
 };
 
-class TransformComponent {
+class TransformComponent : public Persistent {
  public:
   TransformComponent(int x, int y) : position_({x, y}) {}
   Vector2D get_position() { return position_; }
   void move(Vector2D new_position) { position_ = new_position; }
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 
  private:
   Vector2D position_;
 };
 
-class ASCIIComponent {
+class ASCIIComponent : public Persistent {
  public:
   ASCIIComponent(std::string_view symbol, tcod::ColorRGB colour, int layer)
       : symbol_(symbol), colour_(colour), layer_(layer) {}
 
   std::string_view get_symbol() { return symbol_; }
   tcod::ColorRGB get_colour() { return colour_; }
   int get_layer() { return layer_; }
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 
  private:
-  std::string_view symbol_;
+  std::string symbol_;
   tcod::ColorRGB colour_;
   int layer_;
 };
 
-class Container {
+class Container : Persistent {
  private:
   size_t size_;
   std::vector<Entity*> inventory_;
@@ -78,22 +87,34 @@ class Container {
   void remove(Entity* actor);
   std::vector<Entity*> get_inventory() { return inventory_; }
   int get_size() { return size_; }
+
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 };
 
-class ConsumableComponent {
+class ConsumableComponent : public Persistent {
  public:
   virtual ~ConsumableComponent() = default;
   // TODO: should also be an action result
   ActionResult pick_up(Entity* owner, Entity* wearer);
   ActionResult drop(Entity* owner, Entity* wearer);
   virtual ActionResult use(Entity* owner, Entity* wearer, World& world);
+  virtual void load(TCODZip& zip) = 0;
+  virtual void save(TCODZip& zip) = 0;
+  static ConsumableComponent* create(TCODZip& zip);
+
+ protected:
+  enum ConsumableType { HEALER, LIGHTNING_BOLT, CONFUSER, FIREBALL };
 };
 
 class HealingConsumable final : public ConsumableComponent {
  public:
   HealingConsumable(int amount);
   ActionResult use(Entity* owner, Entity* wearer, World& world);
 
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
+
  private:
   int amount_;
 };
@@ -106,6 +127,9 @@ class LightningBolt final : public ConsumableComponent {
   LightningBolt(float range, float damage) : range_(range), damage_(damage) {}
   ~LightningBolt() = default;
   ActionResult use(Entity* owner, Entity* wearer, World& world);
+
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 };
 
 class FireSpell final : public ConsumableComponent {
@@ -118,6 +142,9 @@ class FireSpell final : public ConsumableComponent {
   ~FireSpell() = default;
 
   ActionResult use(Entity* owner, Entity* Wearer, World& world);
+
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 };
 
 class ConfusionSpell final : public ConsumableComponent {
@@ -130,6 +157,9 @@ class ConfusionSpell final : public ConsumableComponent {
   ~ConfusionSpell() = default;
 
   ActionResult use(Entity* owner, Entity* wearer, World& world);
+
+  void load(TCODZip& zip);
+  void save(TCODZip& zip);
 };
 
 }  // namespace cpprl

include/dungeon.hpp

@@ -4,6 +4,7 @@
 #include <vector>
 
 #include "game_entity.hpp"
+#include "persistent.hpp"
 #include "types/map.hpp"
 
 struct DungeonConfig {
@@ -16,14 +17,20 @@ struct DungeonConfig {
 };
 
 namespace cpprl {
-class Dungeon {
+class Dungeon : public Persistent {
  private:
   std::vector<Vector2D> l_tunnel_between(Vector2D start, Vector2D end);
+  TCODRandom* rng_;
+  long seed_;
 
  public:
-  Dungeon(){};
-  ~Dungeon() = default;
+  Dungeon() {
+    seed_ = TCODRandom::getInstance()->getInt(0, 0x7FFFFFFF);
+  };
+  ~Dungeon() { delete rng_; };
   Map* generate(DungeonConfig config);
+  void save(TCODZip& zip) override;
+  void load(TCODZip& zip) override;
 };
 }  // namespace cpprl
 

include/engine.hpp

@@ -23,18 +23,8 @@ class State;
 
 class Engine {
  private:
-  // std::unique_ptr<Dungeon> dungeon_;
-  // UiWindow* health_bar_;
-  // std::unique_ptr<MessageLog> message_log_;
-  // UiWindow* current_window_;
-  // EventHandler* input_handler_;
   std::unique_ptr<Renderer> renderer_;
   tcod::Context context_;
-  // Controller controller_;
-  // bool is_paused_ = false;
-  // bool game_over_ = false;
-  // bool show_view_ = false;
-  // bool targeting_mode_ = false;
   std::unique_ptr<World> world_;
   std::unique_ptr<State> engine_state_;
 
@@ -45,25 +35,12 @@ class Engine {
   Engine(int argc, char** argv);
   ~Engine();
   void handle_events();
-  // EntityManager& get_entities() { return *entities_; };
   void render();
-  // Map* get_map() { return map_; }
-  // Entity* get_player() { return player_; }
   void handle_player_death();
   void reset_game();
-  // MessageLog& get_message_log() { return *message_log_; }
-  // Controller& get_controller() { return controller_; }
-  // UiWindow& get_current_view() { return *current_window_; }
-  // void toggle_pause() { is_paused_ = !is_paused_; }
-  // void toggle_view() { show_view_ = !show_view_; }
-  // void set_input_handler(EventHandler* input_handler);
-  // void set_current_view(UiWindow* current_window) {
-  //   current_window_ = current_window;
-  // };
-  // void scroll_current_view(int scroll_amount);
-  // void toggle_targeting_mode() { targeting_mode_ = !targeting_mode_; }
-  // void set_targeting_tile(
-  //     float max_range = 0.0f, std::function<void()> callback = nullptr);
+  void load();
+  void save();
+  void init();
 };
 }  // namespace cpprl
 #endif

include/entity_manager.hpp

@@ -22,6 +22,7 @@ class EntityManager {
   void reserve(size_t size) { entities_.reserve(size); }
   void shrink_to_fit() { entities_.shrink_to_fit(); }
   void remove(Entity* entity);
+  size_t size() const { return entities_.size(); }
 
   Entity& at(int index) { return *entities_.at(index); }
 

include/events/command.hpp

@@ -72,21 +72,41 @@ class InventoryCommand final : public Command {
   StateResult execute() override;
 };
 
-enum SubCommand { USE_ITEM, DROP_ITEM };
+class MainMenuCommand final : public EngineEvent {
+ public:
+  MainMenuCommand(World& world) : EngineEvent(world) {}
+  StateResult execute() override;
+};
+
+enum ItemSubCommand { USE_ITEM, DROP_ITEM };
 class SelectItemCommand final : public Command {
  private:
-  SubCommand sub_command_;
+  ItemSubCommand sub_command_;
   UiWindow& ui_window_;
 
  public:
   SelectItemCommand(
-      World& world, Entity* entity, UiWindow& ui_window, SubCommand sub_command)
+      World& world,
+      Entity* entity,
+      UiWindow& ui_window,
+      ItemSubCommand sub_command)
       : Command(world, entity),
         sub_command_(sub_command),
         ui_window_(ui_window) {}
   StateResult execute() override;
 };
 
+enum MenuSubCommand { NEW_GAME, CONTINUE, QUIT };
+class SelectMenuItemCommand final : public EngineEvent {
+ private:
+  UiWindow& ui_window_;
+
+ public:
+  SelectMenuItemCommand(World& world, UiWindow& ui_window)
+      : EngineEvent(world), ui_window_(ui_window) {}
+  StateResult execute() override;
+};
+
 class UseItemCommand final : public Command {
  private:
   int item_index_;

include/game_entity.hpp

@@ -4,6 +4,7 @@
 #include <libtcod.hpp>
 #include <string_view>
 
+#include "persistent.hpp"
 #include "types/math.hpp"
 #include "types/world_fwd.hpp"
 
@@ -73,6 +74,8 @@ class Entity {
     aiComponent_ = aiComponent;
   };
   void set_container(Container* container) { container_ = container; };
+  void save(TCODZip& zip);
+  void load(TCODZip& zip);
 };
 
 }  // namespace cpprl