17 files changed, 511 insertions, 63 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..245419d 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"
 
@@ -46,14 +46,16 @@ void ComponentManager::delete_all_components() {
 	this->next_id = 0;
 }
 
-GameObject ComponentManager::new_object(const string & name, const string & tag,
-										const vec2 & position, double rotation, double scale) {
+GameObject ComponentManager::new_object(
+	const string & name, const string & tag, const vec2 & position, double rotation,
+	double scale
+) {
 	// Find the first available id (taking persistent objects into account)
 	while (this->persistent[this->next_id]) {
 		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;
@@ -64,11 +66,38 @@ void ComponentManager::set_persistent(game_object_id_t id, bool persistent) {
 }
 
 set<game_object_id_t> ComponentManager::get_objects_by_name(const string & name) const {
-	return this->get_objects_by_predicate<Metadata>(
-		[name](const Metadata & data) { return data.name == name; });
+	return this->get_objects_by_predicate<Metadata>([name](const Metadata & data) {
+		return data.name == name;
+	});
 }
 
 set<game_object_id_t> ComponentManager::get_objects_by_tag(const string & tag) const {
-	return this->get_objects_by_predicate<Metadata>(
-		[tag](const Metadata & data) { return data.tag == tag; });
+	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..2eb1f7e 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
@@ -45,16 +38,12 @@ public:
 	 *
 	 * \note This method automatically assigns a new entity ID
 	 */
-	GameObject new_object(const std::string & name, const std::string & tag = "",
-						  const vec2 & position = {0, 0}, double rotation = 0,
-						  double scale = 1);
+	GameObject new_object(
+		const std::string & name, const std::string & tag = "", 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 +143,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/ComponentManager.hpp b/src/crepe/manager/ComponentManager.hpp
index 9e70865..6d32edb 100644
--- a/src/crepe/manager/ComponentManager.hpp
+++ b/src/crepe/manager/ComponentManager.hpp
@@ -11,8 +11,10 @@ template <class T, typename... Args>
 T & ComponentManager::add_component(game_object_id_t id, Args &&... args) {
 	using namespace std;
 
-	static_assert(is_base_of<Component, T>::value,
-				  "add_component must recieve a derivative class of Component");
+	static_assert(
+		is_base_of<Component, T>::value,
+		"add_component must recieve a derivative class of Component"
+	);
 
 	// Determine the type of T (this is used as the key of the unordered_map<>)
 	type_index type = typeid(T);
@@ -40,8 +42,8 @@ T & ComponentManager::add_component(game_object_id_t id, Args &&... args) {
 	// Check if the vector size is not greater than get_instances_max
 	int max_instances = instance->get_instances_max();
 	if (max_instances != -1 && components[type][id].size() >= max_instances) {
-		throw std::runtime_error(
-			"Exceeded maximum number of instances for this component type");
+		throw std::runtime_error("Exceeded maximum number of instances for this component type"
+		);
 	}
 
 	// store its unique_ptr in the vector<>
@@ -95,8 +97,10 @@ template <typename T>
 RefVector<T> ComponentManager::get_components_by_id(game_object_id_t id) const {
 	using namespace std;
 
-	static_assert(is_base_of<Component, T>::value,
-				  "get_components_by_id must recieve a derivative class of Component");
+	static_assert(
+		is_base_of<Component, T>::value,
+		"get_components_by_id must recieve a derivative class of Component"
+	);
 
 	type_index type = typeid(T);
 	if (!this->components.contains(type)) return {};
@@ -170,8 +174,8 @@ ComponentManager::get_objects_by_predicate(const std::function<bool(const T &)>
 }
 
 template <typename T>
-RefVector<T>
-ComponentManager::get_components_by_ids(const std::set<game_object_id_t> & ids) const {
+RefVector<T> ComponentManager::get_components_by_ids(const std::set<game_object_id_t> & ids
+) const {
 	using namespace std;
 
 	RefVector<T> out = {};
diff --git a/src/crepe/manager/EventManager.h b/src/crepe/manager/EventManager.h
index 639e37f..5766a0c 100644
--- a/src/crepe/manager/EventManager.h
+++ b/src/crepe/manager/EventManager.h
@@ -49,8 +49,8 @@ public:
 	 * \return A unique subscription ID associated with the registered callback.
 	 */
 	template <typename EventType>
-	subscription_t subscribe(const EventHandler<EventType> & callback,
-							 event_channel_t channel = CHANNEL_ALL);
+	subscription_t
+	subscribe(const EventHandler<EventType> & callback, event_channel_t channel = CHANNEL_ALL);
 
 	/**
 	 * \brief Unsubscribe a previously registered callback.
@@ -106,7 +106,7 @@ private:
 	 * \brief Represents an entry in the event queue.
 	 */
 	struct QueueEntry {
-		std::unique_ptr<Event> event; ///< The event instance.
+		std::unique_ptr<Event, std::function<void(Event *)>> event; ///< The event instance.
 		event_channel_t channel = CHANNEL_ALL; ///< The channel associated with the event.
 		std::type_index type; ///< The type of the event.
 	};
diff --git a/src/crepe/manager/EventManager.hpp b/src/crepe/manager/EventManager.hpp
index a5f4556..1f44943 100644
--- a/src/crepe/manager/EventManager.hpp
+++ b/src/crepe/manager/EventManager.hpp
@@ -5,24 +5,31 @@
 namespace crepe {
 
 template <typename EventType>
-subscription_t EventManager::subscribe(const EventHandler<EventType> & callback,
-									   event_channel_t channel) {
+subscription_t
+EventManager::subscribe(const EventHandler<EventType> & callback, event_channel_t channel) {
 	subscription_counter++;
 	std::type_index event_type = typeid(EventType);
 	std::unique_ptr<EventHandlerWrapper<EventType>> handler
 		= std::make_unique<EventHandlerWrapper<EventType>>(callback);
 	std::vector<CallbackEntry> & handlers = this->subscribers[event_type];
-	handlers.emplace_back(CallbackEntry{
-		.callback = std::move(handler), .channel = channel, .id = subscription_counter});
+	handlers.emplace_back(CallbackEntry {
+		.callback = std::move(handler), .channel = channel, .id = subscription_counter
+	});
 	return subscription_counter;
 }
 
 template <typename EventType>
 void EventManager::queue_event(const EventType & event, event_channel_t channel) {
-	static_assert(std::is_base_of<Event, EventType>::value,
-				  "EventType must derive from Event");
+	static_assert(
+		std::is_base_of<Event, EventType>::value, "EventType must derive from Event"
+	);
 	this->events_queue.push_back(QueueEntry{
-		.event = std::make_unique<EventType>(event),
+		// unique_ptr w/ custom destructor implementation is used because the base Event interface
+		// can't be polymorphic (= have default virtual destructor)
+		.event = {
+			new EventType(event),
+			[](Event * ev) { delete static_cast<EventType *>(ev); },
+		},
 		.channel = channel,
 		.type = typeid(EventType),
 	});
diff --git a/src/crepe/manager/LoopTimerManager.cpp b/src/crepe/manager/LoopTimerManager.cpp
index a6e4788..b4cd07f 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"
 
@@ -17,9 +17,9 @@ LoopTimerManager::LoopTimerManager(Mediator & mediator) : Manager(mediator) {
 void LoopTimerManager::start() {
 	this->last_frame_time = std::chrono::steady_clock::now();
 
-	this->elapsed_time = elapsed_time_t{0};
-	this->elapsed_fixed_time = elapsed_time_t{0};
-	this->delta_time = duration_t{0};
+	this->elapsed_time = elapsed_time_t {0};
+	this->elapsed_fixed_time = elapsed_time_t {0};
+	this->delta_time = duration_t {0};
 }
 
 void LoopTimerManager::update() {
diff --git a/src/crepe/manager/LoopTimerManager.h b/src/crepe/manager/LoopTimerManager.h
index 76b02d3..279d6b2 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.
 	 *
@@ -155,17 +157,17 @@ private:
 	//! Time scale for speeding up or slowing down the game (0 = pause, < 1 = slow down, 1 = normal speed, > 1 = speed up).
 	float time_scale = 1;
 	//! Maximum delta time in seconds to avoid large jumps.
-	duration_t maximum_delta_time{0.25};
+	duration_t maximum_delta_time {0.25};
 	//! Delta time for the current frame in seconds.
-	duration_t delta_time{0.0};
+	duration_t delta_time {0.0};
 	//! Target time per frame in seconds
-	duration_t frame_target_time{1.0 / target_fps};
+	duration_t frame_target_time {1.0 / target_fps};
 	//! Fixed delta time for fixed updates in seconds.
-	duration_t fixed_delta_time{1.0 / 50.0};
+	duration_t fixed_delta_time {1.0 / 50.0};
 	//! Total elapsed game time in microseconds.
-	elapsed_time_t elapsed_time{0};
+	elapsed_time_t elapsed_time {0};
 	//! Total elapsed time for fixed updates in microseconds.
-	elapsed_time_t elapsed_fixed_time{0};
+	elapsed_time_t elapsed_fixed_time {0};
 
 	typedef std::chrono::steady_clock::time_point time_point_t;
 	//! Time of the last frame.
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/ResourceManager.hpp b/src/crepe/manager/ResourceManager.hpp
index cf5c949..4ca6be0 100644
--- a/src/crepe/manager/ResourceManager.hpp
+++ b/src/crepe/manager/ResourceManager.hpp
@@ -9,17 +9,20 @@ namespace crepe {
 template <typename T>
 T & ResourceManager::get(const Asset & asset) {
 	using namespace std;
-	static_assert(is_base_of<Resource, T>::value,
-				  "cache must recieve a derivative class of Resource");
+	static_assert(
+		is_base_of<Resource, T>::value, "cache must recieve a derivative class of Resource"
+	);
 
 	CacheEntry & entry = this->get_entry(asset);
 	if (entry.resource == nullptr) entry.resource = make_unique<T>(asset, this->mediator);
 
 	T * concrete_resource = dynamic_cast<T *>(entry.resource.get());
 	if (concrete_resource == nullptr)
-		throw runtime_error(format("ResourceManager: mismatch between requested type and "
-								   "actual type of resource ({})",
-								   asset.get_path()));
+		throw runtime_error(format(
+			"ResourceManager: mismatch between requested type and "
+			"actual type of resource ({})",
+			asset.get_path()
+		));
 
 	return *concrete_resource;
 }
diff --git a/src/crepe/manager/SceneManager.cpp b/src/crepe/manager/SceneManager.cpp
index d4ca90b..e6f92db 100644
--- a/src/crepe/manager/SceneManager.cpp
+++ b/src/crepe/manager/SceneManager.cpp
@@ -17,10 +17,12 @@ void SceneManager::load_next_scene() {
 	// next scene not set
 	if (this->next_scene.empty()) return;
 
-	auto it = find_if(this->scenes.begin(), this->scenes.end(),
-					  [&next_scene = this->next_scene](unique_ptr<Scene> & scene) {
-						  return scene.get()->get_name() == next_scene;
-					  });
+	auto it = find_if(
+		this->scenes.begin(), this->scenes.end(),
+		[&next_scene = this->next_scene](unique_ptr<Scene> & scene) {
+			return scene.get()->get_name() == next_scene;
+		}
+	);
 
 	// next scene not found
 	if (it == this->scenes.end()) return;
diff --git a/src/crepe/manager/SystemManager.cpp b/src/crepe/manager/SystemManager.cpp
new file mode 100644
index 0000000..eabc022
--- /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<ParticleSystem>();
+	this->load_system<AISystem>();
+	this->load_system<PhysicsSystem>();
+	this->load_system<CollisionSystem>();
+	this->load_system<AudioSystem>();
+	this->load_system<AnimatorSystem>();
+	this->load_system<RenderSystem>();
+	this->load_system<ReplaySystem>();
+
+	this->mediator.system_manager = *this;
+}
+
+void SystemManager::fixed_update() {
+	for (System & system : this->system_order) {
+		if (!system.active) continue;
+		system.fixed_update();
+	}
+}
+
+void SystemManager::frame_update() {
+	for (System & system : this->system_order) {
+		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..614d90c
--- /dev/null
+++ b/src/crepe/manager/SystemManager.h
@@ -0,0 +1,93 @@
+#pragma once
+
+#include <memory>
+#include <typeindex>
+#include <unordered_map>
+#include <vector>
+
+#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 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::vector<std::reference_wrapper<System>> system_order;
+	/**
+	 * \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..addd274
--- /dev/null
+++ b/src/crepe/manager/SystemManager.hpp
@@ -0,0 +1,44 @@
+#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);
+	this->system_order.push_back(*this->systems[type]);
+}
+
+} // namespace crepe