2 files changed, 151 insertions, 125 deletions

diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 32538e8..bb454af 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -1,4 +1,3 @@
-#include <iostream>
 #include "../api/Button.h"
 #include "../manager/ComponentManager.h"
 #include "../manager/EventManager.h"
@@ -11,7 +10,7 @@ using namespace crepe;
 
 void InputSystem::update() {
 	ComponentManager & mgr = this->mediator.component_manager;
-	EventManager & event_mgr = this->mediator.event_manager;
+	
 	SDLContext & context = this->mediator.sdl_context;
 	std::vector<SDLContext::EventData> event_list = context.get_events();
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -31,129 +30,135 @@ void InputSystem::update() {
 		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
 	Transform & cam_transform = transform_vec.front().get();
 
-	ivec2 camera_origin;
-	int camera_origin_x = cam_transform.position.x + current_cam.data.postion_offset.x
-						  - (current_cam.viewport_size.x / 2);
-	int camera_origin_y = cam_transform.position.y + current_cam.data.postion_offset.y
-						  - (current_cam.viewport_size.y / 2);
+	vec2 camera_origin = cam_transform.position + current_cam.data.postion_offset
+						  - (current_cam.viewport_size / 2);
 
 	for (const SDLContext::EventData & event : event_list) {
 		// Only calculate mouse coordinates for relevant events
-		if (event.event_type == SDLContext::EventType::MOUSEDOWN
-			|| event.event_type == SDLContext::EventType::MOUSEUP
-			|| event.event_type == SDLContext::EventType::MOUSEMOVE
-			|| event.event_type == SDLContext::EventType::MOUSEWHEEL) {
-
-			ivec2 adjusted_mouse;
-			std::cout << "mousePos X: " << event.data.mouse_data.mouse_position.x << std::endl;
-			std::cout << "mousePos Y: " << event.data.mouse_data.mouse_position.y << std::endl;
-			int world_mouse_x = event.data.mouse_data.mouse_position.x + camera_origin_x;
-			int world_mouse_y = event.data.mouse_data.mouse_position.y + camera_origin_y;
-			// Check if the mouse is within the viewport
-			bool mouse_in_viewport
-			= !(world_mouse_x < camera_origin_x
-				|| world_mouse_x > camera_origin_x + current_cam.viewport_size.x
-				|| world_mouse_y < camera_origin_y
-				|| world_mouse_y > camera_origin_y + current_cam.viewport_size.y);
-			std::cout << "in view " << mouse_in_viewport << std::endl;
-			if (!mouse_in_viewport) continue;
-
-			// Handle mouse-specific events
-			switch (event.event_type) {
-				case SDLContext::EventType::MOUSEDOWN:
-					event_mgr.queue_event<MousePressEvent>({
-						.mouse_pos = {adjusted_mouse.x, adjusted_mouse.y},
-						.button = event.data.mouse_data.mouse_button,
-					});
-					this->last_mouse_down_position = {adjusted_mouse.x, adjusted_mouse.y};
-					this->last_mouse_button = event.data.mouse_data.mouse_button;
-					break;
-
-				case SDLContext::EventType::MOUSEUP: {
-					event_mgr.queue_event<MouseReleaseEvent>({
-						.mouse_pos = {adjusted_mouse.x, adjusted_mouse.y},
-						.button = event.data.mouse_data.mouse_button,
-					});
-					int delta_x = adjusted_mouse.x - this->last_mouse_down_position.x;
-					int delta_y = adjusted_mouse.y - this->last_mouse_down_position.y;
-
-					if (this->last_mouse_button == event.data.mouse_data.mouse_button
-						&& std::abs(delta_x) <= click_tolerance
-						&& std::abs(delta_y) <= click_tolerance) {
-						event_mgr.queue_event<MouseClickEvent>({
-							.mouse_pos = {adjusted_mouse.x, adjusted_mouse.y},
-							.button = event.data.mouse_data.mouse_button,
-						});
-						this->handle_click(event.data.mouse_data.mouse_button, adjusted_mouse);
-					}
-					break;
-				}
-
-				case SDLContext::EventType::MOUSEMOVE:
-					event_mgr.queue_event<MouseMoveEvent>({
-						.mouse_pos = {adjusted_mouse.x, adjusted_mouse.y},
-						.mouse_delta = event.data.mouse_data.rel_mouse_move,
-					});
-					this->handle_move(event, adjusted_mouse);
-					break;
-
-				case SDLContext::EventType::MOUSEWHEEL:
-					event_mgr.queue_event<MouseScrollEvent>({
-						.mouse_pos = {adjusted_mouse.x, adjusted_mouse.y},
-						.scroll_direction = event.data.mouse_data.scroll_direction,
-						.scroll_delta = event.data.mouse_data.scroll_delta,
-					});
-					break;
-
-				default:
-					break;
-			}
+		if(this->is_mouse_event(event.event_type)) {
+			this->handle_mouse_event(event,camera_origin,current_cam);
+			
 		} else {
-			// Handle non-mouse events
-			switch (event.event_type) {
-				case SDLContext::EventType::KEYDOWN:
-					
-					event_mgr.queue_event<KeyPressEvent>(
-						{.repeat = event.data.key_data.key_repeat, .key = event.data.key_data.key});
-					break;
-				case SDLContext::EventType::KEYUP:
-					event_mgr.queue_event<KeyReleaseEvent>({.key = event.data.key_data.key});
-					break;
-				case SDLContext::EventType::SHUTDOWN:
-					event_mgr.queue_event<ShutDownEvent>({});
-					break;
-				case SDLContext::EventType::WINDOW_EXPOSE:
-					event_mgr.queue_event<WindowExposeEvent>({});
-					break;
-				case SDLContext::EventType::WINDOW_RESIZE:
-					event_mgr.queue_event<WindowResizeEvent>(
-						WindowResizeEvent{.dimensions = event.data.window_data.resize_dimension});
-					break;
-				case SDLContext::EventType::WINDOW_MOVE:
-					event_mgr.queue_event<WindowMoveEvent>(
-						{.delta_move = event.data.window_data.move_delta});
-					break;
-				case SDLContext::EventType::WINDOW_MINIMIZE:
-					event_mgr.queue_event<WindowMinimizeEvent>({});
-					break;
-				case SDLContext::EventType::WINDOW_MAXIMIZE:
-					event_mgr.queue_event<WindowMaximizeEvent>({});
-					break;
-				case SDLContext::EventType::WINDOW_FOCUS_GAIN:
-					event_mgr.queue_event<WindowFocusGainEvent>({});
-					break;
-				case SDLContext::EventType::WINDOW_FOCUS_LOST:
-					event_mgr.queue_event<WindowFocusLostEvent>({});
-					break;
-				default:
-					break;
+			this->handle_non_mouse_event(event);
+			
+		}
+	}
+}
+
+void InputSystem::handle_mouse_event(const SDLContext::EventData &event, const vec2 &camera_origin, 
+                                     const Camera &current_cam){
+	EventManager & event_mgr = this->mediator.event_manager;
+	vec2 adjusted_mouse;
+	adjusted_mouse.x = event.data.mouse_data.mouse_position.x + camera_origin.x;
+	adjusted_mouse.x = event.data.mouse_data.mouse_position.y + camera_origin.y;
+	// Check if the mouse is within the viewport
+	if ((adjusted_mouse.x < camera_origin.x
+		|| adjusted_mouse.x > camera_origin.x + current_cam.viewport_size.x
+		|| adjusted_mouse.y < camera_origin.y
+		|| adjusted_mouse.y > camera_origin.y + current_cam.viewport_size.y)) return;
+
+	// Handle mouse-specific events
+	switch (event.event_type) {
+		case SDLContext::EventType::MOUSEDOWN:
+			event_mgr.queue_event<MousePressEvent>({
+				.mouse_pos = adjusted_mouse,
+				.button = event.data.mouse_data.mouse_button,
+			});
+			this->last_mouse_down_position = adjusted_mouse;
+			this->last_mouse_button = event.data.mouse_data.mouse_button;
+			break;
+
+		case SDLContext::EventType::MOUSEUP: {
+			event_mgr.queue_event<MouseReleaseEvent>({
+				.mouse_pos = adjusted_mouse,
+				.button = event.data.mouse_data.mouse_button,
+			});
+			vec2 delta_move = adjusted_mouse - this->last_mouse_down_position;
+			int click_tolerance = Config::get_instance().input.click_tolerance;
+			if (this->last_mouse_button == event.data.mouse_data.mouse_button
+				&& std::abs(delta_move.x) <= click_tolerance
+				&& std::abs(delta_move.y) <= click_tolerance) {
+				event_mgr.queue_event<MouseClickEvent>({
+					.mouse_pos = adjusted_mouse,
+					.button = event.data.mouse_data.mouse_button,
+				});
+				this->handle_click(event.data.mouse_data.mouse_button, adjusted_mouse);
 			}
+			break;
 		}
+
+		case SDLContext::EventType::MOUSEMOVE:
+			event_mgr.queue_event<MouseMoveEvent>({
+				.mouse_pos = adjusted_mouse,
+				.mouse_delta = event.data.mouse_data.rel_mouse_move,
+			});
+			this->handle_move(event, adjusted_mouse);
+			break;
+
+		case SDLContext::EventType::MOUSEWHEEL:
+			event_mgr.queue_event<MouseScrollEvent>({
+				.mouse_pos = adjusted_mouse,
+				.scroll_direction = event.data.mouse_data.scroll_direction,
+				.scroll_delta = event.data.mouse_data.scroll_delta,
+			});
+			break;
+
+		default:
+			break;
+	}									
+}
+
+void InputSystem::handle_non_mouse_event(const SDLContext::EventData &event){
+	EventManager & event_mgr = this->mediator.event_manager;
+	switch (event.event_type) {
+		case SDLContext::EventType::KEYDOWN:
+			
+			event_mgr.queue_event<KeyPressEvent>(
+				{.repeat = event.data.key_data.key_repeat, .key = event.data.key_data.key});
+			break;
+		case SDLContext::EventType::KEYUP:
+			event_mgr.queue_event<KeyReleaseEvent>({.key = event.data.key_data.key});
+			break;
+		case SDLContext::EventType::SHUTDOWN:
+			event_mgr.queue_event<ShutDownEvent>({});
+			break;
+		case SDLContext::EventType::WINDOW_EXPOSE:
+			event_mgr.queue_event<WindowExposeEvent>({});
+			break;
+		case SDLContext::EventType::WINDOW_RESIZE:
+			event_mgr.queue_event<WindowResizeEvent>(
+				WindowResizeEvent{.dimensions = event.data.window_data.resize_dimension});
+			break;
+		case SDLContext::EventType::WINDOW_MOVE:
+			event_mgr.queue_event<WindowMoveEvent>(
+				{.delta_move = event.data.window_data.move_delta});
+			break;
+		case SDLContext::EventType::WINDOW_MINIMIZE:
+			event_mgr.queue_event<WindowMinimizeEvent>({});
+			break;
+		case SDLContext::EventType::WINDOW_MAXIMIZE:
+			event_mgr.queue_event<WindowMaximizeEvent>({});
+			break;
+		case SDLContext::EventType::WINDOW_FOCUS_GAIN:
+			event_mgr.queue_event<WindowFocusGainEvent>({});
+			break;
+		case SDLContext::EventType::WINDOW_FOCUS_LOST:
+			event_mgr.queue_event<WindowFocusLostEvent>({});
+			break;
+		default:
+			break;
 	}
 }
 
+bool InputSystem::is_mouse_event(SDLContext::EventType event_type){
+	return (event_type == SDLContext::EventType::MOUSEDOWN
+			|| event_type == SDLContext::EventType::MOUSEUP
+			|| event_type == SDLContext::EventType::MOUSEMOVE
+			|| event_type == SDLContext::EventType::MOUSEWHEEL);
+}
+
 void InputSystem::handle_move(const SDLContext::EventData & event_data,
-							  const ivec2& mouse_pos) {
+							  const vec2& mouse_pos) {
 	ComponentManager & mgr = this->mediator.component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -183,7 +188,7 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data,
 	}
 }
 
-void InputSystem::handle_click(const MouseButton & mouse_button, const ivec2& mouse_pos) {
+void InputSystem::handle_click(const MouseButton & mouse_button, const vec2& mouse_pos) {
 	ComponentManager & mgr = this->mediator.component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -203,7 +208,7 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const ivec2& mo
 	}
 }
 
-bool InputSystem::is_mouse_inside_button(const ivec2& mouse_pos,
+bool InputSystem::is_mouse_inside_button(const vec2& mouse_pos,
 										 const Button & button, const Transform & transform) {
 	int actual_x = transform.position.x + button.offset.x;
 	int actual_y = transform.position.y + button.offset.y;
diff --git a/src/crepe/system/InputSystem.h b/src/crepe/system/InputSystem.h
index 3703635..7b8f510 100644
--- a/src/crepe/system/InputSystem.h
+++ b/src/crepe/system/InputSystem.h
@@ -32,15 +32,36 @@ public:
 
 private:
 	//! Stores the last position of the mouse when the button was pressed.
-	ivec2 last_mouse_down_position;
+	vec2 last_mouse_down_position;
 	// TODO: specify world/hud space and make regular `vec2`
 
 	//! Stores the last mouse button pressed.
 	MouseButton last_mouse_button = MouseButton::NONE;
-
-	//! The maximum allowable distance between mouse down and mouse up to register as a click. This can be changed using the Config.
-	int click_tolerance = Config::get_instance().input.click_tolerance;
-
+	/**
+	 * \brief Determines whether the given event type is a mouse event.
+	 * \param event_type The event type to check.
+	 * \return True if the event type corresponds to a mouse event, false otherwise.
+	 */
+	bool is_mouse_event(SDLContext::EventType event_type);
+	/**
+	 * \brief Handles mouse-related events.
+	 * \param event The event data for the mouse event.
+	 * \param camera_origin The origin position of the camera in world space.
+	 * \param current_cam The currently active camera.
+	 *
+	 * This method processes mouse events, adjusts the mouse position to world coordinates,
+	 * and triggers the appropriate mouse-specific event handling logic.
+	 */
+	void handle_mouse_event(const SDLContext::EventData &event, const vec2 &camera_origin, 
+							const Camera &current_cam);
+	/**
+	 * \brief Handles non-mouse-related events.
+	 * \param event The event data for the non-mouse event.
+	 *
+	 * This method processes events that do not involve the mouse, such as keyboard events,
+	 * window events, and shutdown events, and triggers the corresponding event actions.
+	 */
+	void handle_non_mouse_event(const SDLContext::EventData &event);
 	/**
 	* \brief Handles the mouse click event.
 	* \param mouse_button The mouse button involved in the click.
@@ -49,7 +70,7 @@ private:
 	*
 	* This method processes the mouse click event and triggers the corresponding button action.
 	*/
-	void handle_click(const MouseButton & mouse_button,const ivec2& mouse_pos);
+	void handle_click(const MouseButton & mouse_button,const vec2& mouse_pos);
 
 	/**
 	* \brief Handles the mouse movement event.
@@ -59,7 +80,7 @@ private:
 	*
 	* This method processes the mouse movement event and updates the button hover state.
 	*/
-	void handle_move(const SDLContext::EventData & event_data, const ivec2& mouse_pos);
+	void handle_move(const SDLContext::EventData & event_data, const vec2& mouse_pos);
 
 	/**
 	* \brief Checks if the mouse position is inside the bounds of the button.
@@ -69,7 +90,7 @@ private:
 	* \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 ivec2& mouse_pos,
+	bool is_mouse_inside_button(const vec2& mouse_pos,
 								const Button & button, const Transform & transform);
 
 	/**