merge with master and keypressed added to game

30 files changed, 299 insertions, 780 deletions

diff --git a/src/crepe/api/BehaviorScript.cpp b/src/crepe/api/BehaviorScript.cpp
index 7bbace0..d22afdf 100644
--- a/src/crepe/api/BehaviorScript.cpp
+++ b/src/crepe/api/BehaviorScript.cpp
@@ -4,12 +4,12 @@
 
 using namespace crepe;
 
-BehaviorScript::BehaviorScript(game_object_id_t id, ComponentManager & mgr)
+BehaviorScript::BehaviorScript(game_object_id_t id, Mediator & mediator)
 	: Component(id),
-	  component_manager(mgr) {}
+	  mediator(mediator) {}
 
 template <>
 BehaviorScript & GameObject::add_component<BehaviorScript>() {
 	ComponentManager & mgr = this->component_manager;
-	return mgr.add_component<BehaviorScript>(this->id, mgr);
+	return mgr.add_component<BehaviorScript>(this->id, mgr.mediator);
 }
diff --git a/src/crepe/api/BehaviorScript.h b/src/crepe/api/BehaviorScript.h
index d556fe5..3909b96 100644
--- a/src/crepe/api/BehaviorScript.h
+++ b/src/crepe/api/BehaviorScript.h
@@ -23,14 +23,13 @@ class BehaviorScript : public Component {
 protected:
 	/**
 	 * \param id Parent \c GameObject id
-	 * \param component_manager Reference to component manager (passed through to \c Script
-	 * instance)
+	 * \param mediator Mediator reference
 	 *
 	 * \note Calls to this constructor (should) always pass through \c GameObject::add_component,
 	 * which has an exception for this specific component type. This was done so the user does
 	 * not have to pass references used within \c Script to each \c BehaviorScript instance.
 	 */
-	BehaviorScript(game_object_id_t id, ComponentManager & component_manager);
+	BehaviorScript(game_object_id_t id, Mediator & mediator);
 	//! Only ComponentManager is allowed to instantiate BehaviorScript
 	friend class ComponentManager;
 
@@ -55,8 +54,8 @@ protected:
 	friend class ScriptSystem;
 
 protected:
-	//! Reference to component manager (passed to Script)
-	ComponentManager & component_manager;
+	//! Reference mediator
+	Mediator & mediator;
 };
 
 /**
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index bd59337..b9bb1e2 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -13,14 +13,12 @@ template <class T, typename... Args>
 BehaviorScript & BehaviorScript::set_script(Args &&... args) {
 	dbg_trace();
 	static_assert(std::is_base_of<Script, T>::value);
-	Script * s = new T(std::forward<Args>(args)...);
+	this->script = std::unique_ptr<Script>(new T(std::forward<Args>(args)...));
 
-	s->game_object_id = this->game_object_id;
-	s->active = this->active;
-	s->component_manager = this->component_manager;
-	s->event_manager = EventManager::get_instance();
+	this->script->game_object_id = this->game_object_id;
+	this->script->active = this->active;
+	this->script->mediator = this->mediator;
 
-	this->script = std::unique_ptr<Script>(s);
 	return *this;
 }
 
diff --git a/src/crepe/api/Button.cpp b/src/crepe/api/Button.cpp
new file mode 100644
index 0000000..76f74f0
--- /dev/null
+++ b/src/crepe/api/Button.cpp
@@ -0,0 +1,11 @@
+#include "Button.h"
+
+namespace crepe {
+
+Button::Button(game_object_id_t id, const vec2 & dimensions, const vec2 & offset,
+			   const std::function<void()> & on_click, bool is_toggle)
+	: UIObject(id, dimensions, offset),
+	  is_toggle(is_toggle),
+	  on_click(on_click) {}
+
+} // namespace crepe
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
new file mode 100644
index 0000000..26e7526
--- /dev/null
+++ b/src/crepe/api/Button.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <functional>
+
+#include "UIObject.h"
+
+namespace crepe {
+
+//! Represents a clickable UI button, derived from the UiObject class.
+class Button : public UIObject {
+public:
+	/**
+	 * \brief Constructs a Button with the specified game object ID and dimensions.
+	 * 
+	 * \param id The unique ID of the game object associated with this button.
+	 * \param dimensions The width and height of the UIObject
+	 * \param offset The offset relative this GameObjects Transform
+	 * \param is_toggle Optional flag to indicate if the button is a toggle button. Defaults to false.
+	 * \param on_click callback function that will be invoked when the button is clicked.
+	 */
+	Button(game_object_id_t id, const vec2 & dimensions, const vec2 & offset,
+		   const std::function<void()> & on_click, bool is_toggle = false);
+
+	/**
+	 * \brief Indicates if the button is a toggle button (can be pressed and released).
+	 * 
+	 * A toggle button allows for a pressed/released state, whereas a regular button
+	 * typically only has an on-click state.
+	 */
+	bool is_toggle = false;
+	// TODO: create separate toggle button class
+	/**
+	 * \brief The callback function to be executed when the button is clicked.
+	 * 
+	 * This function is invoked whenever the button is clicked. It can be set to any
+	 * function that matches the signature `void()`.
+	 */
+	std::function<void()> on_click = nullptr;
+
+	/**
+	 * \brief Callback function to be executed when the mouse enters the button's boundaries.
+	 *
+	 * This function is triggered when the mouse cursor moves over the button, allowing
+	 * custom actions like visual effects, highlighting, or sound effects.
+	 */
+	std::function<void()> on_mouse_enter = nullptr;
+
+	/**
+	 * \brief Callback function to be executed when the mouse exits the button's boundaries.
+	 *
+	 * This function is triggered when the mouse cursor moves out of the button's area,
+	 * allowing custom actions like resetting visual effects or playing exit-related effects.
+	 */
+	std::function<void()> on_mouse_exit = nullptr;
+
+private:
+	//! friend relation for is_pressed and hover variables
+	friend class InputSystem;
+	//! Indicates whether the toggle button is pressed
+	bool is_pressed = false;
+	//! Indicates whether the mouse is currently hovering over the button
+	bool hover = false;
+
+public:
+};
+
+} // namespace crepe
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index d8215b9..b2e3df8 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -9,15 +9,12 @@ target_sources(crepe PUBLIC
 	Texture.cpp
 	AssetManager.cpp
 	Sprite.cpp
-	SaveManager.cpp
 	Config.cpp
 	Metadata.cpp
-	SceneManager.cpp
 	Camera.cpp
 	Animator.cpp
 	BoxCollider.cpp
 	CircleCollider.cpp
-	EventManager.cpp
 	IKeyListener.cpp
 	IMouseListener.cpp
 	LoopManager.cpp
@@ -25,6 +22,8 @@ target_sources(crepe PUBLIC
 	Asset.cpp
 	EventHandler.cpp
 	Script.cpp
+	Button.cpp
+	UIObject.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
@@ -43,17 +42,12 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	Texture.h 
 	AssetManager.h 
 	AssetManager.hpp
-	SaveManager.h
 	Scene.h
 	Metadata.h
-	SceneManager.h
-	SceneManager.hpp
 	Camera.h
 	Animator.h
 	BoxCollider.h
 	CircleCollider.h
-	EventManager.h
-	EventManager.hpp
 	EventHandler.h
 	EventHandler.hpp
 	Event.h
@@ -62,4 +56,6 @@ target_sources(crepe PUBLIC FILE_SET HEADERS FILES
 	LoopManager.h
 	LoopTimer.h
 	Asset.h
+	Button.h
+	UIObject.h
 )
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 152bc2c..f2f3daf 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -3,8 +3,6 @@
 
 #include <string>
 
-#include "system/CollisionSystem.h"
-
 #include "KeyCodes.h"
 
 namespace crepe {
@@ -90,16 +88,29 @@ public:
 
 	//! Y-coordinate of the mouse position at the time of the event.
 	int mouse_y = 0;
+
+	// Movement since last event in x
+	int delta_x = 0;
+
+	// Movement since last event in y
+	int delta_y = 0;
 };
 
 /**
- * \brief Event triggered during a collision between objects.
+ * \brief Event triggered when the mouse is moved.
  */
-class CollisionEvent : public Event {
+class MouseScrollEvent : public Event {
 public:
-	crepe::CollisionSystem::CollisionInfo info;
-	CollisionEvent(const crepe::CollisionSystem::CollisionInfo & collisionInfo)
-		: info(collisionInfo) {}
+	//! X-coordinate of the mouse position at the time of the event.
+	int mouse_x = 0;
+
+	//! Y-coordinate of the mouse position at the time of the event.
+	int mouse_y = 0;
+
+	//! scroll direction (-1 = down, 1 = up)
+	int scroll_direction = 0;
+	//! scroll amount in y axis (from and away from the person).
+	float scroll_delta = 0;
 };
 
 /**
diff --git a/src/crepe/api/EventHandler.h b/src/crepe/api/EventHandler.h
index ef659fd..7bdd9a3 100644
--- a/src/crepe/api/EventHandler.h
+++ b/src/crepe/api/EventHandler.h
@@ -29,29 +29,29 @@ using EventHandler = std::function<bool(const EventType & e)>;
 class IEventHandlerWrapper {
 public:
 	/**
-     * \brief Virtual destructor for IEventHandlerWrapper.
-     */
+	 * \brief Virtual destructor for IEventHandlerWrapper.
+	 */
 	virtual ~IEventHandlerWrapper() = default;
 
 	/**
-     * \brief Executes the handler with the given event.
-     * 
-     * This method calls the `call()` method of the derived class, passing the event to the handler.
-     * 
-     * \param e The event to be processed.
-     * \return A boolean value indicating whether the event is handled.
-     */
+	 * \brief Executes the handler with the given event.
+	 * 
+	 * This method calls the `call()` method of the derived class, passing the event to the handler.
+	 * 
+	 * \param e The event to be processed.
+	 * \return A boolean value indicating whether the event is handled.
+	 */
 	bool exec(const Event & e);
 
 private:
 	/**
-     * \brief The method responsible for handling the event.
-     * 
-     * This method is implemented by derived classes to process the event.
-     * 
-     * \param e The event to be processed.
-     * \return A boolean value indicating whether the event is handled.
-     */
+	 * \brief The method responsible for handling the event.
+	 * 
+	 * This method is implemented by derived classes to process the event.
+	 * 
+	 * \param e The event to be processed.
+	 * \return A boolean value indicating whether the event is handled.
+	 */
 	virtual bool call(const Event & e) = 0;
 };
 
@@ -69,23 +69,23 @@ template <typename EventType>
 class EventHandlerWrapper : public IEventHandlerWrapper {
 public:
 	/**
-     * \brief Constructs an EventHandlerWrapper with a given handler.
-     * 
-     * The constructor takes an event handler function and stores it in the wrapper.
-     * 
-     * \param handler The event handler function.
-     */
+	 * \brief Constructs an EventHandlerWrapper with a given handler.
+	 * 
+	 * The constructor takes an event handler function and stores it in the wrapper.
+	 * 
+	 * \param handler The event handler function.
+	 */
 	explicit EventHandlerWrapper(const EventHandler<EventType> & handler);
 
 private:
 	/**
-     * \brief Calls the stored event handler with the event.
-     * 
-     * This method casts the event to the appropriate type and calls the handler.
-     * 
-     * \param e The event to be handled.
-     * \return A boolean value indicating whether the event is handled.
-     */
+	 * \brief Calls the stored event handler with the event.
+	 * 
+	 * This method casts the event to the appropriate type and calls the handler.
+	 * 
+	 * \param e The event to be handled.
+	 * \return A boolean value indicating whether the event is handled.
+	 */
 	bool call(const Event & e) override;
 	//! The event handler function.
 	EventHandler<EventType> handler;
diff --git a/src/crepe/api/EventManager.cpp b/src/crepe/api/EventManager.cpp
deleted file mode 100644
index 20f0dd3..0000000
--- a/src/crepe/api/EventManager.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-#include "EventManager.h"
-
-using namespace crepe;
-using namespace std;
-
-EventManager & EventManager::get_instance() {
-	static EventManager instance;
-	return instance;
-}
-
-void EventManager::dispatch_events() {
-	for (auto & event : this->events_queue) {
-		this->handle_event(event.type, event.channel, *event.event.get());
-	}
-	this->events_queue.clear();
-}
-
-void EventManager::handle_event(type_index type, event_channel_t channel, const Event & data) {
-	auto handlers_it = this->subscribers.find(type);
-	if (handlers_it == this->subscribers.end()) return;
-
-	vector<CallbackEntry> & handlers = handlers_it->second;
-	for (auto & handler : handlers) {
-		bool check_channel = handler.channel != CHANNEL_ALL || channel != CHANNEL_ALL;
-		if (check_channel && handler.channel != channel) continue;
-
-		bool handled = handler.callback->exec(data);
-		if (handled) return;
-	}
-}
-
-void EventManager::clear() {
-	this->subscribers.clear();
-	this->events_queue.clear();
-}
-
-void EventManager::unsubscribe(subscription_t id) {
-	for (auto & [event_type, handlers] : this->subscribers) {
-		for (auto it = handlers.begin(); it != handlers.end(); it++) {
-			// find listener with subscription id
-			if ((*it).id != id) continue;
-			it = handlers.erase(it);
-			return;
-		}
-	}
-}
diff --git a/src/crepe/api/EventManager.h b/src/crepe/api/EventManager.h
deleted file mode 100644
index 1a33023..0000000
--- a/src/crepe/api/EventManager.h
+++ /dev/null
@@ -1,161 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <typeindex>
-#include <unordered_map>
-#include <vector>
-
-#include "Event.h"
-#include "EventHandler.h"
-
-namespace crepe {
-
-//! Event listener unique ID
-typedef size_t subscription_t;
-
-/**
- * \brief Event channel
- *
- * Events can be sent to a specific channel, which prevents listeners on other channels from
- * being called. The default channel is EventManager::CHANNEL_ALL, which calls all listeners.
- */
-typedef size_t event_channel_t;
-
-/**
- * \class EventManager
- * \brief Manages event subscriptions, triggers, and queues, enabling decoupled event handling.
- * 
- * The `EventManager` acts as a centralized event system. It allows for registering callbacks
- * for specific event types, triggering events synchronously, queueing events for later
- * processing, and managing subscriptions via unique identifiers.
- */
-class EventManager {
-public:
-	static constexpr const event_channel_t CHANNEL_ALL = -1;
-
-	/**
-	 * \brief Get the singleton instance of the EventManager.
-	 * 
-	 * This method returns the unique instance of the EventManager, creating it if it
-	 * doesn't already exist. Ensures only one instance is active in the program.
-	 * 
-	 * \return Reference to the singleton instance of the EventManager.
-	 */
-	static EventManager & get_instance();
-
-	/**
-	 * \brief Subscribe to a specific event type.
-	 * 
-	 * Registers a callback for a given event type and optional channel. Each callback
-	 * is assigned a unique subscription ID that can be used for later unsubscription.
-	 * 
-	 * \tparam EventType The type of the event to subscribe to.
-	 * \param callback The callback function to be invoked when the event is triggered.
-	 * \param channel The channel number to subscribe to (default is CHANNEL_ALL, which listens to all channels).
-	 * \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);
-
-	/**
-	 * \brief Unsubscribe a previously registered callback.
-	 * 
-	 * Removes a callback from the subscription list based on its unique subscription ID.
-	 * 
-	 * \param event_id The unique subscription ID of the callback to remove.
-	 */
-	void unsubscribe(subscription_t event_id);
-
-	/**
-	 * \brief Trigger an event immediately.
-	 * 
-	 * Synchronously invokes all registered callbacks for the given event type on the specified channel.
-	 * 
-	 * \tparam EventType The type of the event to trigger.
-	 * \param event The event instance to pass to the callbacks.
-	 * \param channel The channel to trigger the event on (default is CHANNEL_ALL, which triggers on all channels).
-	 */
-	template <typename EventType>
-	void trigger_event(const EventType & event = {}, event_channel_t channel = CHANNEL_ALL);
-
-	/**
-	 * \brief Queue an event for later processing.
-	 * 
-	 * Adds an event to the event queue to be processed during the next call to `dispatch_events`.
-	 * 
-	 * \tparam EventType The type of the event to queue.
-	 * \param event The event instance to queue.
-	 * \param channel The channel to associate with the event (default is CHANNEL_ALL).
-	 */
-	template <typename EventType>
-	void queue_event(const EventType & event = {}, event_channel_t channel = CHANNEL_ALL);
-
-	/**
-	 * \brief Process all queued events.
-	 * 
-	 * Iterates through the event queue and triggers callbacks for each queued event.
-	 * Events are removed from the queue once processed.
-	 */
-	void dispatch_events();
-
-	/**
-	 * \brief Clear all subscriptions.
-	 * 
-	 * Removes all registered event handlers and clears the subscription list.
-	 */
-	void clear();
-
-private:
-	/**
-	 * \brief Default constructor for the EventManager.
-	 * 
-	 * Constructor is private to enforce the singleton pattern.
-	 */
-	EventManager() = default;
-
-	/**
-	 * \struct QueueEntry
-	 * \brief Represents an entry in the event queue.
-	 */
-	struct QueueEntry {
-		std::unique_ptr<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.
-	};
-
-	/**
-	 * \brief Internal event handler
-	 *
-	 * This function processes a single event, and is used to process events both during
-	 * EventManager::dispatch_events and inside EventManager::trigger_event
-	 *
-	 * \param type \c typeid of concrete Event class
-	 * \param channel Event channel
-	 * \param data Event data
-	 */
-	void handle_event(std::type_index type, event_channel_t channel, const Event & data);
-
-	/**
-	 * \struct CallbackEntry
-	 * \brief Represents a registered event handler callback.
-	 */
-	struct CallbackEntry {
-		std::unique_ptr<IEventHandlerWrapper> callback; ///< The callback function wrapper.
-		event_channel_t channel = CHANNEL_ALL; ///< The channel this callback listens to.
-		subscription_t id = -1; ///< Unique subscription ID.
-	};
-
-	//! The queue of events to be processed during dispatch.
-	std::vector<QueueEntry> events_queue;
-
-	//! A map of event type to registered callbacks.
-	std::unordered_map<std::type_index, std::vector<CallbackEntry>> subscribers;
-
-	//! Counter to generate unique subscription IDs.
-	subscription_t subscription_counter = 0;
-};
-
-} // namespace crepe
-
-#include "EventManager.hpp"
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
deleted file mode 100644
index a5f4556..0000000
--- a/src/crepe/api/EventManager.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#pragma once
-
-#include "EventManager.h"
-
-namespace crepe {
-
-template <typename EventType>
-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});
-	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");
-	this->events_queue.push_back(QueueEntry{
-		.event = std::make_unique<EventType>(event),
-		.channel = channel,
-		.type = typeid(EventType),
-	});
-}
-
-template <typename EventType>
-void EventManager::trigger_event(const EventType & event, event_channel_t channel) {
-	this->handle_event(typeid(EventType), channel, event);
-}
-
-} // namespace crepe
diff --git a/src/crepe/api/GameObject.hpp b/src/crepe/api/GameObject.hpp
index 17b17d7..a6b45b0 100644
--- a/src/crepe/api/GameObject.hpp
+++ b/src/crepe/api/GameObject.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../ComponentManager.h"
+#include "../manager/ComponentManager.h"
 
 #include "GameObject.h"
 
diff --git a/src/crepe/api/IKeyListener.h b/src/crepe/api/IKeyListener.h
index 328a4c2..180a0a6 100644
--- a/src/crepe/api/IKeyListener.h
+++ b/src/crepe/api/IKeyListener.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include "../manager/EventManager.h"
+
 #include "Event.h"
 #include "EventHandler.h"
-#include "EventManager.h"
 
 namespace crepe {
 
@@ -13,9 +14,9 @@ namespace crepe {
 class IKeyListener {
 public:
 	/**
-     * \brief Constructs an IKeyListener with a specified channel.
-     * \param channel The channel ID for event handling.
-     */
+	 * \brief Constructs an IKeyListener with a specified channel.
+	 * \param channel The channel ID for event handling.
+	 */
 	IKeyListener(event_channel_t channel = EventManager::CHANNEL_ALL);
 	virtual ~IKeyListener();
 	IKeyListener(const IKeyListener &) = delete;
@@ -24,17 +25,17 @@ public:
 	IKeyListener(IKeyListener &&) = delete;
 
 	/**
-     * \brief Pure virtual function to handle key press events.
-     * \param event The key press event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Pure virtual function to handle key press events.
+	 * \param event The key press event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_key_pressed(const KeyPressEvent & event) = 0;
 
 	/**
-     * \brief Pure virtual function to handle key release events.
-     * \param event The key release event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Pure virtual function to handle key release events.
+	 * \param event The key release event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_key_released(const KeyReleaseEvent & event) = 0;
 
 private:
diff --git a/src/crepe/api/IMouseListener.h b/src/crepe/api/IMouseListener.h
index 15e1619..e19897d 100644
--- a/src/crepe/api/IMouseListener.h
+++ b/src/crepe/api/IMouseListener.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include "../manager/EventManager.h"
+
 #include "Event.h"
 #include "EventHandler.h"
-#include "EventManager.h"
 
 namespace crepe {
 
@@ -13,9 +14,9 @@ namespace crepe {
 class IMouseListener {
 public:
 	/**
-     * \brief Constructs an IMouseListener with a specified channel.
-     * \param channel The channel ID for event handling.
-     */
+	 * \brief Constructs an IMouseListener with a specified channel.
+	 * \param channel The channel ID for event handling.
+	 */
 	IMouseListener(event_channel_t channel = EventManager::CHANNEL_ALL);
 	virtual ~IMouseListener();
 	IMouseListener & operator=(const IMouseListener &) = delete;
@@ -24,36 +25,36 @@ public:
 	IMouseListener(IMouseListener &&) = delete;
 
 	/**
-     * \brief Move assignment operator (deleted).
-     */
+	 * \brief Move assignment operator (deleted).
+	 */
 	IMouseListener & operator=(IMouseListener &&) = delete;
 
 	/**
-     * \brief Handles a mouse click event.
-     * \param event The mouse click event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Handles a mouse click event.
+	 * \param event The mouse click event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_mouse_clicked(const MouseClickEvent & event) = 0;
 
 	/**
-     * \brief Handles a mouse press event.
-     * \param event The mouse press event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Handles a mouse press event.
+	 * \param event The mouse press event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_mouse_pressed(const MousePressEvent & event) = 0;
 
 	/**
-     * \brief Handles a mouse release event.
-     * \param event The mouse release event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Handles a mouse release event.
+	 * \param event The mouse release event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_mouse_released(const MouseReleaseEvent & event) = 0;
 
 	/**
-     * \brief Handles a mouse move event.
-     * \param event The mouse move event to handle.
-     * \return True if the event was handled, false otherwise.
-     */
+	 * \brief Handles a mouse move event.
+	 * \param event The mouse move event to handle.
+	 * \return True if the event was handled, false otherwise.
+	 */
 	virtual bool on_mouse_moved(const MouseMoveEvent & event) = 0;
 
 private:
diff --git a/src/crepe/api/KeyCodes.h b/src/crepe/api/KeyCodes.h
index 9e173e0..fcfc080 100644
--- a/src/crepe/api/KeyCodes.h
+++ b/src/crepe/api/KeyCodes.h
@@ -1,5 +1,5 @@
 #pragma once
-
+namespace crepe {
 //! Enumeration for mouse button inputs, including standard and extended buttons.
 enum class MouseButton {
 	NONE = 0, //!< No mouse button input.
@@ -85,9 +85,9 @@ enum class Keycode {
 	PRINT_SCREEN = 283, //!< Print Screen key.
 	PAUSE = 284, //!< Pause key.
 	/**
-	 * \name Function keys (F1-F25).
-	 * \{
-	 */
+		 * \name Function keys (F1-F25).
+		 * \{
+		 */
 	F1 = 290,
 	F2 = 291,
 	F3 = 292,
@@ -115,9 +115,9 @@ enum class Keycode {
 	F25 = 314,
 	/// \}
 	/**
-	 * \name Keypad digits and operators.
-	 * \{
-	 */
+		 * \name Keypad digits and operators.
+		 * \{
+		 */
 	KP0 = 320,
 	KP1 = 321,
 	KP2 = 322,
@@ -137,9 +137,9 @@ enum class Keycode {
 	KP_EQUAL = 336,
 	/// \}
 	/**
-	 * \name Modifier keys.
-	 * \{
-	 */
+		 * \name Modifier keys.
+		 * \{
+		 */
 	LEFT_SHIFT = 340,
 	LEFT_CONTROL = 341,
 	LEFT_ALT = 342,
@@ -151,3 +151,4 @@ enum class Keycode {
 	/// \}
 	MENU = 348, //!< Menu key.
 };
+} // namespace crepe
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 478c8ba..b9e91dd 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -1,30 +1,31 @@
-#include "../facade/SDLContext.h"
-
 #include "../system/AnimatorSystem.h"
 #include "../system/CollisionSystem.h"
+#include "../system/InputSystem.h"
 #include "../system/ParticleSystem.h"
 #include "../system/PhysicsSystem.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
+#include "manager/EventManager.h"
 
 #include "LoopManager.h"
-#include "LoopTimer.h"
 
 using namespace crepe;
 using namespace std;
 
 LoopManager::LoopManager() {
+	this->mediator.component_manager = this->component_manager;
+	this->mediator.scene_manager = this->scene_manager;
+
 	this->load_system<AnimatorSystem>();
 	this->load_system<CollisionSystem>();
 	this->load_system<ParticleSystem>();
 	this->load_system<PhysicsSystem>();
 	this->load_system<RenderSystem>();
 	this->load_system<ScriptSystem>();
+	this->load_system<InputSystem>();
 }
 
-void LoopManager::process_input() {
-	SDLContext::get_instance().handle_events(this->game_running);
-}
+void LoopManager::process_input() { this->get_system<InputSystem>().update(); }
 
 void LoopManager::start() {
 	this->setup();
@@ -33,24 +34,26 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
+	EventManager & ev = this->mediator.event_manager;
+	ev.dispatch_events();
 	this->get_system<ScriptSystem>().update();
 	this->get_system<PhysicsSystem>().update();
 	this->get_system<CollisionSystem>().update();
 }
 
 void LoopManager::loop() {
-	LoopTimer & timer = LoopTimer::get_instance();
+	LoopTimer & timer = this->loop_timer;
 	timer.start();
 
 	while (game_running) {
 		timer.update();
-
+		
 		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
 		}
-
+		
 		this->update();
 		this->render();
 
@@ -59,16 +62,17 @@ void LoopManager::loop() {
 }
 
 void LoopManager::setup() {
+	LoopTimer & timer = this->loop_timer;
 	this->game_running = true;
-	LoopTimer::get_instance().start();
-	LoopTimer::get_instance().set_fps(200);
 	this->scene_manager.load_next_scene();
+	timer.start();
+	timer.set_fps(200);
 }
 
 void LoopManager::render() {
-	if (this->game_running) {
-		this->get_system<RenderSystem>().update();
-	}
+	if (!this->game_running) return;
+
+	this->get_system<RenderSystem>().update();
 }
 
-void LoopManager::update() { LoopTimer & timer = LoopTimer::get_instance(); }
+void LoopManager::update() {}
diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h
index 13e6dac..d8910a0 100644
--- a/src/crepe/api/LoopManager.h
+++ b/src/crepe/api/LoopManager.h
@@ -2,9 +2,12 @@
 
 #include <memory>
 
-#include "../ComponentManager.h"
+#include "../facade/SDLContext.h"
+#include "../manager/ComponentManager.h"
+#include "../manager/SceneManager.h"
 #include "../system/System.h"
-#include "api/SceneManager.h"
+
+#include "LoopTimer.h"
 
 namespace crepe {
 
@@ -85,10 +88,18 @@ private:
 	bool game_running = false;
 
 private:
+	//! Global context
+	Mediator mediator;
+
 	//! Component manager instance
-	ComponentManager component_manager{};
+	ComponentManager component_manager{mediator};
 	//! Scene manager instance
-	SceneManager scene_manager{component_manager};
+	SceneManager scene_manager{mediator};
+
+	//! SDL context \todo no more singletons!
+	SDLContext & sdl_context = SDLContext::get_instance();
+	//! Loop timer \todo no more singletons!
+	LoopTimer & loop_timer = LoopTimer::get_instance();
 
 private:
 	/**
diff --git a/src/crepe/api/LoopManager.hpp b/src/crepe/api/LoopManager.hpp
index 9cf470b..266758a 100644
--- a/src/crepe/api/LoopManager.hpp
+++ b/src/crepe/api/LoopManager.hpp
@@ -38,8 +38,11 @@ void LoopManager::load_system() {
 	static_assert(is_base_of<System, T>::value,
 				  "load_system must recieve a derivative class of System");
 
-	System * system = new T(this->component_manager);
-	this->systems[typeid(T)] = unique_ptr<System>(system);
+	const type_info & type = typeid(T);
+	if (this->systems.contains(type))
+		throw runtime_error(format("LoopManager: {} is already initialized", type.name()));
+	System * system = new T(this->mediator);
+	this->systems[type] = unique_ptr<System>(system);
 }
 
 } // namespace crepe
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 293b1a4..b0a24f7 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,11 +1,13 @@
 #pragma once
 
 #include <cmath>
+#include <set>
 
 #include "../Component.h"
 
 #include "types.h"
 
+
 namespace crepe {
 
 /**
@@ -138,7 +140,7 @@ public:
 		 * Each element in the vector represents a layer ID, and the GameObject will only detect 
 		 * collisions with other GameObjects that belong to these layers.
 		 */
-		std::vector<int> collision_layers;
+		std::set<int> collision_layers;
 	};
 
 public:
diff --git a/src/crepe/api/SaveManager.cpp b/src/crepe/api/SaveManager.cpp
deleted file mode 100644
index c5f43ea..0000000
--- a/src/crepe/api/SaveManager.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#include "../facade/DB.h"
-#include "../util/Log.h"
-
-#include "Config.h"
-#include "SaveManager.h"
-#include "ValueBroker.h"
-
-using namespace std;
-using namespace crepe;
-
-template <>
-string SaveManager::serialize(const string & value) const noexcept {
-	return value;
-}
-template <typename T>
-string SaveManager::serialize(const T & value) const noexcept {
-	return to_string(value);
-}
-template string SaveManager::serialize(const uint8_t &) const noexcept;
-template string SaveManager::serialize(const int8_t &) const noexcept;
-template string SaveManager::serialize(const uint16_t &) const noexcept;
-template string SaveManager::serialize(const int16_t &) const noexcept;
-template string SaveManager::serialize(const uint32_t &) const noexcept;
-template string SaveManager::serialize(const int32_t &) const noexcept;
-template string SaveManager::serialize(const uint64_t &) const noexcept;
-template string SaveManager::serialize(const int64_t &) const noexcept;
-template string SaveManager::serialize(const float &) const noexcept;
-template string SaveManager::serialize(const double &) const noexcept;
-
-template <>
-uint64_t SaveManager::deserialize(const string & value) const noexcept {
-	try {
-		return stoul(value);
-	} catch (std::invalid_argument &) {
-		return 0;
-	}
-}
-template <>
-int64_t SaveManager::deserialize(const string & value) const noexcept {
-	try {
-		return stol(value);
-	} catch (std::invalid_argument &) {
-		return 0;
-	}
-}
-template <>
-float SaveManager::deserialize(const string & value) const noexcept {
-	try {
-		return stof(value);
-	} catch (std::invalid_argument &) {
-		return 0;
-	}
-	return stof(value);
-}
-template <>
-double SaveManager::deserialize(const string & value) const noexcept {
-	try {
-		return stod(value);
-	} catch (std::invalid_argument &) {
-		return 0;
-	}
-}
-template <>
-string SaveManager::deserialize(const string & value) const noexcept {
-	return value;
-}
-
-template <>
-uint8_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<uint64_t>(value);
-}
-template <>
-int8_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<int64_t>(value);
-}
-template <>
-uint16_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<uint64_t>(value);
-}
-template <>
-int16_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<int64_t>(value);
-}
-template <>
-uint32_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<uint64_t>(value);
-}
-template <>
-int32_t SaveManager::deserialize(const string & value) const noexcept {
-	return deserialize<int64_t>(value);
-}
-
-SaveManager::SaveManager() { dbg_trace(); }
-
-SaveManager & SaveManager::get_instance() {
-	dbg_trace();
-	static SaveManager instance;
-	return instance;
-}
-
-DB & SaveManager::get_db() {
-	Config & cfg = Config::get_instance();
-	// TODO: make this path relative to XDG_DATA_HOME on Linux and whatever the
-	// default equivalent is on Windows using some third party library
-	static DB db(cfg.savemgr.location);
-	return db;
-}
-
-bool SaveManager::has(const string & key) {
-	DB & db = this->get_db();
-	return db.has(key);
-}
-
-template <>
-void SaveManager::set(const string & key, const string & value) {
-	DB & db = this->get_db();
-	db.set(key, value);
-}
-template <typename T>
-void SaveManager::set(const string & key, const T & value) {
-	DB & db = this->get_db();
-	db.set(key, std::to_string(value));
-}
-template void SaveManager::set(const string &, const uint8_t &);
-template void SaveManager::set(const string &, const int8_t &);
-template void SaveManager::set(const string &, const uint16_t &);
-template void SaveManager::set(const string &, const int16_t &);
-template void SaveManager::set(const string &, const uint32_t &);
-template void SaveManager::set(const string &, const int32_t &);
-template void SaveManager::set(const string &, const uint64_t &);
-template void SaveManager::set(const string &, const int64_t &);
-template void SaveManager::set(const string &, const float &);
-template void SaveManager::set(const string &, const double &);
-
-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);
-}
-template ValueBroker<uint8_t> SaveManager::get(const string &, const uint8_t &);
-template ValueBroker<int8_t> SaveManager::get(const string &, const int8_t &);
-template ValueBroker<uint16_t> SaveManager::get(const string &, const uint16_t &);
-template ValueBroker<int16_t> SaveManager::get(const string &, const int16_t &);
-template ValueBroker<uint32_t> SaveManager::get(const string &, const uint32_t &);
-template ValueBroker<int32_t> SaveManager::get(const string &, const int32_t &);
-template ValueBroker<uint64_t> SaveManager::get(const string &, const uint64_t &);
-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 & {
-			value = this->deserialize<T>(this->get_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/api/SaveManager.h b/src/crepe/api/SaveManager.h
deleted file mode 100644
index 3d8c852..0000000
--- a/src/crepe/api/SaveManager.h
+++ /dev/null
@@ -1,114 +0,0 @@
-#pragma once
-
-#include <memory>
-
-#include "../ValueBroker.h"
-
-namespace crepe {
-
-class DB;
-
-/**
- * \brief Save data manager
- *
- * This class provides access to a simple key-value store that stores
- * - integers (8-64 bit, signed or unsigned)
- * - real numbers (float or double)
- * - string (std::string)
- *
- * The underlying database is a key-value store.
- */
-class SaveManager {
-public:
-	/**
-	 * \brief Get a read/write reference to a value and initialize it if it does not yet exist
-	 *
-	 * \param key  The value key
-	 * \param default_value  Value to initialize \c key with if it does not already exist in the
-	 * database
-	 *
-	 * \return Read/write reference to the value
-	 */
-	template <typename T>
-	ValueBroker<T> get(const std::string & key, const T & default_value);
-
-	/**
-	 * \brief Get a read/write reference to a value
-	 *
-	 * \param key  The value key
-	 *
-	 * \return Read/write reference to 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);
-
-	/**
-	 * \brief Set a value directly
-	 *
-	 * \param key  The value key
-	 * \param value  The value to store
-	 */
-	template <typename T>
-	void set(const std::string & key, const T & value);
-
-	/**
-	 * \brief Check if the save file has a value for this \c key
-	 *
-	 * \param key  The value key
-	 *
-	 * \returns True if the key exists, or false if it does not
-	 */
-	bool has(const std::string & key);
-
-private:
-	SaveManager();
-	virtual ~SaveManager() = default;
-
-private:
-	/**
-	 * \brief Serialize an arbitrary value to STL string
-	 *
-	 * \tparam T  Type of arbitrary value
-	 *
-	 * \returns String representation of value
-	 */
-	template <typename T>
-	std::string serialize(const T &) const noexcept;
-
-	/**
-	 * \brief Deserialize an STL string back to type \c T
-	 *
-	 * \tparam T  Type of value
-	 * \param value  Serialized value
-	 *
-	 * \returns Deserialized value
-	 */
-	template <typename T>
-	T deserialize(const std::string & value) const noexcept;
-
-public:
-	// singleton
-	static SaveManager & get_instance();
-	SaveManager(const SaveManager &) = delete;
-	SaveManager(SaveManager &&) = delete;
-	SaveManager & operator=(const SaveManager &) = delete;
-	SaveManager & operator=(SaveManager &&) = delete;
-
-private:
-	/**
-	 * \brief Create an instance of DB and return its reference
-	 *
-	 * \returns DB instance
-	 *
-	 * This function exists because DB is a facade class, which can't directly be used in the API
-	 * without workarounds
-	 *
-	 * TODO: better solution
-	 */
-	static DB & get_db();
-};
-
-} // namespace crepe
diff --git a/src/crepe/api/Scene.h b/src/crepe/api/Scene.h
index f6fdb2a..9f1e8ce 100644
--- a/src/crepe/api/Scene.h
+++ b/src/crepe/api/Scene.h
@@ -2,6 +2,7 @@
 
 #include <string>
 
+#include "../manager/Mediator.h"
 #include "../util/OptionalRef.h"
 
 namespace crepe {
@@ -34,6 +35,9 @@ public:
 	 */
 	virtual std::string get_name() const = 0;
 
+	// TODO: Late references should ALWAYS be private! This is currently kept as-is so unit tests
+	// keep passing, but this reference should not be directly accessible by the user!!!
+
 protected:
 	/**
 	 * \name Late references
@@ -46,8 +50,8 @@ protected:
 	 *
 	 * \{
 	 */
-	//! Reference to the ComponentManager
-	OptionalRef<ComponentManager> component_manager;
+	//! Mediator reference
+	OptionalRef<Mediator> mediator;
 	//! \}
 };
 
diff --git a/src/crepe/api/SceneManager.cpp b/src/crepe/api/SceneManager.cpp
deleted file mode 100644
index 1f783ad..0000000
--- a/src/crepe/api/SceneManager.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include <algorithm>
-#include <memory>
-
-#include "../ComponentManager.h"
-
-#include "SceneManager.h"
-
-using namespace crepe;
-using namespace std;
-
-SceneManager::SceneManager(ComponentManager & mgr) : component_manager(mgr) {}
-
-void SceneManager::set_next_scene(const string & name) { next_scene = name; }
-
-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;
-					  });
-
-	// next scene not found
-	if (it == this->scenes.end()) return;
-	unique_ptr<Scene> & scene = *it;
-
-	// Delete all components of the current scene
-	ComponentManager & mgr = this->component_manager;
-	mgr.delete_all_components();
-
-	// Load the new scene
-	scene->load_scene();
-}
diff --git a/src/crepe/api/SceneManager.h b/src/crepe/api/SceneManager.h
deleted file mode 100644
index f6f62cd..0000000
--- a/src/crepe/api/SceneManager.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "Scene.h"
-
-namespace crepe {
-
-class ComponentManager;
-
-/**
- * \brief Manages scenes
- *
- * This class manages scenes. It can add new scenes and load them. It also manages the current scene
- * and the next scene.
- */
-class SceneManager {
-public:
-	//! \param mgr  Reference to the ComponentManager
-	SceneManager(ComponentManager & mgr);
-
-public:
-	/**
-	 * \brief Add a new concrete scene to the scene manager
-	 *
-	 * \tparam T  Type of concrete scene
-	 */
-	template <typename T, typename... Args>
-	void add_scene(Args &&... args);
-	/**
-	 * \brief Set the next scene
-	 *
-	 * This scene will be loaded at the end of the frame
-	 *
-	 * \param name  Name of the next scene
-	 */
-	void set_next_scene(const std::string & name);
-	//! Load a new scene (if there is one)
-	void load_next_scene();
-
-private:
-	//! Vector of concrete scenes (added by add_scene())
-	std::vector<std::unique_ptr<Scene>> scenes;
-	//! Next scene to load
-	std::string next_scene;
-	//! Reference to the ComponentManager
-	ComponentManager & component_manager;
-};
-
-} // namespace crepe
-
-#include "SceneManager.hpp"
diff --git a/src/crepe/api/SceneManager.hpp b/src/crepe/api/SceneManager.hpp
deleted file mode 100644
index 5c8e417..0000000
--- a/src/crepe/api/SceneManager.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "SceneManager.h"
-
-namespace crepe {
-
-template <typename T, typename... Args>
-void SceneManager::add_scene(Args &&... args) {
-	using namespace std;
-	static_assert(is_base_of<Scene, T>::value, "T must be derived from Scene");
-
-	Scene * scene = new T(std::forward<Args>(args)...);
-	unique_ptr<Scene> unique_scene(scene);
-
-	unique_scene->component_manager = this->component_manager;
-
-	this->scenes.emplace_back(std::move(unique_scene));
-
-	// The first scene added, is the one that will be loaded at the beginning
-	if (next_scene.empty()) {
-		next_scene = scene->get_name();
-	}
-}
-
-} // namespace crepe
diff --git a/src/crepe/api/Script.cpp b/src/crepe/api/Script.cpp
index fcbe4c7..4091fd4 100644
--- a/src/crepe/api/Script.cpp
+++ b/src/crepe/api/Script.cpp
@@ -1,11 +1,17 @@
+#include <string>
+
+#include "../manager/SceneManager.h"
+
 #include "Script.h"
 
 using namespace crepe;
+using namespace std;
 
 Script::~Script() {
-	EventManager & evmgr = this->event_manager;
+	Mediator & mediator = this->mediator;
+	EventManager & mgr = mediator.event_manager;
 	for (auto id : this->listeners) {
-		evmgr.unsubscribe(id);
+		mgr.unsubscribe(id);
 	}
 }
 
@@ -13,3 +19,9 @@ template <>
 void Script::subscribe(const EventHandler<CollisionEvent> & callback) {
 	this->subscribe_internal(callback, this->game_object_id);
 }
+
+void Script::set_next_scene(const string & name) {
+	Mediator & mediator = this->mediator;
+	SceneManager & mgr = mediator.scene_manager;
+	mgr.set_next_scene(name);
+}
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index a0870cb..1474a09 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -2,11 +2,12 @@
 
 #include <vector>
 
+#include "../manager/EventManager.h"
+#include "system/CollisionSystem.h"
+#include "../manager/Mediator.h"
 #include "../types.h"
 #include "../util/OptionalRef.h"
 
-#include "EventManager.h"
-
 namespace crepe {
 
 class ScriptSystem;
@@ -106,6 +107,12 @@ protected:
 	template <typename EventType>
 	void subscribe(const EventHandler<EventType> & callback);
 
+	/**
+	 * \brief Set the next scene using SceneManager
+	 * \see SceneManager::set_next_scene
+	 */
+	void set_next_scene(const std::string & name);
+
 	//! \}
 
 private:
@@ -160,10 +167,8 @@ private:
 	game_object_id_t game_object_id;
 	//! Reference to parent component
 	OptionalRef<bool> active;
-	//! Reference to component manager instance
-	OptionalRef<ComponentManager> component_manager;
-	//! Reference to event manager instance
-	OptionalRef<EventManager> event_manager;
+	//! Mediator reference
+	OptionalRef<Mediator> mediator;
 	//! \}
 
 private:
diff --git a/src/crepe/api/Script.hpp b/src/crepe/api/Script.hpp
index a2463bf..45f1ff1 100644
--- a/src/crepe/api/Script.hpp
+++ b/src/crepe/api/Script.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "../ComponentManager.h"
+#include "../manager/ComponentManager.h"
 
 #include "BehaviorScript.h"
 #include "Script.h"
@@ -20,7 +20,8 @@ T & Script::get_component() const {
 
 template <typename T>
 RefVector<T> Script::get_components() const {
-	ComponentManager & mgr = this->component_manager;
+	Mediator & mediator = this->mediator;
+	ComponentManager & mgr = mediator.component_manager;
 
 	return mgr.get_components_by_id<T>(this->game_object_id);
 }
@@ -33,7 +34,8 @@ void Script::logf(Args &&... args) {
 template <typename EventType>
 void Script::subscribe_internal(const EventHandler<EventType> & callback,
 								event_channel_t channel) {
-	EventManager & mgr = this->event_manager;
+	Mediator & mediator = this->mediator;
+	EventManager & mgr = mediator.event_manager;
 	subscription_t listener = mgr.subscribe<EventType>(
 		[this, callback](const EventType & data) -> bool {
 			bool & active = this->active;
diff --git a/src/crepe/api/UIObject.cpp b/src/crepe/api/UIObject.cpp
new file mode 100644
index 0000000..d239b89
--- /dev/null
+++ b/src/crepe/api/UIObject.cpp
@@ -0,0 +1,8 @@
+#include "UIObject.h"
+
+using namespace crepe;
+
+UIObject::UIObject(game_object_id_t id, const vec2 & dimensions, const vec2 & offset)
+	: Component(id),
+	  dimensions(dimensions),
+	  offset(offset) {}
diff --git a/src/crepe/api/UIObject.h b/src/crepe/api/UIObject.h
new file mode 100644
index 0000000..f7f4fba
--- /dev/null
+++ b/src/crepe/api/UIObject.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "../Component.h"
+
+namespace crepe {
+
+/**
+ * \brief Represents a UI object in the game, derived from the Component class.
+ */
+class UIObject : public Component {
+public:
+	/**
+	 * \brief Constructs a UiObject with the specified game object ID.
+	 * \param id The unique ID of the game object associated with this UI object.
+	 * \param dimensions width and height of the UIObject
+	 * \param offset Offset relative to the GameObject Transform
+	 */
+	UIObject(game_object_id_t id, const vec2 & dimensions, const vec2 & offset);
+	//! Width and height of the UIObject
+	vec2 dimensions;
+	//! Position offset relative to this GameObjects Transform
+	vec2 offset;
+};
+
+} // namespace crepe