From 29f9a26046e35c7eb0157df92757ce8e39f1ec74 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 28 Oct 2024 11:06:21 +0100
Subject: iMouseListener and iKeyListener implementation

---
 mwe/events/include/event.h | 51 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

(limited to 'mwe/events/include/event.h')

diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index 0208085..8968c6c 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -64,7 +64,20 @@ public:
 	Keycode key = 0;
 	int repeatCount = 0;
 };
+class MouseClickEvent : public Event {
+public:
+    MouseClickEvent(int x, int y, MouseButton button);
+
+	REGISTER_EVENT_TYPE("KeyClickedEvent");
+    int getX() const { return x; }
+    int getY() const { return y; }
+    MouseButton getButton() const { return button; }
 
+private:
+    int x;
+    int y;
+    MouseButton button;
+};
 // KeyReleasedEvent class
 class KeyReleasedEvent : public Event {
 public:
@@ -87,6 +100,31 @@ public:
 
 	std::pair<int, int> getMousePosition() const;
 
+private:
+	int mouseX = 0;
+	int mouseY = 0;
+	MouseButton button;
+};
+class MouseReleasedEvent : public Event {
+public:
+	MouseReleasedEvent(int mouseX, int mouseY, MouseButton button);
+
+	REGISTER_EVENT_TYPE(MouseReleasedEvent)
+
+	std::pair<int, int> getMousePosition() const;
+	MouseButton getMouseButton() const;
+private:
+	int mouseX = 0;
+	int mouseY = 0;
+	MouseButton button;
+};
+class MouseMovedEvent : public Event {
+public:
+	MouseMovedEvent(int mouseX, int mouseY);
+
+	REGISTER_EVENT_TYPE(MouseMovedEvent)
+
+	std::pair<int, int> getMousePosition() const;
 private:
 	int mouseX = 0;
 	int mouseY = 0;
@@ -103,3 +141,16 @@ private:
    	Collision collisionData;
     
 };
+class TextSubmitEvent : public Event {
+public:
+    TextSubmitEvent(std::string submittedText);
+
+    REGISTER_EVENT_TYPE(TextSubmitEvent)
+
+    std::string getText() const {
+        return text;
+    }
+
+private:
+    std::string text;
+};
-- 
cgit v1.2.3


From f2136f836f9b9e9a6a6698f7bc6fba85a27ebebf Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 28 Oct 2024 11:34:43 +0100
Subject: iKeyListener test and iMouseListener test working

---
 mwe/events/CMakeLists.txt              |  5 ++++-
 mwe/events/include/event.h             | 13 +++++--------
 mwe/events/include/iKeyListener.h      |  2 ++
 mwe/events/include/iMouseListener.h    | 26 ++++----------------------
 mwe/events/include/keyListenerTest.h   | 12 ++++++++++++
 mwe/events/include/mouseListenerTest.h | 14 ++++++++++++++
 mwe/events/src/event.cpp               | 24 +++++++++++++++++++++---
 mwe/events/src/keyListenerTest.cpp     | 17 +++++++++++++++++
 mwe/events/src/main.cpp                | 11 +++++++----
 mwe/events/src/mouseListenerTest.cpp   | 25 +++++++++++++++++++++++++
 10 files changed, 111 insertions(+), 38 deletions(-)
 create mode 100644 mwe/events/include/keyListenerTest.h
 create mode 100644 mwe/events/include/mouseListenerTest.h
 create mode 100644 mwe/events/src/keyListenerTest.cpp
 create mode 100644 mwe/events/src/mouseListenerTest.cpp

(limited to 'mwe/events/include/event.h')

diff --git a/mwe/events/CMakeLists.txt b/mwe/events/CMakeLists.txt
index e429516..096b8ad 100644
--- a/mwe/events/CMakeLists.txt
+++ b/mwe/events/CMakeLists.txt
@@ -13,13 +13,16 @@ find_package(SDL2 REQUIRED)
 add_executable(gameloop
 	src/window.cpp
 	src/main.cpp
-	#src/eventHandler.cpp
 	src/eventManager.cpp
 	src/event.cpp
 	src/loopManager.cpp
 	src/timer.cpp
 	src/keyCodes.cpp
 	src/eventHandler.cpp
+	src/iMouseListener.cpp
+	src/iKeyListener.cpp
+	src/mouseListenerTest.cpp
+	src/keyListenerTest.cpp
 )
 add_subdirectory(../../lib/SDL_ttf SDL_ttf)
 # Link the SDL2 library to your project
diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index 8968c6c..65560a1 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -67,15 +67,14 @@ public:
 class MouseClickEvent : public Event {
 public:
     MouseClickEvent(int x, int y, MouseButton button);
-
+	
 	REGISTER_EVENT_TYPE("KeyClickedEvent");
-    int getX() const { return x; }
-    int getY() const { return y; }
+	std::pair<int, int> getMousePosition() const;
     MouseButton getButton() const { return button; }
 
 private:
-    int x;
-    int y;
+    int mouseX = 0;
+	int mouseY = 0;
     MouseButton button;
 };
 // KeyReleasedEvent class
@@ -147,9 +146,7 @@ public:
 
     REGISTER_EVENT_TYPE(TextSubmitEvent)
 
-    std::string getText() const {
-        return text;
-    }
+    std::string getText() const;
 
 private:
     std::string text;
diff --git a/mwe/events/include/iKeyListener.h b/mwe/events/include/iKeyListener.h
index 87ee1d5..5f39ece 100644
--- a/mwe/events/include/iKeyListener.h
+++ b/mwe/events/include/iKeyListener.h
@@ -11,6 +11,8 @@ public:
 protected:
     void subscribeEvents(int listenerId = 0);
     void unsubscribeEvents(int listenerId = 0);
+	void activate(int listenerId = 0) { subscribeEvents(listenerId); }
+    void deactivate(int listenerId = 0) { unsubscribeEvents(listenerId); }
 
 private:
     EventHandler<KeyPressedEvent> keyPressedHandler;
diff --git a/mwe/events/include/iMouseListener.h b/mwe/events/include/iMouseListener.h
index 7ae371c..03fd4c3 100644
--- a/mwe/events/include/iMouseListener.h
+++ b/mwe/events/include/iMouseListener.h
@@ -1,36 +1,18 @@
+#pragma once
 #include "event.h"
 #include "eventManager.h"
 #include "eventHandler.h"
 class IMouseListener {
 public:
-    virtual ~IMouseListener() {
-        unsubscribeEvents();
-    }
+    virtual ~IMouseListener();
 
     virtual void onMouseClicked(const MouseClickEvent& event) = 0;
     virtual void onMousePressed(const MousePressedEvent& event) = 0;
     virtual void onMouseReleased(const MouseReleasedEvent& event) = 0;
     virtual void onMouseMoved(const MouseMovedEvent& event) = 0;
-
 protected:
-    void subscribeEvents(int listenerId = 0) {
-        mouseClickHandler = [this](const MouseClickEvent& event) { this->onMouseClicked(event); };
-        mousePressHandler = [this](const MousePressedEvent& event) { this->onMousePressed(event); };
-        mouseReleaseHandler = [this](const MouseReleasedEvent& event) { this->onMouseReleased(event); };
-        mouseMoveHandler = [this](const MouseMovedEvent& event) { this->onMouseMoved(event); };
-
-        subscribe<MouseClickEvent>(mouseClickHandler, listenerId);
-        subscribe<MousePressedEvent>(mousePressHandler, listenerId);
-        subscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
-        subscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
-    }
-
-    void unsubscribeEvents(int listenerId = 0) {
-        unsubscribe<MouseClickEvent>(mouseClickHandler, listenerId);
-        unsubscribe<MousePressedEvent>(mousePressHandler, listenerId);
-        unsubscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
-        unsubscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
-    }
+    void subscribeEvents(int listenerId = 0);
+    void unsubscribeEvents(int listenerId = 0);
 
 private:
     EventHandler<MouseClickEvent> mouseClickHandler;
diff --git a/mwe/events/include/keyListenerTest.h b/mwe/events/include/keyListenerTest.h
new file mode 100644
index 0000000..5990cd1
--- /dev/null
+++ b/mwe/events/include/keyListenerTest.h
@@ -0,0 +1,12 @@
+#pragma once
+#include "iKeyListener.h"
+#include <iostream>
+
+class KeyListenerTest : public IKeyListener {
+public:
+    KeyListenerTest(int listenerId);
+    ~KeyListenerTest();
+
+    void onKeyPressed(const KeyPressedEvent& event) override;
+    void onKeyReleased(const KeyReleasedEvent& event) override;
+};
diff --git a/mwe/events/include/mouseListenerTest.h b/mwe/events/include/mouseListenerTest.h
new file mode 100644
index 0000000..dae04f5
--- /dev/null
+++ b/mwe/events/include/mouseListenerTest.h
@@ -0,0 +1,14 @@
+#pragma once
+#include "iMouseListener.h"
+#include <iostream>
+
+class MouseListenerTest : public IMouseListener {
+public:
+    MouseListenerTest(int listenerId);
+    ~MouseListenerTest();
+
+    void onMouseClicked(const MouseClickEvent& event) override;
+    void onMousePressed(const MousePressedEvent& event) override;
+    void onMouseReleased(const MouseReleasedEvent& event) override;
+    void onMouseMoved(const MouseMovedEvent& event) override;
+};
diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp
index 2509088..fc8eec9 100644
--- a/mwe/events/src/event.cpp
+++ b/mwe/events/src/event.cpp
@@ -53,10 +53,28 @@ Collision CollisionEvent::getCollisionData() const
 	return this->collisionData;
 }
 
-TextSubmitEvent::TextSubmitEvent(std::string text) : Event("TextSubmitEvent"){
+TextSubmitEvent::TextSubmitEvent(std::string text) 
+    : text(text), Event("TextSubmitEvent") {}
 
+std::string TextSubmitEvent::getText() const {
+    return this->text;
 }
-std::string TextSubmitEvent::getText() const{
-	return this->text;
+
+MouseReleasedEvent::MouseReleasedEvent(int x, int y, MouseButton button) : mouseX(x), mouseY(y), button(button),Event("MouseReleased"){
+
+}
+std::pair<int, int> MouseReleasedEvent::getMousePosition() const{
+	return {mouseX,mouseY};
+}
+MouseClickEvent::MouseClickEvent(int x,int y,MouseButton button) : mouseX(x), mouseY(y), button(button),Event("MouseClickEvent"){
+
 }
+MouseMovedEvent::MouseMovedEvent(int x, int y) : mouseX(x), mouseY(y),Event("MouseMovedEvent"){
 
+}
+std::pair<int, int> MouseClickEvent::getMousePosition() const {
+	return {mouseX, mouseY};
+}
+std::pair<int, int> MouseMovedEvent::getMousePosition() const {
+	return {mouseX, mouseY};
+}
diff --git a/mwe/events/src/keyListenerTest.cpp b/mwe/events/src/keyListenerTest.cpp
new file mode 100644
index 0000000..90b92a5
--- /dev/null
+++ b/mwe/events/src/keyListenerTest.cpp
@@ -0,0 +1,17 @@
+#include "keyListenerTest.h"
+
+KeyListenerTest::KeyListenerTest(int listenerId) {
+    subscribeEvents(listenerId);
+}
+
+KeyListenerTest::~KeyListenerTest() {
+    unsubscribeEvents();
+}
+
+void KeyListenerTest::onKeyPressed(const KeyPressedEvent& event) {
+    std::cout << "Key pressed: " << event.getKeyCode() << std::endl;
+}
+
+void KeyListenerTest::onKeyReleased(const KeyReleasedEvent& event) {
+    std::cout << "Key released: " << event.getKeyCode() << std::endl;
+}
diff --git a/mwe/events/src/main.cpp b/mwe/events/src/main.cpp
index d056f85..03dff16 100644
--- a/mwe/events/src/main.cpp
+++ b/mwe/events/src/main.cpp
@@ -6,6 +6,10 @@
 #include "loopManager.h"
 #include "event.h"
 #include "customTypes.h"
+#include "iKeyListener.h"
+#include "iMouseListener.h"
+#include "keyListenerTest.h"
+#include "mouseListenerTest.h"
 class PlayerDamagedEvent : public Event {
 public:
 	PlayerDamagedEvent(int damage, int playerID)
@@ -46,10 +50,9 @@ void testCollisionEvent() {
 }
 int main(int argc, char * args[]) {
 	LoopManager gameLoop;
-	// Create an event handler for KeyPressedEvent
-	// EventHandler<KeyPressedEvent> callback = [](const KeyPressedEvent& e) {
-	//     onKeyPressed(e);
-	// };
+	int testListenerId = 0;
+	KeyListenerTest keyListener(testListenerId);
+    MouseListenerTest mouseListener(testListenerId);
 	// custom event class poc
 	subscribe<PlayerDamagedEvent>(onPlayerDamaged);
 	triggerEvent(PlayerDamagedEvent(50, 1));
diff --git a/mwe/events/src/mouseListenerTest.cpp b/mwe/events/src/mouseListenerTest.cpp
new file mode 100644
index 0000000..4b3aa3e
--- /dev/null
+++ b/mwe/events/src/mouseListenerTest.cpp
@@ -0,0 +1,25 @@
+#include "mouseListenerTest.h"
+
+MouseListenerTest::MouseListenerTest(int listenerId) {
+    subscribeEvents(listenerId);
+}
+
+MouseListenerTest::~MouseListenerTest() {
+    unsubscribeEvents();
+}
+
+void MouseListenerTest::onMouseClicked(const MouseClickEvent& event) {
+    std::cout << "Mouse clicked at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+}
+
+void MouseListenerTest::onMousePressed(const MousePressedEvent& event) {
+    std::cout << "Mouse button pressed at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+}
+
+void MouseListenerTest::onMouseReleased(const MouseReleasedEvent& event) {
+    std::cout << "Mouse button released at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+}
+
+void MouseListenerTest::onMouseMoved(const MouseMovedEvent& event) {
+    std::cout << "Mouse moved to: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+}
-- 
cgit v1.2.3


From 5e833bba513d97c39f4e0d26b45a9095c32812a6 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 28 Oct 2024 17:58:53 +0100
Subject: button working

---
 mwe/events/CMakeLists.txt           | 37 +++++++++++--------
 mwe/events/include/event.h          | 20 +++++++++-
 mwe/events/include/eventHandler.h   |  4 +-
 mwe/events/include/gameObject.h     | 14 +++----
 mwe/events/include/iMouseListener.h |  3 +-
 mwe/events/include/inputSystem.h    | 16 ++++++++
 mwe/events/include/loopManager.h    |  7 ++++
 mwe/events/include/uiObject.h       | 17 +++++----
 mwe/events/include/uiRenderer.h     | 17 +++++++++
 mwe/events/include/window.h         | 28 +++++++++-----
 mwe/events/src/event.cpp            |  4 +-
 mwe/events/src/inputSystem.cpp      | 39 +++++++++++++++++++
 mwe/events/src/loopManager.cpp      | 61 +++++++++++++++++-------------
 mwe/events/src/uiObject.cpp         |  2 +-
 mwe/events/src/uiRenderer.cpp       | 72 ++++++++++++++++++++++++++++++++++++
 mwe/events/src/window.cpp           | 74 +++++++++++++++++++++++++------------
 16 files changed, 321 insertions(+), 94 deletions(-)
 create mode 100644 mwe/events/include/inputSystem.h
 create mode 100644 mwe/events/include/uiRenderer.h
 create mode 100644 mwe/events/src/inputSystem.cpp
 create mode 100644 mwe/events/src/uiRenderer.cpp

(limited to 'mwe/events/include/event.h')

diff --git a/mwe/events/CMakeLists.txt b/mwe/events/CMakeLists.txt
index 096b8ad..12e45a7 100644
--- a/mwe/events/CMakeLists.txt
+++ b/mwe/events/CMakeLists.txt
@@ -2,34 +2,39 @@ cmake_minimum_required(VERSION 3.5)
 project(gameloop)
 
 # Set the C++ standard (optional, but good practice)
-set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD 17)
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
 set(CMAKE_BUILD_TYPE Debug)
 
 # Find the SDL2 package
 find_package(SDL2 REQUIRED)
+# Find the SDL2_ttf package
+find_package(SDL2_ttf REQUIRED)
 
 add_executable(gameloop
-	src/window.cpp
-	src/main.cpp
-	src/eventManager.cpp
-	src/event.cpp
-	src/loopManager.cpp
-	src/timer.cpp
-	src/keyCodes.cpp
-	src/eventHandler.cpp
-	src/iMouseListener.cpp
-	src/iKeyListener.cpp
-	src/mouseListenerTest.cpp
-	src/keyListenerTest.cpp
+    src/window.cpp
+    src/main.cpp
+    src/eventManager.cpp
+    src/event.cpp
+    src/loopManager.cpp
+    src/timer.cpp
+    src/keyCodes.cpp
+    src/eventHandler.cpp
+    src/iMouseListener.cpp
+    src/iKeyListener.cpp
+    src/mouseListenerTest.cpp
+    src/keyListenerTest.cpp
+    src/inputSystem.cpp
+    src/uiRenderer.cpp
+    src/uiObject.cpp
 )
-add_subdirectory(../../lib/SDL_ttf SDL_ttf)
-# Link the SDL2 library to your project
-target_link_libraries(gameloop ${SDL2_LIBRARIES})
+
+target_link_libraries(gameloop ${SDL2_LIBRARIES} SDL2_ttf::SDL2_ttf)
 
 # Include SDL2 header files and project headers
 target_include_directories(gameloop PRIVATE ${SDL2_INCLUDE_DIRS})
 target_include_directories(gameloop PRIVATE ${CMAKE_SOURCE_DIR}/include)
 
+# Copy font files to the build directory
 file(COPY ${PROJECT_SOURCE_DIR}/font DESTINATION ${CMAKE_BINARY_DIR})
diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index 65560a1..b1b6867 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -7,7 +7,6 @@
 #include <variant>
 #include "keyCodes.h"
 #include "customTypes.h"
-
 class UUIDGenerator {
 public:
 	static std::uint32_t getUniqueID() {
@@ -151,3 +150,22 @@ public:
 private:
     std::string text;
 };
+class ShutDownEvent : public Event {
+public:
+    ShutDownEvent() : Event("ShutDownEvent"){};
+
+    REGISTER_EVENT_TYPE(ShutDownEvent)
+
+private:
+};
+// class ButtonClickEvent : public Event {
+// public:
+//     ButtonClickEvent(int x,int y,int width,int height);
+
+//     REGISTER_EVENT_TYPE(TextSubmitEvent)
+
+//     std::string getText() const;
+
+// private:
+//     std::string text;
+// };
diff --git a/mwe/events/include/eventHandler.h b/mwe/events/include/eventHandler.h
index 7414801..7d8f20a 100644
--- a/mwe/events/include/eventHandler.h
+++ b/mwe/events/include/eventHandler.h
@@ -1,9 +1,9 @@
 #pragma once
-
 #include "event.h"
-
 #include <functional>
 #include <iostream>
+
+
 template <typename EventType>
 using EventHandler = std::function<void(const EventType & e)>;
 
diff --git a/mwe/events/include/gameObject.h b/mwe/events/include/gameObject.h
index 70d4517..de5f3fe 100644
--- a/mwe/events/include/gameObject.h
+++ b/mwe/events/include/gameObject.h
@@ -3,14 +3,14 @@
 #include <string>
 class GameObject {
 public:
-	GameObject(std::uint32_t id, std::string name, std::string tag, int layer);
+	GameObject(){}
 
-	template <typename... Args>
-	void addSpriteComponent(Args &&... args);
-	template <typename... Args>
-	void addRigidbodyComponent(Args &&... args);
-	template <typename... Args>
-	void addColiderComponent(Args &&... args);
+	// template <typename... Args>
+	// void addSpriteComponent(Args &&... args);
+	// template <typename... Args>
+	// void addRigidbodyComponent(Args &&... args);
+	// template <typename... Args>
+	// void addColiderComponent(Args &&... args);
 
 	std::uint32_t mId;
 	std::string mName;
diff --git a/mwe/events/include/iMouseListener.h b/mwe/events/include/iMouseListener.h
index 03fd4c3..7d840c1 100644
--- a/mwe/events/include/iMouseListener.h
+++ b/mwe/events/include/iMouseListener.h
@@ -1,7 +1,8 @@
 #pragma once
 #include "event.h"
-#include "eventManager.h"
 #include "eventHandler.h"
+#include "eventManager.h"
+
 class IMouseListener {
 public:
     virtual ~IMouseListener();
diff --git a/mwe/events/include/inputSystem.h b/mwe/events/include/inputSystem.h
new file mode 100644
index 0000000..06db74c
--- /dev/null
+++ b/mwe/events/include/inputSystem.h
@@ -0,0 +1,16 @@
+#pragma once
+#include <vector>
+#include "uiObject.h"
+#include "event.h"
+#include "keyCodes.h"
+#include "eventManager.h"
+class InputSystem {
+public:
+    InputSystem();
+    void registerButton(Button* button);
+    void processInput();
+
+private:
+    std::vector<Button*> buttons;
+    void processMouseClick(int mouseX, int mouseY);
+};
diff --git a/mwe/events/include/loopManager.h b/mwe/events/include/loopManager.h
index baffb94..289ff0f 100644
--- a/mwe/events/include/loopManager.h
+++ b/mwe/events/include/loopManager.h
@@ -6,6 +6,10 @@
 #include "eventHandler.h"
 #include "eventManager.h"
 #include "loopManager.h"
+#include "uiRenderer.h"
+#include "uiObject.h"
+#include "inputSystem.h"
+#include <memory>
 class LoopManager {
 public:
 	LoopManager();
@@ -19,6 +23,7 @@ private:
 	void lateUpdate();
 	void fixedUpdate();
 	void render();
+	void onShutdown(const ShutDownEvent& e);
 	bool gameRunning = false;
 	WindowManager window;
 	int timeScale = 1;
@@ -26,4 +31,6 @@ private:
 	double currentTime;
 	double t = 0.0;
 	double dt = 0.01;
+	std::unique_ptr<InputSystem> inputSystem;
+	EventHandler<ShutDownEvent> shutdownHandler;
 };
diff --git a/mwe/events/include/uiObject.h b/mwe/events/include/uiObject.h
index 46d32be..720d5c2 100644
--- a/mwe/events/include/uiObject.h
+++ b/mwe/events/include/uiObject.h
@@ -1,8 +1,10 @@
+#pragma once
 #include "gameObject.h"
 #include <SDL2/SDL.h>
 #include <SDL_ttf.h>
 #include "event.h"
 #include "eventHandler.h"
+#include <functional>
 struct Alignment {
     enum class Horizontal { LEFT, CENTER, RIGHT };
     enum class Vertical { TOP, MIDDLE, BOTTOM };
@@ -21,28 +23,29 @@ struct Alignment {
     int marginRight = 0;
 };
 struct RGBColor{
-	int red,
-	int green,
-	int blue
+	int red;
+	int green;
+	int blue;
 };
 class UIObject : public GameObject{
 	public:
 	UIObject(int width,int height);
-	private:
+	virtual ~UIObject() {}
 	int width;
 	int height;
+	int x;
+	int y;
 };
 class Button : public UIObject{
 	public:
 	Button(int width,int height);
-	EventHandler<KeyPressedEvent> onKeyPressed;
-	EventHandler<KeyReleasedEvent> onKeyReleased;
+	RGBColor color;
+	std::function<void()> onClick;
 
 };
 class Text : public UIObject{
 	public:
 	Text(int width,int height);
-	private:
 	std::string text;
 	int size;
 	Alignment alignment;
diff --git a/mwe/events/include/uiRenderer.h b/mwe/events/include/uiRenderer.h
new file mode 100644
index 0000000..286ac1f
--- /dev/null
+++ b/mwe/events/include/uiRenderer.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+#include "uiObject.h"
+
+class UIRenderer {
+public:
+    UIRenderer(SDL_Renderer* renderer);
+    void render(UIObject* uiObject);
+
+private:
+    SDL_Renderer* renderer;
+
+    void renderButton(Button* button);
+    void renderText(Text* text);
+    void renderTextInput(TextInput* textInput);
+};
diff --git a/mwe/events/include/window.h b/mwe/events/include/window.h
index 9020b1a..3c34d4c 100644
--- a/mwe/events/include/window.h
+++ b/mwe/events/include/window.h
@@ -1,19 +1,27 @@
 #pragma once
 #include <SDL2/SDL.h>
-#include <iostream>
 #include <vector>
+#include "uiObject.h"
+#include "uiRenderer.h"
+
 class WindowManager {
 public:
-	WindowManager();
-	virtual ~WindowManager();
-	bool initWindow();
-	void destroyWindow();
+    WindowManager();
+    virtual ~WindowManager();
+
+    bool initWindow();
+    void destroyWindow();
+    SDL_Renderer* getRenderer();
 
-	SDL_Renderer * getRenderer();
+    void addUIObject(UIObject* uiObject);
+    void renderUIObjects();
 
 private:
-	const int SCREEN_WIDTH = 800;
-	const int SCREEN_HEIGHT = 600;
-	SDL_Window * window = NULL;
-	SDL_Renderer * renderer = NULL;
+    const int SCREEN_WIDTH = 800;
+    const int SCREEN_HEIGHT = 600;
+    SDL_Window* window = nullptr;
+    SDL_Renderer* renderer = nullptr;
+
+    UIRenderer* uiRenderer;
+    std::vector<UIObject*> uiObjects;
 };
diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp
index fc8eec9..0a7454d 100644
--- a/mwe/events/src/event.cpp
+++ b/mwe/events/src/event.cpp
@@ -54,7 +54,9 @@ Collision CollisionEvent::getCollisionData() const
 }
 
 TextSubmitEvent::TextSubmitEvent(std::string text) 
-    : text(text), Event("TextSubmitEvent") {}
+    : text(text), Event("TextSubmitEvent") {
+		
+	}
 
 std::string TextSubmitEvent::getText() const {
     return this->text;
diff --git a/mwe/events/src/inputSystem.cpp b/mwe/events/src/inputSystem.cpp
new file mode 100644
index 0000000..ffab84b
--- /dev/null
+++ b/mwe/events/src/inputSystem.cpp
@@ -0,0 +1,39 @@
+#include "inputSystem.h"
+
+InputSystem::InputSystem() {}
+
+void InputSystem::registerButton(Button* button) {
+    buttons.push_back(button);
+}
+
+void InputSystem::processInput() {
+	
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                triggerEvent(ShutDownEvent());
+                break;
+            case SDL_KEYDOWN:
+                triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym)));
+                break;
+            case SDL_MOUSEBUTTONDOWN: {
+                int mouseX, mouseY;
+                SDL_GetMouseState(&mouseX, &mouseY);
+                processMouseClick(mouseX, mouseY);
+                triggerEvent(MousePressedEvent(mouseX, mouseY));
+                break;
+            }
+        }
+    }
+}
+
+void InputSystem::processMouseClick(int mouseX, int mouseY) {
+    for (auto* button : buttons) {
+        if (mouseX >= button->x && mouseX <= (button->x + button->width) &&
+            mouseY >= button->y && mouseY <= (button->y + button->height)) {
+            button->onClick();
+        }
+    }
+}
+
diff --git a/mwe/events/src/loopManager.cpp b/mwe/events/src/loopManager.cpp
index 8ecb932..83ccfc3 100644
--- a/mwe/events/src/loopManager.cpp
+++ b/mwe/events/src/loopManager.cpp
@@ -1,22 +1,27 @@
 #include "loopManager.h"
 
-LoopManager::LoopManager() {}
+LoopManager::LoopManager() 
+    : inputSystem(std::make_unique<InputSystem>()){
+	shutdownHandler = [this](const ShutDownEvent& event) { this->onShutdown(event); };
+	subscribe(shutdownHandler);
+}
 void LoopManager::processInput() {
-	SDL_Event event;
-	SDL_PollEvent(&event);
-	switch (event.type) {
-		case SDL_QUIT:
-			gameRunning = false;
-			break;
-		case SDL_KEYDOWN:
-			triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym)));
-			break;
-		case SDL_MOUSEBUTTONDOWN:
-			int x, y;
-			SDL_GetMouseState(&x, &y);
-			triggerEvent(MousePressedEvent(x, y));
-			break;
-	}
+	inputSystem->processInput();
+	// SDL_Event event;
+	// SDL_PollEvent(&event);
+	// switch (event.type) {
+	// 	case SDL_QUIT:
+	// 		gameRunning = false;
+	// 		break;
+	// 	case SDL_KEYDOWN:
+	// 		triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym)));
+	// 		break;
+	// 	case SDL_MOUSEBUTTONDOWN:
+	// 		int x, y;
+	// 		SDL_GetMouseState(&x, &y);
+	// 		triggerEvent(MousePressedEvent(x, y));
+	// 		break;
+	// }
 }
 void LoopManager::setRunning(bool running) { this->gameRunning = running; }
 void LoopManager::fixedUpdate() {
@@ -28,9 +33,8 @@ void LoopManager::loop() {
 
 	while (gameRunning) {
 		timer.update();
-
+		processInput();
 		while (timer.getLag() >= timer.getFixedDeltaTime()) {
-			processInput();
 			fixedUpdate();
 			timer.advanceFixedUpdate();
 		}
@@ -66,22 +70,29 @@ void LoopManager::setup() {
 			  }
 		  };
 	subscribe<KeyPressedEvent>(closeWindowCallback, false);
+	Button* testButton = new Button(200,200);
+	testButton->color = {100,0,100};
+	testButton->onClick = []() {
+    	std::cout << "Button was clicked" << std::endl;
+	};
+	testButton->x = 200;
+	testButton->y = 200;
+	inputSystem->registerButton(testButton);
+
+	window.addUIObject(testButton);
 }
 void LoopManager::render() {
 	//fprintf(stderr, "**********render********** \n");
 	if (gameRunning) {
-		//window.render(objectList);
+		window.renderUIObjects();
 	}
 }
-
+void LoopManager::onShutdown(const ShutDownEvent& e){
+	this->gameRunning = false;
+}
 void LoopManager::update() {
 	//fprintf(stderr, "**********normal update********** \n");
 	LoopTimer & timer = LoopTimer::getInstance();
 
 	float delta = timer.getDeltaTime();
-
-	// for (int i = 0; i < objectList.size(); i++) {
-	// 	objectList[i]->setX(objectList[i]->getX() + 50 * delta);
-	// 	objectList[i]->setY(objectList[i]->getY() + 50 * delta);
-	// }
 }
diff --git a/mwe/events/src/uiObject.cpp b/mwe/events/src/uiObject.cpp
index b941858..ef4443f 100644
--- a/mwe/events/src/uiObject.cpp
+++ b/mwe/events/src/uiObject.cpp
@@ -2,7 +2,7 @@
 
 // Constructor for UIObject
 UIObject::UIObject(int width, int height)
-    : width(width), height(height) {
+    : width(width), height(height){
 
 	}
 
diff --git a/mwe/events/src/uiRenderer.cpp b/mwe/events/src/uiRenderer.cpp
new file mode 100644
index 0000000..4a756f9
--- /dev/null
+++ b/mwe/events/src/uiRenderer.cpp
@@ -0,0 +1,72 @@
+#include "uiRenderer.h"
+
+// Constructor
+UIRenderer::UIRenderer(SDL_Renderer* renderer) : renderer(renderer) {}
+
+// Render function
+void UIRenderer::render(UIObject* uiObject) {
+    if (Button* button = dynamic_cast<Button*>(uiObject)) {
+        renderButton(button);
+    } else if (Text* text = dynamic_cast<Text*>(uiObject)) {
+        renderText(text);
+    } else if (TextInput* textInput = dynamic_cast<TextInput*>(uiObject)) {
+        renderTextInput(textInput);
+    }
+}
+
+// Private helper function to render a Button
+void UIRenderer::renderButton(Button* button) {
+    SDL_Rect buttonRect = {button->x, button->y, button->width, button->height};
+    SDL_SetRenderDrawColor(renderer, 100, 100, 255, 255); // Button color
+    SDL_RenderFillRect(renderer, &buttonRect);
+}
+
+// Private helper function to render a Text
+void UIRenderer::renderText(Text* text) {
+    if (text->font != nullptr) {
+        SDL_Color sdlColor = {text->color.red, text->color.green, text->color.blue, 255};
+        SDL_Surface* textSurface = TTF_RenderText_Blended(text->font, text->text.c_str(), sdlColor);
+        if (!textSurface) {
+            std::cerr << "Error creating text surface: " << TTF_GetError() << std::endl;
+            return;
+        }
+
+        SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
+        if (!textTexture) {
+            std::cerr << "Error creating texture from surface: " << SDL_GetError() << std::endl;
+            SDL_FreeSurface(textSurface);
+            return;
+        }
+
+        SDL_Rect textRect = {text->x, text->y, textSurface->w, textSurface->h};
+        SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
+        SDL_FreeSurface(textSurface);
+        SDL_DestroyTexture(textTexture);
+    }
+}
+
+// Private helper function to render a TextInput
+void UIRenderer::renderTextInput(TextInput* textInput) {
+    SDL_Rect inputRect = {textInput->x, textInput->y, textInput->width, textInput->height};
+    SDL_SetRenderDrawColor(renderer, textInput->backgroundColor.red, textInput->backgroundColor.green, textInput->backgroundColor.blue, 255);
+    SDL_RenderFillRect(renderer, &inputRect);
+
+    // Render text or placeholder
+    if (!textInput->textBuffer.empty()) {
+        SDL_Color sdlColor = {textInput->textColor.red, textInput->textColor.green, textInput->textColor.blue, 255};
+        SDL_Surface* textSurface = TTF_RenderText_Blended(textInput->font, textInput->textBuffer.c_str(), sdlColor);
+        SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
+        SDL_Rect textRect = {textInput->x + 5, textInput->y + 5, textSurface->w, textSurface->h};
+        SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
+        SDL_FreeSurface(textSurface);
+        SDL_DestroyTexture(textTexture);
+    } else if (!textInput->placeholder.empty()) {
+        SDL_Color sdlColor = {128, 128, 128, 255};  // Placeholder color
+        SDL_Surface* placeholderSurface = TTF_RenderText_Blended(textInput->font, textInput->placeholder.c_str(), sdlColor);
+        SDL_Texture* placeholderTexture = SDL_CreateTextureFromSurface(renderer, placeholderSurface);
+        SDL_Rect placeholderRect = {textInput->x + 5, textInput->y + 5, placeholderSurface->w, placeholderSurface->h};
+        SDL_RenderCopy(renderer, placeholderTexture, nullptr, &placeholderRect);
+        SDL_FreeSurface(placeholderSurface);
+        SDL_DestroyTexture(placeholderTexture);
+    }
+}
diff --git a/mwe/events/src/window.cpp b/mwe/events/src/window.cpp
index 41eb85f..a3bae40 100644
--- a/mwe/events/src/window.cpp
+++ b/mwe/events/src/window.cpp
@@ -1,29 +1,57 @@
 #include "window.h"
-WindowManager::WindowManager() {}
-WindowManager::~WindowManager() { destroyWindow(); }
-SDL_Renderer * WindowManager::getRenderer() { return renderer; }
+#include <iostream>
+
+
+WindowManager::WindowManager() {
+	this->uiRenderer = nullptr;
+}
+
+
+WindowManager::~WindowManager() {
+    destroyWindow();
+}
 
 bool WindowManager::initWindow() {
-	if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
-		fprintf(stderr, "Error inititalising SDL.\n");
-		return false;
-	}
-	window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED,
-							  SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
-							  SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
-	if (!window) {
-		fprintf(stderr, "Error creating SDL Window. \n");
-		return false;
-	}
-	renderer = SDL_CreateRenderer(window, -1, 0);
-	if (!renderer) {
-		fprintf(stderr, "Error creating SDL renderer. \n");
-		return false;
-	}
-	return true;
+    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
+        std::cerr << "Error initializing SDL.\n";
+        return false;
+    }
+
+    window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED,
+                              SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
+                              SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
+    if (!window) {
+        std::cerr << "Error creating SDL Window.\n";
+        return false;
+    }
+
+    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+    if (!renderer) {
+        std::cerr << "Error creating SDL renderer.\n";
+        return false;
+    }
+
+    uiRenderer = new UIRenderer(renderer);
+    return true;
 }
+
 void WindowManager::destroyWindow() {
-	SDL_DestroyRenderer(renderer);
-	SDL_DestroyWindow(window);
-	SDL_Quit();
+    delete uiRenderer;
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+}
+
+SDL_Renderer* WindowManager::getRenderer() {
+    return renderer;
+}
+void WindowManager::addUIObject(UIObject* uiObject) {
+    uiObjects.push_back(uiObject);
+}
+
+void WindowManager::renderUIObjects() {
+    for (UIObject* obj : uiObjects) {
+        uiRenderer->render(obj);
+    }
+	SDL_RenderPresent(this->renderer);
 }
-- 
cgit v1.2.3


From 2585dc3cab48ccad0cfa0c63354662d656c86c46 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Sun, 3 Nov 2024 13:34:27 +0100
Subject: `make format`

---
 mwe/audio/miniaudio/main.cpp           |   6 +-
 mwe/events/include/event.h             |  26 ++---
 mwe/events/include/eventHandler.h      |   1 -
 mwe/events/include/gameObject.h        |   2 +-
 mwe/events/include/iKeyListener.h      |  19 ++--
 mwe/events/include/iMouseListener.h    |  23 ++---
 mwe/events/include/inputSystem.h       |  27 +++---
 mwe/events/include/keyCodes.h          |  16 ++--
 mwe/events/include/keyListenerTest.h   |   8 +-
 mwe/events/include/loopManager.h       |   6 +-
 mwe/events/include/mouseListenerTest.h |  12 +--
 mwe/events/include/uiObject.h          |  74 +++++++-------
 mwe/events/include/uiRenderer.h        |  18 ++--
 mwe/events/include/window.h            |  30 +++---
 mwe/events/src/event.cpp               |  29 +++---
 mwe/events/src/iKeyListener.cpp        |  19 ++--
 mwe/events/src/iMouseListener.cpp      |  35 ++++---
 mwe/events/src/inputSystem.cpp         | 162 +++++++++++++++----------------
 mwe/events/src/keyListenerTest.cpp     |  14 ++-
 mwe/events/src/loopManager.cpp         |  22 ++---
 mwe/events/src/main.cpp                |  13 +--
 mwe/events/src/mouseListenerTest.cpp   |  26 ++---
 mwe/events/src/uiObject.cpp            |  30 +++---
 mwe/events/src/uiRenderer.cpp          | 170 +++++++++++++++++----------------
 mwe/events/src/window.cpp              |  72 +++++++-------
 mwe/gameloop/include/loopManager.h     |   2 +-
 mwe/gameloop/src/loopManager.cpp       |   9 +-
 src/crepe/api/Transform.cpp            |   3 +-
 src/example/audio_internal.cpp         |   6 +-
 src/example/log.cpp                    |   4 +-
 src/example/script.cpp                 |  12 ++-
 31 files changed, 435 insertions(+), 461 deletions(-)

(limited to 'mwe/events/include/event.h')

diff --git a/mwe/audio/miniaudio/main.cpp b/mwe/audio/miniaudio/main.cpp
index bf31898..5c4f667 100644
--- a/mwe/audio/miniaudio/main.cpp
+++ b/mwe/audio/miniaudio/main.cpp
@@ -33,12 +33,10 @@ int main() {
 	ma_sound_start(&sfx[2]);
 	ma_sound_start(&bgm); // this actually resumes now
 	this_thread::sleep_for(500ms);
-	for (unsigned i = 0; i < 3; i++)
-		ma_sound_seek_to_pcm_frame(&sfx[i], 0);
+	for (unsigned i = 0; i < 3; i++) ma_sound_seek_to_pcm_frame(&sfx[i], 0);
 
 	// 5. play all samples simultaniously
-	for (unsigned i = 0; i < 3; i++)
-		ma_sound_start(&sfx[i]);
+	for (unsigned i = 0; i < 3; i++) ma_sound_start(&sfx[i]);
 	this_thread::sleep_for(1000ms);
 
 	ma_engine_uninit(&engine);
diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index 62d8974..16c75bf 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -6,8 +6,6 @@
 #include <string>
 #include <unordered_map>
 #include <variant>
-#include "keyCodes.h"
-#include "customTypes.h"
 class UUIDGenerator {
 public:
 	static std::uint32_t getUniqueID() {
@@ -66,16 +64,16 @@ public:
 };
 class MouseClickEvent : public Event {
 public:
-    MouseClickEvent(int x, int y, MouseButton button);
-	
+	MouseClickEvent(int x, int y, MouseButton button);
+
 	REGISTER_EVENT_TYPE("KeyClickedEvent");
 	std::pair<int, int> getMousePosition() const;
-    MouseButton getButton() const { return button; }
+	MouseButton getButton() const { return button; }
 
 private:
-    int mouseX = 0;
+	int mouseX = 0;
 	int mouseY = 0;
-    MouseButton button;
+	MouseButton button;
 };
 // KeyReleasedEvent class
 class KeyReleasedEvent : public Event {
@@ -112,6 +110,7 @@ public:
 
 	std::pair<int, int> getMousePosition() const;
 	MouseButton getMouseButton() const;
+
 private:
 	int mouseX = 0;
 	int mouseY = 0;
@@ -124,6 +123,7 @@ public:
 	REGISTER_EVENT_TYPE(MouseMovedEvent)
 
 	std::pair<int, int> getMousePosition() const;
+
 private:
 	int mouseX = 0;
 	int mouseY = 0;
@@ -141,20 +141,20 @@ private:
 };
 class TextSubmitEvent : public Event {
 public:
-    TextSubmitEvent(std::string submittedText);
+	TextSubmitEvent(std::string submittedText);
 
-    REGISTER_EVENT_TYPE(TextSubmitEvent)
+	REGISTER_EVENT_TYPE(TextSubmitEvent)
 
-    std::string getText() const;
+	std::string getText() const;
 
 private:
-    std::string text;
+	std::string text;
 };
 class ShutDownEvent : public Event {
 public:
-    ShutDownEvent() : Event("ShutDownEvent"){};
+	ShutDownEvent() : Event("ShutDownEvent") {};
 
-    REGISTER_EVENT_TYPE(ShutDownEvent)
+	REGISTER_EVENT_TYPE(ShutDownEvent)
 
 private:
 };
diff --git a/mwe/events/include/eventHandler.h b/mwe/events/include/eventHandler.h
index 7d8f20a..aa8f63b 100644
--- a/mwe/events/include/eventHandler.h
+++ b/mwe/events/include/eventHandler.h
@@ -3,7 +3,6 @@
 #include <functional>
 #include <iostream>
 
-
 template <typename EventType>
 using EventHandler = std::function<void(const EventType & e)>;
 
diff --git a/mwe/events/include/gameObject.h b/mwe/events/include/gameObject.h
index de5f3fe..48e239b 100644
--- a/mwe/events/include/gameObject.h
+++ b/mwe/events/include/gameObject.h
@@ -3,7 +3,7 @@
 #include <string>
 class GameObject {
 public:
-	GameObject(){}
+	GameObject() {}
 
 	// template <typename... Args>
 	// void addSpriteComponent(Args &&... args);
diff --git a/mwe/events/include/iKeyListener.h b/mwe/events/include/iKeyListener.h
index 5f39ece..5fee2eb 100644
--- a/mwe/events/include/iKeyListener.h
+++ b/mwe/events/include/iKeyListener.h
@@ -1,21 +1,20 @@
 #pragma once
 #include "event.h"
-#include "eventManager.h"
 #include "eventHandler.h"
+#include "eventManager.h"
 class IKeyListener {
 public:
-    virtual ~IKeyListener();
-    virtual void onKeyPressed(const KeyPressedEvent& event) = 0;
-    virtual void onKeyReleased(const KeyReleasedEvent& event) = 0;
+	virtual ~IKeyListener();
+	virtual void onKeyPressed(const KeyPressedEvent & event) = 0;
+	virtual void onKeyReleased(const KeyReleasedEvent & event) = 0;
 
 protected:
-    void subscribeEvents(int listenerId = 0);
-    void unsubscribeEvents(int listenerId = 0);
+	void subscribeEvents(int listenerId = 0);
+	void unsubscribeEvents(int listenerId = 0);
 	void activate(int listenerId = 0) { subscribeEvents(listenerId); }
-    void deactivate(int listenerId = 0) { unsubscribeEvents(listenerId); }
+	void deactivate(int listenerId = 0) { unsubscribeEvents(listenerId); }
 
 private:
-    EventHandler<KeyPressedEvent> keyPressedHandler;
-    EventHandler<KeyReleasedEvent> keyReleasedHandler;
+	EventHandler<KeyPressedEvent> keyPressedHandler;
+	EventHandler<KeyReleasedEvent> keyReleasedHandler;
 };
-
diff --git a/mwe/events/include/iMouseListener.h b/mwe/events/include/iMouseListener.h
index 7d840c1..5b1181c 100644
--- a/mwe/events/include/iMouseListener.h
+++ b/mwe/events/include/iMouseListener.h
@@ -5,19 +5,20 @@
 
 class IMouseListener {
 public:
-    virtual ~IMouseListener();
+	virtual ~IMouseListener();
+
+	virtual void onMouseClicked(const MouseClickEvent & event) = 0;
+	virtual void onMousePressed(const MousePressedEvent & event) = 0;
+	virtual void onMouseReleased(const MouseReleasedEvent & event) = 0;
+	virtual void onMouseMoved(const MouseMovedEvent & event) = 0;
 
-    virtual void onMouseClicked(const MouseClickEvent& event) = 0;
-    virtual void onMousePressed(const MousePressedEvent& event) = 0;
-    virtual void onMouseReleased(const MouseReleasedEvent& event) = 0;
-    virtual void onMouseMoved(const MouseMovedEvent& event) = 0;
 protected:
-    void subscribeEvents(int listenerId = 0);
-    void unsubscribeEvents(int listenerId = 0);
+	void subscribeEvents(int listenerId = 0);
+	void unsubscribeEvents(int listenerId = 0);
 
 private:
-    EventHandler<MouseClickEvent> mouseClickHandler;
-    EventHandler<MousePressedEvent> mousePressHandler;
-    EventHandler<MouseReleasedEvent> mouseReleaseHandler;
-    EventHandler<MouseMovedEvent> mouseMoveHandler;
+	EventHandler<MouseClickEvent> mouseClickHandler;
+	EventHandler<MousePressedEvent> mousePressHandler;
+	EventHandler<MouseReleasedEvent> mouseReleaseHandler;
+	EventHandler<MouseMovedEvent> mouseMoveHandler;
 };
diff --git a/mwe/events/include/inputSystem.h b/mwe/events/include/inputSystem.h
index c20562d..3e53b7c 100644
--- a/mwe/events/include/inputSystem.h
+++ b/mwe/events/include/inputSystem.h
@@ -1,24 +1,23 @@
 #pragma once
-#include <vector>
-#include "uiObject.h"
 #include "event.h"
-#include "keyCodes.h"
 #include "eventManager.h"
+#include "keyCodes.h"
+#include "uiObject.h"
+#include <vector>
 class InputSystem {
 public:
-    InputSystem();
-    void registerButton(Button* button);
-	void registerText(Text* label);
-	void registerTextInput(TextInput* input);
-    void processInput();
+	InputSystem();
+	void registerButton(Button * button);
+	void registerText(Text * label);
+	void registerTextInput(TextInput * input);
+	void processInput();
 
 private:
-    std::vector<Button*> buttons;
-	std::vector<TextInput*> textInputs;
-	std::vector<Text*> texts;
-    void processMouseClick(int mouseX, int mouseY);
+	std::vector<Button *> buttons;
+	std::vector<TextInput *> textInputs;
+	std::vector<Text *> texts;
+	void processMouseClick(int mouseX, int mouseY);
 	void processInputField(int mouseX, int mouseY);
 	void processKeyPress(Keycode);
-	void processTextInput(const std::string& text);
-	
+	void processTextInput(const std::string & text);
 };
diff --git a/mwe/events/include/keyCodes.h b/mwe/events/include/keyCodes.h
index 61deba2..73ba1cd 100644
--- a/mwe/events/include/keyCodes.h
+++ b/mwe/events/include/keyCodes.h
@@ -4,14 +4,14 @@
 #include <unordered_map>
 using Keycode = uint16_t;
 enum class MouseButton {
-    None = 0,
-    Left_Mouse = 1,
-    Right_Mouse = 2,
-    Middle_Mouse = 3,
-    X1_Mouse = 4,
-    X2_Mouse = 5,
-    Scroll_Up = 6,
-    Scroll_Down = 7,
+	None = 0,
+	Left_Mouse = 1,
+	Right_Mouse = 2,
+	Middle_Mouse = 3,
+	X1_Mouse = 4,
+	X2_Mouse = 5,
+	Scroll_Up = 6,
+	Scroll_Down = 7,
 };
 enum : Keycode {
 	// From glfw3.h
diff --git a/mwe/events/include/keyListenerTest.h b/mwe/events/include/keyListenerTest.h
index 5990cd1..08f3feb 100644
--- a/mwe/events/include/keyListenerTest.h
+++ b/mwe/events/include/keyListenerTest.h
@@ -4,9 +4,9 @@
 
 class KeyListenerTest : public IKeyListener {
 public:
-    KeyListenerTest(int listenerId);
-    ~KeyListenerTest();
+	KeyListenerTest(int listenerId);
+	~KeyListenerTest();
 
-    void onKeyPressed(const KeyPressedEvent& event) override;
-    void onKeyReleased(const KeyReleasedEvent& event) override;
+	void onKeyPressed(const KeyPressedEvent & event) override;
+	void onKeyReleased(const KeyReleasedEvent & event) override;
 };
diff --git a/mwe/events/include/loopManager.h b/mwe/events/include/loopManager.h
index 289ff0f..9959c94 100644
--- a/mwe/events/include/loopManager.h
+++ b/mwe/events/include/loopManager.h
@@ -5,10 +5,10 @@
 //#include "combinedEvent.h"
 #include "eventHandler.h"
 #include "eventManager.h"
+#include "inputSystem.h"
 #include "loopManager.h"
-#include "uiRenderer.h"
 #include "uiObject.h"
-#include "inputSystem.h"
+#include "uiRenderer.h"
 #include <memory>
 class LoopManager {
 public:
@@ -23,7 +23,7 @@ private:
 	void lateUpdate();
 	void fixedUpdate();
 	void render();
-	void onShutdown(const ShutDownEvent& e);
+	void onShutdown(const ShutDownEvent & e);
 	bool gameRunning = false;
 	WindowManager window;
 	int timeScale = 1;
diff --git a/mwe/events/include/mouseListenerTest.h b/mwe/events/include/mouseListenerTest.h
index dae04f5..ca9afc5 100644
--- a/mwe/events/include/mouseListenerTest.h
+++ b/mwe/events/include/mouseListenerTest.h
@@ -4,11 +4,11 @@
 
 class MouseListenerTest : public IMouseListener {
 public:
-    MouseListenerTest(int listenerId);
-    ~MouseListenerTest();
+	MouseListenerTest(int listenerId);
+	~MouseListenerTest();
 
-    void onMouseClicked(const MouseClickEvent& event) override;
-    void onMousePressed(const MousePressedEvent& event) override;
-    void onMouseReleased(const MouseReleasedEvent& event) override;
-    void onMouseMoved(const MouseMovedEvent& event) override;
+	void onMouseClicked(const MouseClickEvent & event) override;
+	void onMousePressed(const MousePressedEvent & event) override;
+	void onMouseReleased(const MouseReleasedEvent & event) override;
+	void onMouseMoved(const MouseMovedEvent & event) override;
 };
diff --git a/mwe/events/include/uiObject.h b/mwe/events/include/uiObject.h
index 893232d..23efe44 100644
--- a/mwe/events/include/uiObject.h
+++ b/mwe/events/include/uiObject.h
@@ -1,70 +1,68 @@
 #pragma once
+#include "event.h"
+#include "eventHandler.h"
 #include "gameObject.h"
 #include <SDL2/SDL.h>
 #include <SDL_ttf.h>
-#include "event.h"
-#include "eventHandler.h"
 #include <functional>
 struct Alignment {
-    enum class Horizontal { LEFT, CENTER, RIGHT };
-    enum class Vertical { TOP, MIDDLE, BOTTOM };
-    enum class PositioningMode { RELATIVE, STATIC,ABSOLUTE };
+	enum class Horizontal { LEFT, CENTER, RIGHT };
+	enum class Vertical { TOP, MIDDLE, BOTTOM };
+	enum class PositioningMode { RELATIVE, STATIC, ABSOLUTE };
 
-    Horizontal horizontal = Horizontal::CENTER;
-    Vertical vertical = Vertical::MIDDLE;
-    PositioningMode mode = PositioningMode::RELATIVE;
+	Horizontal horizontal = Horizontal::CENTER;
+	Vertical vertical = Vertical::MIDDLE;
+	PositioningMode mode = PositioningMode::RELATIVE;
 
-    int staticX = 0;
-    int staticY = 0;
+	int staticX = 0;
+	int staticY = 0;
 
-    int marginTop = 0;
-    int marginBottom = 0;
-    int marginLeft = 0;
-    int marginRight = 0;
+	int marginTop = 0;
+	int marginBottom = 0;
+	int marginLeft = 0;
+	int marginRight = 0;
 };
-struct RGBColor{
+struct RGBColor {
 	int red;
 	int green;
 	int blue;
 };
-class UIObject : public GameObject{
-	public:
-	UIObject(int width,int height);
+class UIObject : public GameObject {
+public:
+	UIObject(int width, int height);
 	virtual ~UIObject() {}
 	int width;
 	int height;
 	int x;
 	int y;
 };
-class Button : public UIObject{
-	public:
-	Button(int width,int height);
+class Button : public UIObject {
+public:
+	Button(int width, int height);
 	RGBColor color;
 	std::function<void()> onClick;
-
 };
-class Text : public UIObject{
-	public:
-	Text(int width,int height);
+class Text : public UIObject {
+public:
+	Text(int width, int height);
 	std::string text;
 	int size;
 	Alignment alignment;
 	//font resource
-	TTF_Font *font;
+	TTF_Font * font;
 	RGBColor color;
 };
 class TextInput : public UIObject {
 public:
-    TextInput(int width, int height);
-    std::string textBuffer;          
-    std::string placeholder;
-    bool isActive = false;
-    RGBColor textColor;
-    RGBColor backgroundColor;
-    size_t maxLength = 100;
-    Alignment alignment;
-    TTF_Font* font = nullptr;
-    std::function<void()> onSubmit; 
-	std::function<void()> onFocus; 
+	TextInput(int width, int height);
+	std::string textBuffer;
+	std::string placeholder;
+	bool isActive = false;
+	RGBColor textColor;
+	RGBColor backgroundColor;
+	size_t maxLength = 100;
+	Alignment alignment;
+	TTF_Font * font = nullptr;
+	std::function<void()> onSubmit;
+	std::function<void()> onFocus;
 };
-
diff --git a/mwe/events/include/uiRenderer.h b/mwe/events/include/uiRenderer.h
index 32acecf..8f22fdf 100644
--- a/mwe/events/include/uiRenderer.h
+++ b/mwe/events/include/uiRenderer.h
@@ -1,21 +1,21 @@
 #pragma once
+#include "uiObject.h"
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_ttf.h>
 #include <string>
-#include "uiObject.h"
 
 class UIRenderer {
 public:
-    UIRenderer(SDL_Renderer* renderer);
-    ~UIRenderer();
+	UIRenderer(SDL_Renderer * renderer);
+	~UIRenderer();
 
-    void render(UIObject* uiObject);
+	void render(UIObject * uiObject);
 
 private:
-    SDL_Renderer* renderer;
-    TTF_Font* font;
+	SDL_Renderer * renderer;
+	TTF_Font * font;
 
-    void renderButton(Button* button);
-    void renderText(Text* text);
-    void renderTextInput(TextInput* textInput);
+	void renderButton(Button * button);
+	void renderText(Text * text);
+	void renderTextInput(TextInput * textInput);
 };
diff --git a/mwe/events/include/window.h b/mwe/events/include/window.h
index 3c34d4c..bd75c4a 100644
--- a/mwe/events/include/window.h
+++ b/mwe/events/include/window.h
@@ -1,27 +1,27 @@
 #pragma once
-#include <SDL2/SDL.h>
-#include <vector>
 #include "uiObject.h"
 #include "uiRenderer.h"
+#include <SDL2/SDL.h>
+#include <vector>
 
 class WindowManager {
 public:
-    WindowManager();
-    virtual ~WindowManager();
+	WindowManager();
+	virtual ~WindowManager();
 
-    bool initWindow();
-    void destroyWindow();
-    SDL_Renderer* getRenderer();
+	bool initWindow();
+	void destroyWindow();
+	SDL_Renderer * getRenderer();
 
-    void addUIObject(UIObject* uiObject);
-    void renderUIObjects();
+	void addUIObject(UIObject * uiObject);
+	void renderUIObjects();
 
 private:
-    const int SCREEN_WIDTH = 800;
-    const int SCREEN_HEIGHT = 600;
-    SDL_Window* window = nullptr;
-    SDL_Renderer* renderer = nullptr;
+	const int SCREEN_WIDTH = 800;
+	const int SCREEN_HEIGHT = 600;
+	SDL_Window * window = nullptr;
+	SDL_Renderer * renderer = nullptr;
 
-    UIRenderer* uiRenderer;
-    std::vector<UIObject*> uiObjects;
+	UIRenderer * uiRenderer;
+	std::vector<UIObject *> uiObjects;
 };
diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp
index eae4d14..0c9f3ed 100644
--- a/mwe/events/src/event.cpp
+++ b/mwe/events/src/event.cpp
@@ -51,27 +51,20 @@ Collision CollisionEvent::getCollisionData() const {
 	return this->collisionData;
 }
 
-TextSubmitEvent::TextSubmitEvent(std::string text) 
-    : text(text), Event("TextSubmitEvent") {
-		
-	}
+TextSubmitEvent::TextSubmitEvent(std::string text)
+	: text(text), Event("TextSubmitEvent") {}
 
-std::string TextSubmitEvent::getText() const {
-    return this->text;
-}
-
-MouseReleasedEvent::MouseReleasedEvent(int x, int y, MouseButton button) : mouseX(x), mouseY(y), button(button),Event("MouseReleased"){
-
-}
-std::pair<int, int> MouseReleasedEvent::getMousePosition() const{
-	return {mouseX,mouseY};
-}
-MouseClickEvent::MouseClickEvent(int x,int y,MouseButton button) : mouseX(x), mouseY(y), button(button),Event("MouseClickEvent"){
-
-}
-MouseMovedEvent::MouseMovedEvent(int x, int y) : mouseX(x), mouseY(y),Event("MouseMovedEvent"){
+std::string TextSubmitEvent::getText() const { return this->text; }
 
+MouseReleasedEvent::MouseReleasedEvent(int x, int y, MouseButton button)
+	: mouseX(x), mouseY(y), button(button), Event("MouseReleased") {}
+std::pair<int, int> MouseReleasedEvent::getMousePosition() const {
+	return {mouseX, mouseY};
 }
+MouseClickEvent::MouseClickEvent(int x, int y, MouseButton button)
+	: mouseX(x), mouseY(y), button(button), Event("MouseClickEvent") {}
+MouseMovedEvent::MouseMovedEvent(int x, int y)
+	: mouseX(x), mouseY(y), Event("MouseMovedEvent") {}
 std::pair<int, int> MouseClickEvent::getMousePosition() const {
 	return {mouseX, mouseY};
 }
diff --git a/mwe/events/src/iKeyListener.cpp b/mwe/events/src/iKeyListener.cpp
index 59cc89a..0235fab 100644
--- a/mwe/events/src/iKeyListener.cpp
+++ b/mwe/events/src/iKeyListener.cpp
@@ -1,18 +1,19 @@
 #include "iKeyListener.h"
 
-IKeyListener::~IKeyListener() {
-    unsubscribeEvents();
-}
+IKeyListener::~IKeyListener() { unsubscribeEvents(); }
 
 void IKeyListener::subscribeEvents(int listenerId) {
-    keyPressedHandler = [this](const KeyPressedEvent& event) { this->onKeyPressed(event); };
-    keyReleasedHandler = [this](const KeyReleasedEvent& event) { this->onKeyReleased(event); };
+	keyPressedHandler
+		= [this](const KeyPressedEvent & event) { this->onKeyPressed(event); };
+	keyReleasedHandler = [this](const KeyReleasedEvent & event) {
+		this->onKeyReleased(event);
+	};
 
-    subscribe<KeyPressedEvent>(keyPressedHandler, listenerId);
-    subscribe<KeyReleasedEvent>(keyReleasedHandler, listenerId);
+	subscribe<KeyPressedEvent>(keyPressedHandler, listenerId);
+	subscribe<KeyReleasedEvent>(keyReleasedHandler, listenerId);
 }
 
 void IKeyListener::unsubscribeEvents(int listenerId) {
-    unsubscribe<KeyPressedEvent>(keyPressedHandler, listenerId);
-    unsubscribe<KeyReleasedEvent>(keyReleasedHandler, listenerId);
+	unsubscribe<KeyPressedEvent>(keyPressedHandler, listenerId);
+	unsubscribe<KeyReleasedEvent>(keyReleasedHandler, listenerId);
 }
diff --git a/mwe/events/src/iMouseListener.cpp b/mwe/events/src/iMouseListener.cpp
index 3239304..69d8c9f 100644
--- a/mwe/events/src/iMouseListener.cpp
+++ b/mwe/events/src/iMouseListener.cpp
@@ -1,23 +1,28 @@
 #include "iMouseListener.h"
-IMouseListener::~IMouseListener() {
-    unsubscribeEvents();
-}
+IMouseListener::~IMouseListener() { unsubscribeEvents(); }
 
 void IMouseListener::subscribeEvents(int listenerId) {
-    mouseClickHandler = [this](const MouseClickEvent& event) { this->onMouseClicked(event); };
-    mousePressHandler = [this](const MousePressedEvent& event) { this->onMousePressed(event); };
-    mouseReleaseHandler = [this](const MouseReleasedEvent& event) { this->onMouseReleased(event); };
-    mouseMoveHandler = [this](const MouseMovedEvent& event) { this->onMouseMoved(event); };
+	mouseClickHandler = [this](const MouseClickEvent & event) {
+		this->onMouseClicked(event);
+	};
+	mousePressHandler = [this](const MousePressedEvent & event) {
+		this->onMousePressed(event);
+	};
+	mouseReleaseHandler = [this](const MouseReleasedEvent & event) {
+		this->onMouseReleased(event);
+	};
+	mouseMoveHandler
+		= [this](const MouseMovedEvent & event) { this->onMouseMoved(event); };
 
-    subscribe<MouseClickEvent>(mouseClickHandler, listenerId);
-    subscribe<MousePressedEvent>(mousePressHandler, listenerId);
-    subscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
-    subscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
+	subscribe<MouseClickEvent>(mouseClickHandler, listenerId);
+	subscribe<MousePressedEvent>(mousePressHandler, listenerId);
+	subscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
+	subscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
 }
 
 void IMouseListener::unsubscribeEvents(int listenerId) {
-    unsubscribe<MouseClickEvent>(mouseClickHandler, listenerId);
-    unsubscribe<MousePressedEvent>(mousePressHandler, listenerId);
-    unsubscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
-    unsubscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
+	unsubscribe<MouseClickEvent>(mouseClickHandler, listenerId);
+	unsubscribe<MousePressedEvent>(mousePressHandler, listenerId);
+	unsubscribe<MouseReleasedEvent>(mouseReleaseHandler, listenerId);
+	unsubscribe<MouseMovedEvent>(mouseMoveHandler, listenerId);
 }
diff --git a/mwe/events/src/inputSystem.cpp b/mwe/events/src/inputSystem.cpp
index bb26e8b..b87b12e 100644
--- a/mwe/events/src/inputSystem.cpp
+++ b/mwe/events/src/inputSystem.cpp
@@ -2,98 +2,94 @@
 
 InputSystem::InputSystem() {}
 
-void InputSystem::registerButton(Button* button) {
-    buttons.push_back(button);
-}
-void InputSystem::registerTextInput(TextInput* input) {
-    textInputs.push_back(input);
-}
-void InputSystem::registerText(Text* label) {
-    texts.push_back(label);
+void InputSystem::registerButton(Button * button) { buttons.push_back(button); }
+void InputSystem::registerTextInput(TextInput * input) {
+	textInputs.push_back(input);
 }
+void InputSystem::registerText(Text * label) { texts.push_back(label); }
 
 void InputSystem::processInput() {
-    SDL_Event event;
-    while (SDL_PollEvent(&event)) {
-        switch (event.type) {
-            case SDL_QUIT:
-                triggerEvent(ShutDownEvent());
-                break;
-            case SDL_KEYDOWN:
-                triggerEvent(KeyPressedEvent(getCustomKey(event.key.keysym.sym)));
-                processKeyPress(event.key.keysym.sym);
-                break;
-            case SDL_TEXTINPUT:
-                // Process typed characters
-                processTextInput(event.text.text);
-                break;
-            case SDL_MOUSEBUTTONDOWN: {
-                int mouseX, mouseY;
-                SDL_GetMouseState(&mouseX, &mouseY);
-                processMouseClick(mouseX, mouseY);
-                triggerEvent(MousePressedEvent(mouseX, mouseY));
-                break;
-            }
-        }
-    }
+	SDL_Event event;
+	while (SDL_PollEvent(&event)) {
+		switch (event.type) {
+			case SDL_QUIT:
+				triggerEvent(ShutDownEvent());
+				break;
+			case SDL_KEYDOWN:
+				triggerEvent(
+					KeyPressedEvent(getCustomKey(event.key.keysym.sym)));
+				processKeyPress(event.key.keysym.sym);
+				break;
+			case SDL_TEXTINPUT:
+				// Process typed characters
+				processTextInput(event.text.text);
+				break;
+			case SDL_MOUSEBUTTONDOWN: {
+				int mouseX, mouseY;
+				SDL_GetMouseState(&mouseX, &mouseY);
+				processMouseClick(mouseX, mouseY);
+				triggerEvent(MousePressedEvent(mouseX, mouseY));
+				break;
+			}
+		}
+	}
 }
 
-
 void InputSystem::processMouseClick(int mouseX, int mouseY) {
-    for (auto* button : buttons) {
-        if (mouseX >= button->x && mouseX <= (button->x + button->width) &&
-            mouseY >= button->y && mouseY <= (button->y + button->height)) {
-            button->onClick();
-        }
-    }
-	for(auto* textInput : textInputs){
-		if (mouseX >= textInput->x && mouseX <= textInput->x + textInput->width &&
-        mouseY >= textInput->y && mouseY <= textInput->y + textInput->height) {
-        textInput->isActive = true;
-    } else {
-        textInput->isActive = false;
-    }
+	for (auto * button : buttons) {
+		if (mouseX >= button->x && mouseX <= (button->x + button->width)
+			&& mouseY >= button->y && mouseY <= (button->y + button->height)) {
+			button->onClick();
+		}
+	}
+	for (auto * textInput : textInputs) {
+		if (mouseX >= textInput->x && mouseX <= textInput->x + textInput->width
+			&& mouseY >= textInput->y
+			&& mouseY <= textInput->y + textInput->height) {
+			textInput->isActive = true;
+		} else {
+			textInput->isActive = false;
+		}
 	}
 }
 void InputSystem::processKeyPress(Keycode key) {
-    // for (auto* textInput : textInputs) {
-    //     if (textInput->isActive) {
-    //         if (key == SDLK_RETURN || key == SDLK_KP_ENTER) {
-    //             // Submit the text
-    //             if (textInput->onSubmit) {
-    //                 textInput->onSubmit();
-    //             }
-    //         } 
-    //         else if (key == SDLK_BACKSPACE) {
-    //             // Handle backspace
-    //             if (!textInput->textBuffer.empty() && textInput->caretPosition > 0) {
-    //                 textInput->textBuffer.erase(textInput->caretPosition - 1, 1);
-    //                 textInput->caretPosition--;
-    //             }
-    //         } 
-    //         else if (key == SDLK_LEFT) {
-    //             // Move caret left
-    //             if (textInput->caretPosition > 0) {
-    //                 textInput->caretPosition--;
-    //             }
-    //         } 
-    //         else if (key == SDLK_RIGHT) {
-    //             // Move caret right
-    //             if (textInput->caretPosition < textInput->textBuffer.size()) {
-    //                 textInput->caretPosition++;
-    //             }
-    //         }
-    //     }
-    // }
+	// for (auto* textInput : textInputs) {
+	//     if (textInput->isActive) {
+	//         if (key == SDLK_RETURN || key == SDLK_KP_ENTER) {
+	//             // Submit the text
+	//             if (textInput->onSubmit) {
+	//                 textInput->onSubmit();
+	//             }
+	//         }
+	//         else if (key == SDLK_BACKSPACE) {
+	//             // Handle backspace
+	//             if (!textInput->textBuffer.empty() && textInput->caretPosition > 0) {
+	//                 textInput->textBuffer.erase(textInput->caretPosition - 1, 1);
+	//                 textInput->caretPosition--;
+	//             }
+	//         }
+	//         else if (key == SDLK_LEFT) {
+	//             // Move caret left
+	//             if (textInput->caretPosition > 0) {
+	//                 textInput->caretPosition--;
+	//             }
+	//         }
+	//         else if (key == SDLK_RIGHT) {
+	//             // Move caret right
+	//             if (textInput->caretPosition < textInput->textBuffer.size()) {
+	//                 textInput->caretPosition++;
+	//             }
+	//         }
+	//     }
+	// }
 }
 
-void InputSystem::processTextInput(const std::string& text) {
-    // for (auto* textInput : textInputs) {
-    //     if (textInput->isActive) {
-    //         // Insert text at caret position
-    //         textInput->textBuffer.insert(textInput->caretPosition, text);
-    //         textInput->caretPosition += text.length();
-    //     }
-    // }
+void InputSystem::processTextInput(const std::string & text) {
+	// for (auto* textInput : textInputs) {
+	//     if (textInput->isActive) {
+	//         // Insert text at caret position
+	//         textInput->textBuffer.insert(textInput->caretPosition, text);
+	//         textInput->caretPosition += text.length();
+	//     }
+	// }
 }
-
diff --git a/mwe/events/src/keyListenerTest.cpp b/mwe/events/src/keyListenerTest.cpp
index 90b92a5..8446dfa 100644
--- a/mwe/events/src/keyListenerTest.cpp
+++ b/mwe/events/src/keyListenerTest.cpp
@@ -1,17 +1,15 @@
 #include "keyListenerTest.h"
 
 KeyListenerTest::KeyListenerTest(int listenerId) {
-    subscribeEvents(listenerId);
+	subscribeEvents(listenerId);
 }
 
-KeyListenerTest::~KeyListenerTest() {
-    unsubscribeEvents();
-}
+KeyListenerTest::~KeyListenerTest() { unsubscribeEvents(); }
 
-void KeyListenerTest::onKeyPressed(const KeyPressedEvent& event) {
-    std::cout << "Key pressed: " << event.getKeyCode() << std::endl;
+void KeyListenerTest::onKeyPressed(const KeyPressedEvent & event) {
+	std::cout << "Key pressed: " << event.getKeyCode() << std::endl;
 }
 
-void KeyListenerTest::onKeyReleased(const KeyReleasedEvent& event) {
-    std::cout << "Key released: " << event.getKeyCode() << std::endl;
+void KeyListenerTest::onKeyReleased(const KeyReleasedEvent & event) {
+	std::cout << "Key released: " << event.getKeyCode() << std::endl;
 }
diff --git a/mwe/events/src/loopManager.cpp b/mwe/events/src/loopManager.cpp
index f673d44..0b7d888 100644
--- a/mwe/events/src/loopManager.cpp
+++ b/mwe/events/src/loopManager.cpp
@@ -1,8 +1,8 @@
 #include "loopManager.h"
 
-LoopManager::LoopManager() 
-    : inputSystem(std::make_unique<InputSystem>()){
-	shutdownHandler = [this](const ShutDownEvent& event) { this->onShutdown(event); };
+LoopManager::LoopManager() : inputSystem(std::make_unique<InputSystem>()) {
+	shutdownHandler
+		= [this](const ShutDownEvent & event) { this->onShutdown(event); };
 	subscribe(shutdownHandler);
 }
 void LoopManager::processInput() {
@@ -70,22 +70,20 @@ void LoopManager::setup() {
 			  }
 		  };
 	subscribe<KeyPressedEvent>(closeWindowCallback, false);
-	Button* testButton = new Button(200,200);
-	testButton->color = {100,0,100};
-	testButton->onClick = []() {
-    	std::cout << "Button was clicked" << std::endl;
-	};
+	Button * testButton = new Button(200, 200);
+	testButton->color = {100, 0, 100};
+	testButton->onClick
+		= []() { std::cout << "Button was clicked" << std::endl; };
 	testButton->x = 200;
 	testButton->y = 200;
 	inputSystem->registerButton(testButton);
 
 	window.addUIObject(testButton);
 
-
-	TextInput* testInput = new TextInput(200,200);
+	TextInput * testInput = new TextInput(200, 200);
 	testInput->x = 100;
 	testInput->y = 100;
-	testInput->backgroundColor = {20,50,80};
+	testInput->backgroundColor = {20, 50, 80};
 	inputSystem->registerTextInput(testInput);
 	window.addUIObject(testInput);
 }
@@ -95,7 +93,7 @@ void LoopManager::render() {
 		window.renderUIObjects();
 	}
 }
-void LoopManager::onShutdown(const ShutDownEvent& e){
+void LoopManager::onShutdown(const ShutDownEvent & e) {
 	this->gameRunning = false;
 }
 void LoopManager::update() {
diff --git a/mwe/events/src/main.cpp b/mwe/events/src/main.cpp
index 972fc70..d49cf74 100644
--- a/mwe/events/src/main.cpp
+++ b/mwe/events/src/main.cpp
@@ -1,16 +1,13 @@
 #include "customTypes.h"
 #include "event.h"
-#include "loopManager.h"
-#include <SDL2/SDL.h>
-#include <iostream>
-#include <memory>
-#include "loopManager.h"
-#include "event.h"
-#include "customTypes.h"
 #include "iKeyListener.h"
 #include "iMouseListener.h"
 #include "keyListenerTest.h"
+#include "loopManager.h"
 #include "mouseListenerTest.h"
+#include <SDL2/SDL.h>
+#include <iostream>
+#include <memory>
 class PlayerDamagedEvent : public Event {
 public:
 	PlayerDamagedEvent(int damage, int playerID)
@@ -53,7 +50,7 @@ int main(int argc, char * args[]) {
 	LoopManager gameLoop;
 	int testListenerId = 0;
 	KeyListenerTest keyListener(testListenerId);
-    MouseListenerTest mouseListener(testListenerId);
+	MouseListenerTest mouseListener(testListenerId);
 	// custom event class poc
 	subscribe<PlayerDamagedEvent>(onPlayerDamaged);
 	triggerEvent(PlayerDamagedEvent(50, 1));
diff --git a/mwe/events/src/mouseListenerTest.cpp b/mwe/events/src/mouseListenerTest.cpp
index 4b3aa3e..a2a7e6d 100644
--- a/mwe/events/src/mouseListenerTest.cpp
+++ b/mwe/events/src/mouseListenerTest.cpp
@@ -1,25 +1,27 @@
 #include "mouseListenerTest.h"
 
 MouseListenerTest::MouseListenerTest(int listenerId) {
-    subscribeEvents(listenerId);
+	subscribeEvents(listenerId);
 }
 
-MouseListenerTest::~MouseListenerTest() {
-    unsubscribeEvents();
-}
+MouseListenerTest::~MouseListenerTest() { unsubscribeEvents(); }
 
-void MouseListenerTest::onMouseClicked(const MouseClickEvent& event) {
-    std::cout << "Mouse clicked at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+void MouseListenerTest::onMouseClicked(const MouseClickEvent & event) {
+	std::cout << "Mouse clicked at: (" << event.getMousePosition().first << ", "
+			  << event.getMousePosition().second << ")" << std::endl;
 }
 
-void MouseListenerTest::onMousePressed(const MousePressedEvent& event) {
-    std::cout << "Mouse button pressed at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+void MouseListenerTest::onMousePressed(const MousePressedEvent & event) {
+	std::cout << "Mouse button pressed at: (" << event.getMousePosition().first
+			  << ", " << event.getMousePosition().second << ")" << std::endl;
 }
 
-void MouseListenerTest::onMouseReleased(const MouseReleasedEvent& event) {
-    std::cout << "Mouse button released at: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+void MouseListenerTest::onMouseReleased(const MouseReleasedEvent & event) {
+	std::cout << "Mouse button released at: (" << event.getMousePosition().first
+			  << ", " << event.getMousePosition().second << ")" << std::endl;
 }
 
-void MouseListenerTest::onMouseMoved(const MouseMovedEvent& event) {
-    std::cout << "Mouse moved to: (" << event.getMousePosition().first << ", " << event.getMousePosition().second << ")" << std::endl;
+void MouseListenerTest::onMouseMoved(const MouseMovedEvent & event) {
+	std::cout << "Mouse moved to: (" << event.getMousePosition().first << ", "
+			  << event.getMousePosition().second << ")" << std::endl;
 }
diff --git a/mwe/events/src/uiObject.cpp b/mwe/events/src/uiObject.cpp
index 31ff486..8405469 100644
--- a/mwe/events/src/uiObject.cpp
+++ b/mwe/events/src/uiObject.cpp
@@ -1,28 +1,24 @@
 #include "uiObject.h"
 
 // Constructor for UIObject
-UIObject::UIObject(int width, int height)
-    : width(width), height(height){
-
-	}
+UIObject::UIObject(int width, int height) : width(width), height(height) {}
 
 // Constructor for Button
-Button::Button(int width, int height)
-    : UIObject(width, height) {
-}
+Button::Button(int width, int height) : UIObject(width, height) {}
 
 Text::Text(int width, int height)
-    : UIObject(width, height), size(12), font(nullptr), color{255, 255, 255} { // Default size and color
-    alignment.horizontal = Alignment::Horizontal::CENTER;
-    alignment.vertical = Alignment::Vertical::MIDDLE;
-    alignment.mode = Alignment::PositioningMode::RELATIVE;
+	: UIObject(width, height), size(12), font(nullptr),
+	  color{255, 255, 255} { // Default size and color
+	alignment.horizontal = Alignment::Horizontal::CENTER;
+	alignment.vertical = Alignment::Vertical::MIDDLE;
+	alignment.mode = Alignment::PositioningMode::RELATIVE;
 }
 
 TextInput::TextInput(int width, int height)
-    : UIObject(width, height), textBuffer(""), placeholder(""), 
-      isActive(false), textColor{255, 255, 255}, backgroundColor{0, 0, 0}, maxLength(100), font(nullptr) {
-    alignment.horizontal = Alignment::Horizontal::LEFT;
-    alignment.vertical = Alignment::Vertical::TOP;
-    alignment.mode = Alignment::PositioningMode::RELATIVE;
+	: UIObject(width, height), textBuffer(""), placeholder(""), isActive(false),
+	  textColor{255, 255, 255}, backgroundColor{0, 0, 0}, maxLength(100),
+	  font(nullptr) {
+	alignment.horizontal = Alignment::Horizontal::LEFT;
+	alignment.vertical = Alignment::Vertical::TOP;
+	alignment.mode = Alignment::PositioningMode::RELATIVE;
 }
-
diff --git a/mwe/events/src/uiRenderer.cpp b/mwe/events/src/uiRenderer.cpp
index dbe8dfe..9fec272 100644
--- a/mwe/events/src/uiRenderer.cpp
+++ b/mwe/events/src/uiRenderer.cpp
@@ -1,103 +1,107 @@
 #include "uiRenderer.h"
 
 // Constructor
-UIRenderer::UIRenderer(SDL_Renderer* renderer) : renderer(renderer) {}
+UIRenderer::UIRenderer(SDL_Renderer * renderer) : renderer(renderer) {}
 
 // Render function
-void UIRenderer::render(UIObject* uiObject) {
-    if (Button* button = dynamic_cast<Button*>(uiObject)) {
-        renderButton(button);
-    } else if (Text* text = dynamic_cast<Text*>(uiObject)) {
-        renderText(text);
-    } else if (TextInput* textInput = dynamic_cast<TextInput*>(uiObject)) {
-        renderTextInput(textInput);
-    }
+void UIRenderer::render(UIObject * uiObject) {
+	if (Button * button = dynamic_cast<Button *>(uiObject)) {
+		renderButton(button);
+	} else if (Text * text = dynamic_cast<Text *>(uiObject)) {
+		renderText(text);
+	} else if (TextInput * textInput = dynamic_cast<TextInput *>(uiObject)) {
+		renderTextInput(textInput);
+	}
 }
 
 // Private helper function to render a Button
-void UIRenderer::renderButton(Button* button) {
-    SDL_Rect buttonRect = {button->x, button->y, button->width, button->height};
-    SDL_SetRenderDrawColor(renderer, 100, 100, 255, 255); // Button color
-    SDL_RenderFillRect(renderer, &buttonRect);
+void UIRenderer::renderButton(Button * button) {
+	SDL_Rect buttonRect = {button->x, button->y, button->width, button->height};
+	SDL_SetRenderDrawColor(renderer, 100, 100, 255, 255); // Button color
+	SDL_RenderFillRect(renderer, &buttonRect);
 }
 
 // Private helper function to render a Text
-void UIRenderer::renderText(Text* text) {
-    if (text->font != nullptr) {
-        SDL_Color sdlColor = {text->color.red, text->color.green, text->color.blue, 255};
-        SDL_Surface* textSurface = TTF_RenderText_Blended(text->font, text->text.c_str(), sdlColor);
-        if (!textSurface) {
-            std::cerr << "Error creating text surface: " << TTF_GetError() << std::endl;
-            return;
-        }
+void UIRenderer::renderText(Text * text) {
+	if (text->font != nullptr) {
+		SDL_Color sdlColor
+			= {text->color.red, text->color.green, text->color.blue, 255};
+		SDL_Surface * textSurface
+			= TTF_RenderText_Blended(text->font, text->text.c_str(), sdlColor);
+		if (!textSurface) {
+			std::cerr << "Error creating text surface: " << TTF_GetError()
+					  << std::endl;
+			return;
+		}
 
-        SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
-        if (!textTexture) {
-            std::cerr << "Error creating texture from surface: " << SDL_GetError() << std::endl;
-            SDL_FreeSurface(textSurface);
-            return;
-        }
+		SDL_Texture * textTexture
+			= SDL_CreateTextureFromSurface(renderer, textSurface);
+		if (!textTexture) {
+			std::cerr << "Error creating texture from surface: "
+					  << SDL_GetError() << std::endl;
+			SDL_FreeSurface(textSurface);
+			return;
+		}
 
-        SDL_Rect textRect = {text->x, text->y, textSurface->w, textSurface->h};
-        SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
-        SDL_FreeSurface(textSurface);
-        SDL_DestroyTexture(textTexture);
-    }
+		SDL_Rect textRect = {text->x, text->y, textSurface->w, textSurface->h};
+		SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
+		SDL_FreeSurface(textSurface);
+		SDL_DestroyTexture(textTexture);
+	}
 }
 
-void UIRenderer::renderTextInput(TextInput* textInput) {
-    // // Check if textInput or renderer is null to avoid segmentation faults
-    // if (!textInput || !renderer) {
-    //     std::cerr << "Error: Null pointer detected for textInput or renderer." << std::endl;
-    //     return;
-    // }
+void UIRenderer::renderTextInput(TextInput * textInput) {
+	// // Check if textInput or renderer is null to avoid segmentation faults
+	// if (!textInput || !renderer) {
+	//     std::cerr << "Error: Null pointer detected for textInput or renderer." << std::endl;
+	//     return;
+	// }
 
-    // // Render the background rectangle for the text input
-    // SDL_Rect inputRect = {textInput->x, textInput->y, textInput->width, textInput->height};
-    // SDL_SetRenderDrawColor(renderer, textInput->backgroundColor.red, textInput->backgroundColor.green, textInput->backgroundColor.blue, 255);
-    // SDL_RenderFillRect(renderer, &inputRect);
+	// // Render the background rectangle for the text input
+	// SDL_Rect inputRect = {textInput->x, textInput->y, textInput->width, textInput->height};
+	// SDL_SetRenderDrawColor(renderer, textInput->backgroundColor.red, textInput->backgroundColor.green, textInput->backgroundColor.blue, 255);
+	// SDL_RenderFillRect(renderer, &inputRect);
 
-    // // Check if font is valid
-    // if (!textInput->font) {
-    //     std::cerr << "Error: Font is not loaded for textInput." << std::endl;
-    //     return;
-    // }
+	// // Check if font is valid
+	// if (!textInput->font) {
+	//     std::cerr << "Error: Font is not loaded for textInput." << std::endl;
+	//     return;
+	// }
 
-    // SDL_Color sdlColor = {textInput->textColor.red, textInput->textColor.green, textInput->textColor.blue, 255};
+	// SDL_Color sdlColor = {textInput->textColor.red, textInput->textColor.green, textInput->textColor.blue, 255};
 
-    // if (!textInput->textBuffer.empty()) {
-    //     // Render the text in the input field
-    //     SDL_Surface* textSurface = TTF_RenderText_Blended(textInput->font, textInput->textBuffer.c_str(), sdlColor);
-    //     if (textSurface) {
-    //         SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
-    //         if (textTexture) {
-    //             SDL_Rect textRect = {textInput->x + 5, textInput->y + 5, textSurface->w, textSurface->h};
-    //             SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
-    //             SDL_DestroyTexture(textTexture);
-    //         } else {
-    //             std::cerr << "Error: Unable to create texture from text surface." << std::endl;
-    //         }
-    //         SDL_FreeSurface(textSurface);
-    //     } else {
-    //         std::cerr << "Error: Unable to create text surface." << std::endl;
-    //     }
-    // } else if (!textInput->placeholder.empty()) {
-    //     // Render the placeholder text
-    //     SDL_Color placeholderColor = {128, 128, 128, 255}; // Light gray for placeholder
-    //     SDL_Surface* placeholderSurface = TTF_RenderText_Blended(textInput->font, textInput->placeholder.c_str(), placeholderColor);
-    //     if (placeholderSurface) {
-    //         SDL_Texture* placeholderTexture = SDL_CreateTextureFromSurface(renderer, placeholderSurface);
-    //         if (placeholderTexture) {
-    //             SDL_Rect placeholderRect = {textInput->x + 5, textInput->y + 5, placeholderSurface->w, placeholderSurface->h};
-    //             SDL_RenderCopy(renderer, placeholderTexture, nullptr, &placeholderRect);
-    //             SDL_DestroyTexture(placeholderTexture);
-    //         } else {
-    //             std::cerr << "Error: Unable to create texture from placeholder surface." << std::endl;
-    //         }
-    //         SDL_FreeSurface(placeholderSurface);
-    //     } else {
-    //         std::cerr << "Error: Unable to create placeholder surface." << std::endl;
-    //     }
-    // }
+	// if (!textInput->textBuffer.empty()) {
+	//     // Render the text in the input field
+	//     SDL_Surface* textSurface = TTF_RenderText_Blended(textInput->font, textInput->textBuffer.c_str(), sdlColor);
+	//     if (textSurface) {
+	//         SDL_Texture* textTexture = SDL_CreateTextureFromSurface(renderer, textSurface);
+	//         if (textTexture) {
+	//             SDL_Rect textRect = {textInput->x + 5, textInput->y + 5, textSurface->w, textSurface->h};
+	//             SDL_RenderCopy(renderer, textTexture, nullptr, &textRect);
+	//             SDL_DestroyTexture(textTexture);
+	//         } else {
+	//             std::cerr << "Error: Unable to create texture from text surface." << std::endl;
+	//         }
+	//         SDL_FreeSurface(textSurface);
+	//     } else {
+	//         std::cerr << "Error: Unable to create text surface." << std::endl;
+	//     }
+	// } else if (!textInput->placeholder.empty()) {
+	//     // Render the placeholder text
+	//     SDL_Color placeholderColor = {128, 128, 128, 255}; // Light gray for placeholder
+	//     SDL_Surface* placeholderSurface = TTF_RenderText_Blended(textInput->font, textInput->placeholder.c_str(), placeholderColor);
+	//     if (placeholderSurface) {
+	//         SDL_Texture* placeholderTexture = SDL_CreateTextureFromSurface(renderer, placeholderSurface);
+	//         if (placeholderTexture) {
+	//             SDL_Rect placeholderRect = {textInput->x + 5, textInput->y + 5, placeholderSurface->w, placeholderSurface->h};
+	//             SDL_RenderCopy(renderer, placeholderTexture, nullptr, &placeholderRect);
+	//             SDL_DestroyTexture(placeholderTexture);
+	//         } else {
+	//             std::cerr << "Error: Unable to create texture from placeholder surface." << std::endl;
+	//         }
+	//         SDL_FreeSurface(placeholderSurface);
+	//     } else {
+	//         std::cerr << "Error: Unable to create placeholder surface." << std::endl;
+	//     }
+	// }
 }
-
diff --git a/mwe/events/src/window.cpp b/mwe/events/src/window.cpp
index 7192e6b..f482b7f 100644
--- a/mwe/events/src/window.cpp
+++ b/mwe/events/src/window.cpp
@@ -1,56 +1,48 @@
 #include "window.h"
 #include <iostream>
 
+WindowManager::WindowManager() { this->uiRenderer = nullptr; }
 
-WindowManager::WindowManager() {
-	this->uiRenderer = nullptr;
-}
-
-
-WindowManager::~WindowManager() {
-    destroyWindow();
-}
+WindowManager::~WindowManager() { destroyWindow(); }
 
 bool WindowManager::initWindow() {
-    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
-        std::cerr << "Error initializing SDL.\n";
-        return false;
-    }
-
-    window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED,
-                              SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
-                              SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
-    if (!window) {
-        std::cerr << "Error creating SDL Window.\n";
-        return false;
-    }
-
-    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
-    if (!renderer) {
-        std::cerr << "Error creating SDL renderer.\n";
-        return false;
-    }
-
-    uiRenderer = new UIRenderer(renderer);
-    return true;
+	if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
+		std::cerr << "Error initializing SDL.\n";
+		return false;
+	}
+
+	window = SDL_CreateWindow("SDL Tutorial", SDL_WINDOWPOS_UNDEFINED,
+							  SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH,
+							  SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
+	if (!window) {
+		std::cerr << "Error creating SDL Window.\n";
+		return false;
+	}
+
+	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
+	if (!renderer) {
+		std::cerr << "Error creating SDL renderer.\n";
+		return false;
+	}
+
+	uiRenderer = new UIRenderer(renderer);
+	return true;
 }
 
 void WindowManager::destroyWindow() {
-    SDL_DestroyRenderer(renderer);
-    SDL_DestroyWindow(window);
-    SDL_Quit();
+	SDL_DestroyRenderer(renderer);
+	SDL_DestroyWindow(window);
+	SDL_Quit();
 }
 
-SDL_Renderer* WindowManager::getRenderer() {
-    return renderer;
-}
-void WindowManager::addUIObject(UIObject* uiObject) {
-    uiObjects.push_back(uiObject);
+SDL_Renderer * WindowManager::getRenderer() { return renderer; }
+void WindowManager::addUIObject(UIObject * uiObject) {
+	uiObjects.push_back(uiObject);
 }
 
 void WindowManager::renderUIObjects() {
-    for (UIObject* obj : uiObjects) {
-        uiRenderer->render(obj);
-    }
+	for (UIObject * obj : uiObjects) {
+		uiRenderer->render(obj);
+	}
 	SDL_RenderPresent(this->renderer);
 }
diff --git a/mwe/gameloop/include/loopManager.h b/mwe/gameloop/include/loopManager.h
index e2c2e2c..7d37253 100644
--- a/mwe/gameloop/include/loopManager.h
+++ b/mwe/gameloop/include/loopManager.h
@@ -17,7 +17,7 @@ private:
 	void fixedUpdate();
 	void render();
 	bool gameRunning = false;
-	WindowManager* window;
+	WindowManager * window;
 	int timeScale = 1;
 	float accumulator = 0.0;
 	double currentTime;
diff --git a/mwe/gameloop/src/loopManager.cpp b/mwe/gameloop/src/loopManager.cpp
index b075bd8..49d65fb 100644
--- a/mwe/gameloop/src/loopManager.cpp
+++ b/mwe/gameloop/src/loopManager.cpp
@@ -1,11 +1,8 @@
 #include "loopManager.h"
 #include "timer.h"
-LoopManager::LoopManager() {
-	this->window = new WindowManager();
-	
-}
-LoopManager::~LoopManager(){
-	for(GameObject* object : this->objectList){
+LoopManager::LoopManager() { this->window = new WindowManager(); }
+LoopManager::~LoopManager() {
+	for (GameObject * object : this->objectList) {
 		delete object;
 	}
 	delete this->window;
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
index 3b218bc..c76bc72 100644
--- a/src/crepe/api/Transform.cpp
+++ b/src/crepe/api/Transform.cpp
@@ -8,7 +8,8 @@
 
 using namespace crepe::api;
 
-Transform::Transform(uint32_t game_id, const Point & point, double rot, double scale)
+Transform::Transform(uint32_t game_id, const Point & point, double rot,
+					 double scale)
 	: Component(game_id), position(point), rotation(rot), scale(scale) {
 	dbg_trace();
 }
diff --git a/src/example/audio_internal.cpp b/src/example/audio_internal.cpp
index f35ad9d..c7dd163 100644
--- a/src/example/audio_internal.cpp
+++ b/src/example/audio_internal.cpp
@@ -4,8 +4,8 @@
  */
 
 #include <crepe/Sound.h>
-#include <crepe/util/log.h>
 #include <crepe/api/Config.h>
+#include <crepe/util/log.h>
 
 #include <thread>
 
@@ -16,7 +16,7 @@ using namespace std::chrono_literals;
 using std::make_unique;
 
 // Unrelated stuff that is not part of this POC
-int _ = [] () {
+int _ = []() {
 	// Show dbg_trace() output
 	auto & cfg = api::Config::get_instance();
 	cfg.log.level = util::LogLevel::TRACE;
@@ -24,8 +24,6 @@ int _ = [] () {
 	return 0; // satisfy compiler
 }();
 
-
-
 int main() {
 	// Load a background track (Ogg Vorbis)
 	auto bgm = Sound("../mwe/audio/bgm.ogg");
diff --git a/src/example/log.cpp b/src/example/log.cpp
index 04ab9cd..75f133c 100644
--- a/src/example/log.cpp
+++ b/src/example/log.cpp
@@ -10,13 +10,13 @@ using namespace crepe;
 using namespace crepe::util;
 
 // unrelated setup code
-int _ = [] () {
+int _ = []() {
 	// make sure all log messages get printed
 	auto & cfg = api::Config::get_instance();
 	cfg.log.level = util::LogLevel::TRACE;
 
 	return 0; // satisfy compiler
-} ();
+}();
 
 int main() {
 	dbg_trace();
diff --git a/src/example/script.cpp b/src/example/script.cpp
index cda9591..5df26e8 100644
--- a/src/example/script.cpp
+++ b/src/example/script.cpp
@@ -18,7 +18,7 @@ using namespace crepe::api;
 using namespace std;
 
 // Unrelated stuff that is not part of this POC
-int _ = [] () {
+int _ = []() {
 	// Show dbg_trace() output
 	auto & cfg = api::Config::get_instance();
 	cfg.log.level = util::LogLevel::TRACE;
@@ -26,8 +26,6 @@ int _ = [] () {
 	return 0; // satisfy compiler
 }();
 
-
-
 // User-defined script:
 class MyScript : public Script {
 	void update() {
@@ -40,7 +38,12 @@ class MyScript : public Script {
 int main() {
 	// Create game object with Transform and BehaviorScript components
 	auto obj = GameObject(0, "name", "tag", 0);
-	obj.add_component<Transform>(Point { .x = 1.2, .y = 3.4, }, 0, 0);
+	obj.add_component<Transform>(
+		Point{
+			.x = 1.2,
+			.y = 3.4,
+		},
+		0, 0);
 	obj.add_component<BehaviorScript>().set_script<MyScript>();
 
 	// Get ScriptSystem singleton instance (this would normally be done from the
@@ -51,4 +54,3 @@ int main() {
 
 	return EXIT_SUCCESS;
 }
-
-- 
cgit v1.2.3