14 files changed, 461 insertions, 46 deletions

diff --git a/src/crepe/manager/CMakeLists.txt b/src/crepe/manager/CMakeLists.txt
index f73e165..48e444f 100644
--- a/src/crepe/manager/CMakeLists.txt
+++ b/src/crepe/manager/CMakeLists.txt
@@ -6,6 +6,8 @@ target_sources(crepe PUBLIC
 	SceneManager.cpp
 	LoopTimerManager.cpp
 	ResourceManager.cpp
+	ReplayManager.cpp
+	SystemManager.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -21,5 +23,8 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	LoopTimerManager.h
 	ResourceManager.h
 	ResourceManager.hpp
+	ReplayManager.h
+	SystemManager.h
+	SystemManager.hpp
 )
 
diff --git a/src/crepe/manager/ComponentManager.cpp b/src/crepe/manager/ComponentManager.cpp
index df30d27..745ddae 100644
--- a/src/crepe/manager/ComponentManager.cpp
+++ b/src/crepe/manager/ComponentManager.cpp
@@ -1,7 +1,7 @@
 #include "../api/GameObject.h"
 #include "../api/Metadata.h"
 #include "../types.h"
-#include "../util/Log.h"
+#include "../util/dbg.h"
 
 #include "ComponentManager.h"
 
@@ -53,7 +53,7 @@ GameObject ComponentManager::new_object(const string & name, const string & tag,
 		this->next_id++;
 	}
 
-	GameObject object{*this, this->next_id, name, tag, position, rotation, scale};
+	GameObject object{this->mediator, this->next_id, name, tag, position, rotation, scale};
 	this->next_id++;
 
 	return object;
@@ -72,3 +72,28 @@ set<game_object_id_t> ComponentManager::get_objects_by_tag(const string & tag) c
 	return this->get_objects_by_predicate<Metadata>(
 		[tag](const Metadata & data) { return data.tag == tag; });
 }
+
+ComponentManager::Snapshot ComponentManager::save() {
+	Snapshot snapshot{};
+	for (const auto & [type, by_id_index] : this->components) {
+		for (game_object_id_t id = 0; id < by_id_index.size(); id++) {
+			const auto & components = by_id_index[id];
+			for (size_t index = 0; index < components.size(); index++) {
+				const Component & component = *components[index];
+				snapshot.components.push_back(SnapshotComponent{
+					.type = type,
+					.id = id,
+					.index = index,
+					.component = component.save(),
+				});
+			}
+		}
+	}
+	return snapshot;
+}
+
+void ComponentManager::restore(const Snapshot & snapshot) {
+	for (const SnapshotComponent & info : snapshot.components) {
+		this->components[info.type][info.id][info.index]->restore(*info.component);
+	}
+}
diff --git a/src/crepe/manager/ComponentManager.h b/src/crepe/manager/ComponentManager.h
index 19a8e81..c3a5b4a 100644
--- a/src/crepe/manager/ComponentManager.h
+++ b/src/crepe/manager/ComponentManager.h
@@ -21,13 +21,6 @@ class GameObject;
  * This class manages all components. It provides methods to add, delete and get components.
  */
 class ComponentManager : public Manager {
-	// TODO: This relation should be removed! I (loek) believe that the scene manager should
-	// create/destroy components because the GameObject's are stored in concrete Scene classes,
-	// which will in turn call GameObject's destructor, which will in turn call
-	// ComponentManager::delete_components_by_id or something. This is a pretty major change, so
-	// here is a comment and temporary fix instead :tada:
-	friend class SceneManager;
-
 public:
 	ComponentManager(Mediator & mediator);
 	~ComponentManager(); // dbg_trace
@@ -49,12 +42,7 @@ public:
 						  const vec2 & position = {0, 0}, double rotation = 0,
 						  double scale = 1);
 
-protected:
-	/**
-	 * GameObject is used as an interface to add/remove components, and the game programmer is
-	 * supposed to use it instead of interfacing with the component manager directly.
-	 */
-	friend class GameObject;
+public:
 	/**
 	 * \brief Add a component to the ComponentManager
 	 *
@@ -154,6 +142,40 @@ public:
 	template <typename T>
 	RefVector<T> get_components_by_tag(const std::string & tag) const;
 
+	//! Snapshot of single component (including path in \c components)
+	struct SnapshotComponent {
+		//! \c components path
+		std::type_index type;
+		//! \c components path
+		game_object_id_t id;
+		//! \c components path
+		size_t index;
+		//! Actual component snapshot
+		std::unique_ptr<Component> component;
+	};
+	//! Snapshot of the entire component manager state
+	struct Snapshot {
+		//! All components
+		std::vector<SnapshotComponent> components;
+		// TODO: some kind of hash code that ensures components exist in all the same places as
+		// this snapshot
+	};
+	/**
+	 * \name ReplayManager (Memento) functions
+	 * \{
+	 */
+	/**
+	 * \brief Save a snapshot of the component manager state
+	 * \returns Deep copy of the component manager's internal state
+	 */
+	Snapshot save();
+	/**
+	 * \brief Restore component manager from a snapshot
+	 * \param snapshot Snapshot to restore from (as returned by \c save())
+	 */
+	void restore(const Snapshot & snapshot);
+	//! \}
+
 private:
 	/**
 	 * \brief Get object IDs by predicate function
diff --git a/src/crepe/manager/LoopTimerManager.cpp b/src/crepe/manager/LoopTimerManager.cpp
index a6e4788..e78f92f 100644
--- a/src/crepe/manager/LoopTimerManager.cpp
+++ b/src/crepe/manager/LoopTimerManager.cpp
@@ -1,7 +1,7 @@
 #include <chrono>
 #include <thread>
 
-#include "../util/Log.h"
+#include "../util/dbg.h"
 
 #include "LoopTimerManager.h"
 
diff --git a/src/crepe/manager/LoopTimerManager.h b/src/crepe/manager/LoopTimerManager.h
index 76b02d3..2f1e6b6 100644
--- a/src/crepe/manager/LoopTimerManager.h
+++ b/src/crepe/manager/LoopTimerManager.h
@@ -6,6 +6,8 @@
 
 namespace crepe {
 
+class Engine;
+
 typedef std::chrono::duration<float> duration_t;
 typedef std::chrono::duration<unsigned long long, std::micro> elapsed_time_t;
 
@@ -107,7 +109,7 @@ public:
 
 private:
 	//! Friend relation to use start,enforce_frame_rate,get_lag,update,advance_fixed_update.
-	friend class LoopManager;
+	friend class Engine;
 	/**
 	 * \brief Start the loop timer.
 	 *
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index a336410..842f1de 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -11,6 +11,8 @@ class LoopTimerManager;
 class SaveManager;
 class ResourceManager;
 class SDLContext;
+class ReplayManager;
+class SystemManager;
 
 /**
  * Struct to pass references to classes that would otherwise need to be singletons down to
@@ -32,6 +34,8 @@ struct Mediator {
 	OptionalRef<LoopTimerManager> loop_timer;
 	OptionalRef<SaveManager> save_manager;
 	OptionalRef<ResourceManager> resource_manager;
+	OptionalRef<ReplayManager> replay_manager;
+	OptionalRef<SystemManager> system_manager;
 };
 
 } // namespace crepe
diff --git a/src/crepe/manager/ReplayManager.cpp b/src/crepe/manager/ReplayManager.cpp
new file mode 100644
index 0000000..090a94e
--- /dev/null
+++ b/src/crepe/manager/ReplayManager.cpp
@@ -0,0 +1,70 @@
+#include <format>
+
+#include "Manager.h"
+#include "ReplayManager.h"
+
+using namespace crepe;
+using namespace std;
+
+ReplayManager::ReplayManager(Mediator & mediator) : Manager(mediator) {
+	mediator.replay_manager = *this;
+}
+
+void ReplayManager::record_start() {
+	if (this->state == RECORDING) this->release(this->id);
+	this->id++;
+	this->memory[this->id] = make_unique<Recording>();
+	this->recording = *this->memory.at(this->id);
+	this->state = RECORDING;
+}
+
+recording_t ReplayManager::record_end() {
+	this->state = IDLE;
+	return this->id;
+}
+
+void ReplayManager::play(recording_t handle) {
+	if (!this->memory.contains(handle))
+		throw out_of_range(format("ReplayManager: no recording for handle {}", handle));
+	this->recording = *this->memory.at(handle);
+	this->recording->frame = 0;
+	this->state = PLAYING;
+}
+
+void ReplayManager::release(recording_t handle) {
+	if (!this->memory.contains(handle)) return;
+	this->memory.erase(handle);
+}
+
+void ReplayManager::frame_record() {
+	if (this->state != RECORDING)
+		throw runtime_error("ReplayManager: frame_step called while not playing");
+
+	ComponentManager & components = this->mediator.component_manager;
+	Recording & recording = this->recording;
+
+	recording.frames.push_back(components.save());
+	recording.frame++;
+}
+
+bool ReplayManager::frame_step() {
+	if (this->state != PLAYING)
+		throw runtime_error("ReplayManager: frame_step called while not playing");
+
+	ComponentManager & components = this->mediator.component_manager;
+	Recording & recording = this->recording;
+
+	ComponentManager::Snapshot & frame = recording.frames.at(recording.frame);
+
+	components.restore(frame);
+	recording.frame++;
+
+	if (recording.frame < recording.frames.size()) return false;
+	// end of recording
+	recording.frame = 0;
+	this->state = IDLE;
+	this->recording.clear();
+	return true;
+}
+
+ReplayManager::State ReplayManager::get_state() const { return this->state; }
diff --git a/src/crepe/manager/ReplayManager.h b/src/crepe/manager/ReplayManager.h
new file mode 100644
index 0000000..f06a58b
--- /dev/null
+++ b/src/crepe/manager/ReplayManager.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "../util/OptionalRef.h"
+
+#include "ComponentManager.h"
+#include "Manager.h"
+
+namespace crepe {
+
+//! Handle to recording held by ReplayManager
+typedef size_t recording_t;
+
+/**
+ * \brief Replay manager
+ *
+ * The replay manager is responsible for creating, storing and restoring ComponentManager
+ * snapshots. Sequential snapshots can be recorded and replayed in combination with
+ * ReplaySystem.
+ */
+class ReplayManager : public Manager {
+	// TODO: Delete recordings at end of scene
+
+public:
+	ReplayManager(Mediator & mediator);
+
+public:
+	//! Start a new recording
+	void record_start();
+	/**
+	 * \brief End the latest recording started by \c record_start()
+	 * \returns Handle to recording
+	 */
+	recording_t record_end();
+	/**
+	 * \brief Play a recording
+	 * \param handle Handle to recording (as returned by \c record_end())
+	 */
+	void play(recording_t handle);
+	/**
+	 * \brief Delete a recording from memory
+	 * \param handle Handle to recording (as returned by \c record_end())
+	 */
+	void release(recording_t handle);
+
+public:
+	//! Internal state
+	enum State {
+		IDLE, //!< Not doing anything
+		RECORDING, //!< Currently recording
+		PLAYING, //!< Currently playing back a recording
+	};
+	//! Get current internal state
+	State get_state() const;
+
+public:
+	/**
+	 * \brief Record a single frame to the current recording
+	 *
+	 * This function is called by ReplaySystem after the game programmer has called \c
+	 * record_start()
+	 */
+	void frame_record();
+	/**
+	 * \brief Play the next frame of the current recording
+	 *
+	 * \returns `true` if the recording is finished playing
+	 * \returns `false` if there are more frames
+	 *
+	 * This function also automatically resets the internal state from PLAYING to IDLE at the end
+	 * of a recording.
+	 */
+	bool frame_step();
+
+private:
+	/**
+	 * \brief Recording data
+	 */
+	struct Recording {
+		//! Current frame being shown
+		size_t frame = 0;
+		//! All frames in recording
+		std::vector<ComponentManager::Snapshot> frames;
+	};
+	//! Internal state
+	State state = IDLE;
+	//! Current recording handle
+	recording_t id = -1;
+	//! Current recording data
+	OptionalRef<Recording> recording;
+	//! Recording storage
+	std::unordered_map<recording_t, std::unique_ptr<Recording>> memory;
+};
+
+} // namespace crepe
diff --git a/src/crepe/manager/ResourceManager.cpp b/src/crepe/manager/ResourceManager.cpp
index a141a46..5713183 100644
--- a/src/crepe/manager/ResourceManager.cpp
+++ b/src/crepe/manager/ResourceManager.cpp
@@ -1,4 +1,4 @@
-#include "util/Log.h"
+#include "util/dbg.h"
 
 #include "ResourceManager.h"
 
diff --git a/src/crepe/manager/SaveManager.cpp b/src/crepe/manager/SaveManager.cpp
index 691ea2f..f313ed2 100644
--- a/src/crepe/manager/SaveManager.cpp
+++ b/src/crepe/manager/SaveManager.cpp
@@ -129,9 +129,32 @@ template void SaveManager::set(const string &, const float &);
 template void SaveManager::set(const string &, const double &);
 
 template <typename T>
+T SaveManager::get(const string & key) {
+	return this->deserialize<T>(this->get_db().get(key));
+}
+template uint8_t SaveManager::get(const string &);
+template int8_t SaveManager::get(const string &);
+template uint16_t SaveManager::get(const string &);
+template int16_t SaveManager::get(const string &);
+template uint32_t SaveManager::get(const string &);
+template int32_t SaveManager::get(const string &);
+template uint64_t SaveManager::get(const string &);
+template int64_t SaveManager::get(const string &);
+template float SaveManager::get(const string &);
+template double SaveManager::get(const string &);
+template string SaveManager::get(const string &);
+
+template <typename T>
 ValueBroker<T> SaveManager::get(const string & key, const T & default_value) {
 	if (!this->has(key)) this->set<T>(key, default_value);
-	return this->get<T>(key);
+	T value;
+	return {
+		[this, key](const T & target) { this->set<T>(key, target); },
+		[this, key, value]() mutable -> const T & {
+			value = this->get<T>(key);
+			return value;
+		},
+	};
 }
 template ValueBroker<uint8_t> SaveManager::get(const string &, const uint8_t &);
 template ValueBroker<int8_t> SaveManager::get(const string &, const int8_t &);
@@ -144,27 +167,3 @@ template ValueBroker<int64_t> SaveManager::get(const string &, const int64_t &);
 template ValueBroker<float> SaveManager::get(const string &, const float &);
 template ValueBroker<double> SaveManager::get(const string &, const double &);
 template ValueBroker<string> SaveManager::get(const string &, const string &);
-
-template <typename T>
-ValueBroker<T> SaveManager::get(const string & key) {
-	T value;
-	return {
-		[this, key](const T & target) { this->set<T>(key, target); },
-		[this, key, value]() mutable -> const T & {
-			DB & db = this->get_db();
-			value = this->deserialize<T>(db.get(key));
-			return value;
-		},
-	};
-}
-template ValueBroker<uint8_t> SaveManager::get(const string &);
-template ValueBroker<int8_t> SaveManager::get(const string &);
-template ValueBroker<uint16_t> SaveManager::get(const string &);
-template ValueBroker<int16_t> SaveManager::get(const string &);
-template ValueBroker<uint32_t> SaveManager::get(const string &);
-template ValueBroker<int32_t> SaveManager::get(const string &);
-template ValueBroker<uint64_t> SaveManager::get(const string &);
-template ValueBroker<int64_t> SaveManager::get(const string &);
-template ValueBroker<float> SaveManager::get(const string &);
-template ValueBroker<double> SaveManager::get(const string &);
-template ValueBroker<string> SaveManager::get(const string &);
diff --git a/src/crepe/manager/SaveManager.h b/src/crepe/manager/SaveManager.h
index 61a978d..1e34bc0 100644
--- a/src/crepe/manager/SaveManager.h
+++ b/src/crepe/manager/SaveManager.h
@@ -36,17 +36,17 @@ public:
 	ValueBroker<T> get(const std::string & key, const T & default_value);
 
 	/**
-	 * \brief Get a read/write reference to a value
+	 * \brief Get a value directly
 	 *
 	 * \param key  The value key
 	 *
-	 * \return Read/write reference to the value
+	 * \return The value
 	 *
 	 * \note Attempting to read this value before it is initialized (i.e. set) will result in an
 	 * exception
 	 */
 	template <typename T>
-	ValueBroker<T> get(const std::string & key);
+	T get(const std::string & key);
 
 	/**
 	 * \brief Set a value directly
diff --git a/src/crepe/manager/SystemManager.cpp b/src/crepe/manager/SystemManager.cpp
new file mode 100644
index 0000000..5ada30f
--- /dev/null
+++ b/src/crepe/manager/SystemManager.cpp
@@ -0,0 +1,66 @@
+#include "../system/AISystem.h"
+#include "../system/AnimatorSystem.h"
+#include "../system/AudioSystem.h"
+#include "../system/CollisionSystem.h"
+#include "../system/EventSystem.h"
+#include "../system/InputSystem.h"
+#include "../system/ParticleSystem.h"
+#include "../system/PhysicsSystem.h"
+#include "../system/RenderSystem.h"
+#include "../system/ReplaySystem.h"
+#include "../system/ScriptSystem.h"
+
+#include "SystemManager.h"
+
+using namespace crepe;
+using namespace std;
+
+SystemManager::SystemManager(Mediator & mediator) : Manager(mediator) {
+	this->load_system<InputSystem>();
+	this->load_system<EventSystem>();
+	this->load_system<ScriptSystem>();
+	this->load_system<AISystem>();
+	this->load_system<PhysicsSystem>();
+	this->load_system<CollisionSystem>();
+	this->load_system<AudioSystem>();
+	this->load_system<AnimatorSystem>();
+	this->load_system<ParticleSystem>();
+	this->load_system<RenderSystem>();
+	this->load_system<ReplaySystem>();
+
+	this->mediator.system_manager = *this;
+}
+
+void SystemManager::fixed_update() {
+	for (auto & [type, system] : this->systems) {
+		if (!system->active) continue;
+		system->fixed_update();
+	}
+}
+
+void SystemManager::frame_update() {
+	for (auto & [type, system] : this->systems) {
+		if (!system->active) continue;
+		system->frame_update();
+	}
+}
+
+SystemManager::Snapshot SystemManager::save() {
+	Snapshot snapshot;
+	for (auto & [type, system] : this->systems) {
+		snapshot[type] = system->active;
+	}
+	return snapshot;
+}
+
+void SystemManager::restore(const Snapshot & snapshot) {
+	for (auto & [type, active] : snapshot) {
+		this->systems[type]->active = active;
+	}
+}
+
+void SystemManager::disable_all() {
+	for (auto & [type, system] : this->systems) {
+		system->active = false;
+	}
+}
diff --git a/src/crepe/manager/SystemManager.h b/src/crepe/manager/SystemManager.h
new file mode 100644
index 0000000..50acf77
--- /dev/null
+++ b/src/crepe/manager/SystemManager.h
@@ -0,0 +1,85 @@
+#pragma once
+
+#include <memory>
+#include <typeindex>
+#include <unordered_map>
+
+#include "../system/System.h"
+
+#include "Manager.h"
+
+namespace crepe {
+
+/**
+ * \brief Collection of all systems
+ *
+ * This manager aggregates all systems and provides utility functions to retrieve references to
+ * and update systems.
+ */
+class SystemManager : public Manager {
+public:
+	SystemManager(Mediator &);
+
+	/**
+	 * \brief Per-frame update.
+	 *
+	 * Updates the game state based on the elapsed time since the last frame.
+	 */
+	void frame_update();
+
+	/**
+	 * \brief Fixed update executed at a fixed rate.
+	 *
+	 * This function updates physics and game logic based on LoopTimer's fixed_delta_time.
+	 */
+	void fixed_update();
+
+private:
+	/**
+	 * \brief Collection of System instances
+	 *
+	 * This map holds System instances indexed by the system's class typeid. It is filled in the
+	 * constructor of \c SystemManager using SystemManager::load_system.
+	 */
+	std::unordered_map<std::type_index, std::unique_ptr<System>> systems;
+	/**
+	 * \brief Initialize a system
+	 * \tparam T System type (must be derivative of \c System)
+	 */
+	template <class T>
+	void load_system();
+
+public:
+	/**
+	 * \brief Retrieve a reference to ECS system
+	 * \tparam T System type
+	 * \returns Reference to system instance
+	 * \throws std::runtime_error if the System is not initialized
+	 */
+	template <class T>
+	T & get_system();
+
+public:
+	/**
+	 * \brief SystemManager snapshot
+	 *
+	 * The SystemManager snapshot only stores which systems are active
+	 */
+	typedef std::unordered_map<std::type_index, bool> Snapshot;
+	/**
+	 * \brief Save a snapshot of the systems' state
+	 * \returns Copy of each system's active property
+	 */
+	Snapshot save();
+	/**
+	 * \brief Restore system active state from a snapshot
+	 * \param snapshot Snapshot to restore from (as returned by \c save())
+	 */
+	void restore(const Snapshot & snapshot);
+	//! Disable all systems
+	void disable_all();
+};
+
+} // namespace crepe
+
+#include "SystemManager.hpp"
diff --git a/src/crepe/manager/SystemManager.hpp b/src/crepe/manager/SystemManager.hpp
new file mode 100644
index 0000000..3d26e4c
--- /dev/null
+++ b/src/crepe/manager/SystemManager.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cassert>
+#include <format>
+#include <memory>
+
+#include "SystemManager.h"
+
+namespace crepe {
+
+template <class T>
+T & SystemManager::get_system() {
+	using namespace std;
+	static_assert(is_base_of<System, T>::value,
+				  "get_system must recieve a derivative class of System");
+
+	const type_info & type = typeid(T);
+	if (!this->systems.contains(type))
+		throw runtime_error(format("SystemManager: {} is not initialized", type.name()));
+
+	System * system = this->systems.at(type).get();
+	T * concrete_system = dynamic_cast<T *>(system);
+	assert(concrete_system != nullptr);
+
+	return *concrete_system;
+}
+
+template <class T>
+void SystemManager::load_system() {
+	using namespace std;
+	static_assert(is_base_of<System, T>::value,
+				  "load_system must recieve a derivative class of System");
+
+	const type_info & type = typeid(T);
+	if (this->systems.contains(type))
+		throw runtime_error(format("SystemManager: {} is already initialized", type.name()));
+	System * system = new T(this->mediator);
+	this->systems[type] = unique_ptr<System>(system);
+}
+
+} // namespace crepe