code standard fixing

9 files changed, 202 insertions, 102 deletions

diff --git a/src/crepe/api/Button.cpp b/src/crepe/api/Button.cpp
new file mode 100644
index 0000000..70f749d
--- /dev/null
+++ b/src/crepe/api/Button.cpp
@@ -0,0 +1,5 @@
+#include "Button.h"
+
+using namespace crepe;
+
+Button::Button(game_object_id_t id) : UiObject(id){}
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
index f533452..f769d58 100644
--- a/src/crepe/api/Button.h
+++ b/src/crepe/api/Button.h
@@ -1,19 +1,44 @@
 #pragma once
+
 #include <functional>
 
-#include "Component.h"
-#include "api/EventHandler.h"
-#include "api/UiObject.h"
+#include "UiObject.h"
+
 namespace crepe {
-class Button : public UiObject{
+
+/**
+ * \class Button
+ * \brief Represents a clickable UI button, derived from the UiObject class.
+ */
+class Button : public UiObject {
 public:
-	Button(game_object_id_t id) : UiObject(id){};
-	bool interactable = true;
-	bool is_toggle = false;
-	bool is_pressed = false;
-	bool hover = false;
-	std::function<void()> on_click;
+    /**
+     * \brief Constructs a Button with the specified game object ID.
+     * \param id The unique ID of the game object associated with this button.
+     */
+    Button(game_object_id_t id);
+
+    //! Indicates if the button is interactable (can be clicked).
+    bool interactable = true;
+
+    //! Indicates if the button is a toggle button (can be pressed and released).
+    bool is_toggle = false;
+
+    //! Indicates whether the button is currently pressed.
+    bool is_pressed = false;
+
+    //! Indicates whether the mouse is currently hovering over the button.
+    bool hover = false;
+
+    //! The callback function to be executed when the button is clicked.
+    std::function<void()> on_click;
+
 public:
-virtual int get_instances_max() const { return 1; }
+    /**
+     * \brief Retrieves the maximum number of instances allowed for this button type.
+     * \return Always returns 1, as only a single instance is allowed.
+     */
+    virtual int get_instances_max() const override { return 1; }
 };
-}
+
+} // namespace crepe
diff --git a/src/crepe/api/CMakeLists.txt b/src/crepe/api/CMakeLists.txt
index fc27fa0..aeb451d 100644
--- a/src/crepe/api/CMakeLists.txt
+++ b/src/crepe/api/CMakeLists.txt
@@ -23,6 +23,8 @@ target_sources(crepe PUBLIC
 	Asset.cpp
 	EventHandler.cpp
 	Script.cpp
+	Button.cpp
+	UiObject.cpp
 )
 
 target_sources(crepe PUBLIC FILE_SET HEADERS FILES
diff --git a/src/crepe/api/EventManager.hpp b/src/crepe/api/EventManager.hpp
index 3eae90a..a5f4556 100644
--- a/src/crepe/api/EventManager.hpp
+++ b/src/crepe/api/EventManager.hpp
@@ -1,5 +1,5 @@
 #pragma once
-#include <iostream>
+
 #include "EventManager.h"
 
 namespace crepe {
diff --git a/src/crepe/api/UiObject.cpp b/src/crepe/api/UiObject.cpp
new file mode 100644
index 0000000..1c11fc3
--- /dev/null
+++ b/src/crepe/api/UiObject.cpp
@@ -0,0 +1,5 @@
+#include "UiObject.h"
+
+using namespace crepe;
+
+UiObject::UiObject(game_object_id_t id) : Component(id){};
diff --git a/src/crepe/api/UiObject.h b/src/crepe/api/UiObject.h
index 82140a0..ae2e744 100644
--- a/src/crepe/api/UiObject.h
+++ b/src/crepe/api/UiObject.h
@@ -1,17 +1,33 @@
 #pragma once
 
-#include "Component.h"
+#include "../Component.h"
 
-#include "api/EventHandler.h"
 namespace crepe {
 
-class UiObject : public Component{
+/**
+ * @class UiObject
+ * \brief Represents a UI object in the game, derived from the Component class.
+ */
+class UiObject : public Component {
 public:
-	UiObject(game_object_id_t id) : Component(id){};
-	int width = 0;
-	int height = 0;
+    /**
+     * \brief Constructs a UiObject with the specified game object ID.
+     * \param id The unique ID of the game object associated with this UI object.
+     */
+    UiObject(game_object_id_t id);
+
+    //! The width of the UI object.
+    int width = 0;
+
+    //! The height of the UI object.
+    int height = 0;
+
 public:
-virtual int get_instances_max() const { return 1; }
+    /**
+     * \brief Retrieves the maximum number of instances allowed for this UI object type.
+     * /return Always returns 1, as only a single instance is allowed.
+     */
+    virtual int get_instances_max() const override { return 1; }
 };
 
-}
+} // namespace crepe
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 6371a51..a37392f 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -360,8 +360,8 @@ std::vector<SDLContext::EventData> SDLContext::get_events(){
                 {
 					event_list.push_back(EventData{
 						.event_type = SDLContext::Event::MOUSEMOVE,
-						.mouse_position = {event.button.x,event.button.y},
-						.rel_mouse_move =  {event.motion.yrel,event.motion.xrel}
+						.mouse_position = {event.motion.x,event.motion.y},
+						.rel_mouse_move =  {event.motion.xrel,event.motion.yrel}
 					});
 				}
                 break;
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index a3e28e4..1b455cd 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -1,25 +1,22 @@
-#include "ComponentManager.h"
 
+#include "ComponentManager.h"
 #include "../api/EventManager.h"
-
-#include "../facade/SDLContext.h"
 #include "../api/Event.h"
 
+
 #include "system/InputSystem.h"
 
 using namespace crepe;
 
-
-
 void InputSystem::update() {
-	EventManager& event_mgr = EventManager::get_instance();
+    EventManager &event_mgr = EventManager::get_instance();
     std::vector<SDLContext::EventData> event_list = SDLContext::get_instance().get_events();
-	
-    for (SDLContext::EventData event : event_list) {
+
+    for (const SDLContext::EventData &event : event_list) {
         switch (event.event_type) {
             case SDLContext::Event::KEYDOWN: {
                 event_mgr.queue_event<KeyPressEvent>(KeyPressEvent{
-					.repeat = event.key_repeat,
+                    .repeat = event.key_repeat,
                     .key = event.key,
                 });
                 break;
@@ -36,51 +33,49 @@ void InputSystem::update() {
                     .mouse_y = event.mouse_position.second,
                     .button = event.mouse_button,
                 });
-				last_mouse_down_position = {event.mouse_position.first,event.mouse_position.second};
-    			last_mouse_button = event.mouse_button;
+                last_mouse_down_position = event.mouse_position;
+                last_mouse_button = event.mouse_button;
+                break;
+            }
+            case SDLContext::Event::MOUSEUP: {
+                MouseReleaseEvent mouse_release_event = MouseReleaseEvent{
+                    .mouse_x = event.mouse_position.first,
+                    .mouse_y = event.mouse_position.second,
+                    .button = event.mouse_button,
+                };
+                event_mgr.queue_event<MouseReleaseEvent>(mouse_release_event);
+
+                // Calculate deltas for click detection
+                int delta_x = event.mouse_position.first - last_mouse_down_position.first;
+                int delta_y = event.mouse_position.second - last_mouse_down_position.second;
+
+                if (last_mouse_button == event.mouse_button &&
+                    std::abs(delta_x) <= click_tolerance &&
+                    std::abs(delta_y) <= click_tolerance) {
+                    event_mgr.queue_event<MouseClickEvent>(MouseClickEvent{
+                        .mouse_x = event.mouse_position.first,
+                        .mouse_y = event.mouse_position.second,
+                        .button = event.mouse_button,
+                    });
+
+                    handle_click(event);
+                }
                 break;
             }
-			case SDLContext::Event::MOUSEUP: {
-				MouseReleaseEvent mouse_release_event = MouseReleaseEvent{
-					.mouse_x = event.mouse_position.first,
-					.mouse_y = event.mouse_position.second,
-					.button = event.mouse_button,
-				};
-				event_mgr.queue_event<MouseReleaseEvent>(mouse_release_event);
-
-				// Calculate deltas for click detection
-				int delta_x = event.mouse_position.first - last_mouse_down_position.first;
-				int delta_y = event.mouse_position.second - last_mouse_down_position.second;
-
-				// Ensure last_mouse_button is properly set and matches the current mouse button
-				if (last_mouse_button == event.mouse_button &&
-					std::abs(delta_x) <= click_tolerance &&
-					std::abs(delta_y) <= click_tolerance) {
-					event_mgr.queue_event<MouseClickEvent>(MouseClickEvent{
-						.mouse_x = event.mouse_position.first,
-						.mouse_y = event.mouse_position.second,
-						.button = event.mouse_button,
-					});
-
-					this->handle_click(mouse_release_event);
-				}
-
-				break;
-			}
             case SDLContext::Event::MOUSEMOVE: {
                 event_mgr.queue_event<MouseMoveEvent>(MouseMoveEvent{
                     .mouse_x = event.mouse_position.first,
                     .mouse_y = event.mouse_position.second,
-                    .rel_x = event.rel_mouse_move.first,  
+                    .rel_x = event.rel_mouse_move.first,
                     .rel_y = event.rel_mouse_move.second,
                 });
+                handle_move(event);
                 break;
             }
-           
             case SDLContext::Event::MOUSEWHEEL: {
                 event_mgr.queue_event<MouseScrollEvent>(MouseScrollEvent{
-                    .scroll_x = event.mouse_position.first,
-                    .scroll_y = event.mouse_position.second,
+                    .scroll_x = event.wheel_delta,
+                    .scroll_y = 0,
                     .direction = event.wheel_delta,
                 });
                 break;
@@ -95,43 +90,43 @@ void InputSystem::update() {
     }
 }
 
-void InputSystem::handle_move(const MouseMoveEvent){
-	ComponentManager &mgr = this->component_manager;
+void InputSystem::handle_move(const SDLContext::EventData &event_data) {
+    ComponentManager &mgr = this->component_manager;
 
-    // Get the buttons and transforms
     std::vector<std::reference_wrapper<Button>> buttons = mgr.get_components_by_type<Button>();
     std::vector<std::reference_wrapper<Transform>> transforms = mgr.get_components_by_type<Transform>();
 
     for (Button &button : buttons) {
-        Transform* transform = find_transform_for_button(button, transforms);
-        if (!transform) continue; 
-        
-        if (button.interactable && is_mouse_inside_button(event, button, *transform)) {
-			button.hover = true;
-        }else{
-			button.hover = false;
-		}
+        Transform *transform = find_transform_for_button(button, transforms);
+        if (!transform)
+            continue;
+
+        if (button.interactable && is_mouse_inside_button(event_data, button, *transform)) {
+            button.hover = true;
+        } else {
+            button.hover = false;
+        }
     }
 }
 
-void InputSystem::handle_click(const MouseReleaseEvent event) {
+void InputSystem::handle_click(const SDLContext::EventData &event_data) {
     ComponentManager &mgr = this->component_manager;
 
-    // Get the buttons and transforms
     std::vector<std::reference_wrapper<Button>> buttons = mgr.get_components_by_type<Button>();
     std::vector<std::reference_wrapper<Transform>> transforms = mgr.get_components_by_type<Transform>();
 
     for (Button &button : buttons) {
-        Transform* transform = find_transform_for_button(button, transforms);
-        if (!transform) continue; 
-        
-        if (button.interactable && is_mouse_inside_button(event, button, *transform)) {
-            handle_button_press(button, event);
+        Transform *transform = find_transform_for_button(button, transforms);
+        if (!transform)
+            continue;
+
+        if (button.interactable && is_mouse_inside_button(event_data, button, *transform)) {
+            handle_button_press(button);
         }
     }
 }
 
-Transform* InputSystem::find_transform_for_button(Button &button, std::vector<std::reference_wrapper<Transform>> &transforms) {
+Transform *InputSystem::find_transform_for_button(Button &button, std::vector<std::reference_wrapper<Transform>> &transforms) {
     for (Transform &transform : transforms) {
         if (button.game_object_id == transform.game_object_id) {
             return &transform;
@@ -140,18 +135,20 @@ Transform* InputSystem::find_transform_for_button(Button &button, std::vector<st
     return nullptr;
 }
 
-bool InputSystem::is_mouse_inside_button(const MouseReleaseEvent &event, const Button &button, const Transform &transform) {
-    return event.mouse_x >= transform.position.x && event.mouse_x <= transform.position.x + button.width &&
-           event.mouse_y >= transform.position.y && event.mouse_y <= transform.position.y + button.height;
+bool InputSystem::is_mouse_inside_button(const SDLContext::EventData &event_data, const Button &button, const Transform &transform) {
+    return event_data.mouse_position.first >= transform.position.x &&
+           event_data.mouse_position.first <= transform.position.x + button.width &&
+           event_data.mouse_position.second >= transform.position.y &&
+           event_data.mouse_position.second <= transform.position.y + button.height;
 }
 
-void InputSystem::handle_button_press(Button &button, const MouseReleaseEvent &event) {
+void InputSystem::handle_button_press(Button &button) {
     if (button.is_toggle) {
         if (!button.is_pressed && button.on_click) {
-    		button.on_click();
+            button.on_click();
         }
         button.is_pressed = !button.is_pressed;
-    } else if(button.on_click) {
+    } else if (button.on_click) {
         button.on_click();
     }
 }
diff --git a/src/crepe/system/InputSystem.h b/src/crepe/system/InputSystem.h
index 5f71687..672f225 100644
--- a/src/crepe/system/InputSystem.h
+++ b/src/crepe/system/InputSystem.h
@@ -1,32 +1,82 @@
 #pragma once
 
-#include <utility>
-
 #include "System.h"
 
 #include "../api/Event.h"
 #include "../api/Button.h"
 #include "../api/Transform.h"
+#include "../facade/SDLContext.h"
 
 namespace crepe {
 
+/**
+ * \class InputSystem
+ * \brief Handles the processing of input events like mouse and keyboard interactions.
+ * 
+ * This system processes events such as mouse clicks, mouse movement, and keyboard
+ * actions. It is responsible for detecting interactions with UI buttons and
+ * passing the corresponding events to the registered listeners.
+ */
 class InputSystem : public System {
 public:
-	using System::System;
-	void update() override;
-	void process_events();
-	
+    using System::System;
+
+    /**
+     * \brief Updates the system, processing all input events.
+     * This method processes all events and triggers corresponding actions.
+     */
+    void update() override;
+
 private:
-	std::pair<int, int> last_mouse_down_position{-1, -1};
+    //! Stores the last position of the mouse when the button was pressed.
+    std::pair<int, int> last_mouse_down_position{-1, -1};
+
+    //! Stores the last mouse button pressed.
     MouseButton last_mouse_button = MouseButton::NONE;
-	const int click_tolerance = 5;
-	void handle_click(const MouseReleaseEvent);
-	void handle_move(const MouseMoveEvent);
+
+    //! The tolerance in pixels for detecting a mouse click.
+    const int click_tolerance = 5;
+
+    /**
+     * \brief Handles the click event.
+     * \param eventData The event data containing information about the mouse click.
+     * 
+     * This method processes the mouse click event and triggers the corresponding button action.
+     */
+    void handle_click(const SDLContext::EventData &eventData);
+
+    /**
+     * \brief Handles the mouse movement event.
+     * \param eventData The event data containing information about the mouse movement.
+     * 
+     * This method processes the mouse movement event and updates the button hover state.
+     */
+    void handle_move(const SDLContext::EventData &eventData);
+
+    /**
+     * \brief Finds the transform component associated with a button.
+     * \param button The button to find the associated transform for.
+     * \param transforms A list of transforms to search through.
+     * \return A pointer to the transform of the button, or nullptr if not found.
+     */
     Transform* find_transform_for_button(Button &button, std::vector<std::reference_wrapper<Transform>> &transforms);
 
-    bool is_mouse_inside_button(const MouseReleaseEvent &event, const Button &button, const Transform &transform);
+    /**
+     * \brief Checks if the mouse position is inside the bounds of the button.
+     * \param eventData The event data containing the mouse position.
+     * \param button The button to check.
+     * \param transform The transform component of the button.
+     * \return True if the mouse is inside the button, false otherwise.
+     */
+    bool is_mouse_inside_button(const SDLContext::EventData &eventData, const Button &button, const Transform &transform);
 
-    void handle_button_press(Button &button, const MouseReleaseEvent &event);
+    /**
+     * \brief Handles the button press event, calling the on_click callback if necessary.
+     * \param button The button being pressed.
+     * 
+     * This method triggers the on_click action for the button when it is pressed.
+     */
+    void handle_button_press(Button &button);
 };
 
 } // namespace crepe