added loopTimer and eventManager to mediator and removed the singletons

4 files changed, 65 insertions, 73 deletions

diff --git a/src/test/EventTest.cpp b/src/test/EventTest.cpp
index dccd554..8479998 100644
--- a/src/test/EventTest.cpp
+++ b/src/test/EventTest.cpp
@@ -1,56 +1,41 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
-
 #include <crepe/api/Event.h>
-#include <crepe/api/IKeyListener.h>
-#include <crepe/api/IMouseListener.h>
 #include <crepe/manager/EventManager.h>
-
+#include <crepe/manager/Mediator.h>
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
 
 class EventManagerTest : public ::testing::Test {
 protected:
+	Mediator mediator;
+	EventManager event_mgr{mediator};
 	void SetUp() override {
 		// Clear any existing subscriptions or events before each test
-		EventManager::get_instance().clear();
+		event_mgr.clear();
 	}
 
 	void TearDown() override {
 		// Ensure cleanup after each test
-		EventManager::get_instance().clear();
+		event_mgr.clear();
 	}
 };
-class MockKeyListener : public IKeyListener {
-public:
-	MOCK_METHOD(bool, on_key_pressed, (const KeyPressEvent & event), (override));
-	MOCK_METHOD(bool, on_key_released, (const KeyReleaseEvent & event), (override));
-};
-
-class MockMouseListener : public IMouseListener {
-public:
-	MOCK_METHOD(bool, on_mouse_clicked, (const MouseClickEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_pressed, (const MousePressEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_released, (const MouseReleaseEvent & event), (override));
-	MOCK_METHOD(bool, on_mouse_moved, (const MouseMoveEvent & event), (override));
-};
-
 TEST_F(EventManagerTest, EventSubscription) {
 	EventHandler<KeyPressEvent> key_handler = [](const KeyPressEvent & e) { return true; };
 
 	// Subscribe to KeyPressEvent
-	EventManager::get_instance().subscribe<KeyPressEvent>(key_handler, 1);
+	event_mgr.subscribe<KeyPressEvent>(key_handler, 1);
 
 	// Verify subscription (not directly verifiable; test by triggering event)
 
-	EventManager::get_instance().trigger_event<KeyPressEvent>(
+	event_mgr.trigger_event<KeyPressEvent>(
 		KeyPressEvent{
 			.repeat = true,
 			.key = Keycode::A,
 		},
 		1);
-	EventManager::get_instance().trigger_event<KeyPressEvent>(
+	event_mgr.trigger_event<KeyPressEvent>(
 		KeyPressEvent{
 			.repeat = true,
 			.key = Keycode::A,
@@ -68,12 +53,12 @@ TEST_F(EventManagerTest, EventManagerTest_trigger_all_channels) {
 		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false;
 	};
-	EventManager::get_instance().subscribe<MouseClickEvent>(mouse_handler,
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler,
 															EventManager::CHANNEL_ALL);
 
 	MouseClickEvent click_event{
 		.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE};
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
+	event_mgr.trigger_event<MouseClickEvent>(click_event,
 																EventManager::CHANNEL_ALL);
 
 	EXPECT_TRUE(triggered);
@@ -88,19 +73,18 @@ TEST_F(EventManagerTest, EventManagerTest_trigger_one_channel) {
 		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false;
 	};
-	EventManager::get_instance().subscribe<MouseClickEvent>(mouse_handler, test_channel);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler, test_channel);
 
 	MouseClickEvent click_event{
 		.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE};
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event,
+	event_mgr.trigger_event<MouseClickEvent>(click_event,
 																EventManager::CHANNEL_ALL);
 
 	EXPECT_FALSE(triggered);
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event, test_channel);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, test_channel);
 }
 
 TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
-	EventManager & event_manager = EventManager::get_instance();
 
 	// Flags to track handler calls
 	bool triggered_true = false;
@@ -126,11 +110,11 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 	// Test event
 	MouseClickEvent click_event{
 		.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE};
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
 
 	// Trigger event
-	event_manager.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
 
 	// Check that only the true handler was triggered
 	EXPECT_TRUE(triggered_true);
@@ -139,12 +123,12 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 	// Reset and clear
 	triggered_true = false;
 	triggered_false = false;
-	event_manager.clear();
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
-	event_manager.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
+	event_mgr.clear();
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_false, EventManager::CHANNEL_ALL);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler_true, EventManager::CHANNEL_ALL);
 
 	// Trigger event again
-	event_manager.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
+	event_mgr.trigger_event<MouseClickEvent>(click_event, EventManager::CHANNEL_ALL);
 
 	// Check that both handlers were triggered
 	EXPECT_TRUE(triggered_true);
@@ -152,7 +136,6 @@ TEST_F(EventManagerTest, EventManagerTest_callback_propagation) {
 }
 
 TEST_F(EventManagerTest, EventManagerTest_queue_dispatch) {
-	EventManager & event_manager = EventManager::get_instance();
 	bool triggered1 = false;
 	bool triggered2 = false;
 	int test_channel = 1;
@@ -170,21 +153,20 @@ TEST_F(EventManagerTest, EventManagerTest_queue_dispatch) {
 		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
 		return false; // Allows propagation
 	};
-	event_manager.subscribe<MouseClickEvent>(mouse_handler1);
-	event_manager.subscribe<MouseClickEvent>(mouse_handler2, test_channel);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler1);
+	event_mgr.subscribe<MouseClickEvent>(mouse_handler2, test_channel);
 
-	event_manager.queue_event<MouseClickEvent>(
+	event_mgr.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
-	event_manager.queue_event<MouseClickEvent>(
+	event_mgr.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE},
 		test_channel);
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_TRUE(triggered1);
 	EXPECT_TRUE(triggered2);
 }
 
 TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
-	EventManager & event_manager = EventManager::get_instance();
 
 	// Flags to track if handlers are triggered
 	bool triggered1 = false;
@@ -207,15 +189,15 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 		return false; // Allows propagation
 	};
 	// Subscribe handlers
-	subscription_t handler1_id = event_manager.subscribe<MouseClickEvent>(mouse_handler1);
-	subscription_t handler2_id = event_manager.subscribe<MouseClickEvent>(mouse_handler2);
+	subscription_t handler1_id = event_mgr.subscribe<MouseClickEvent>(mouse_handler1);
+	subscription_t handler2_id = event_mgr.subscribe<MouseClickEvent>(mouse_handler2);
 
 	// Queue events
-	event_manager.queue_event<MouseClickEvent>(
+	event_mgr.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - both handlers should be triggered
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_TRUE(triggered1); // Handler 1 should be triggered
 	EXPECT_TRUE(triggered2); // Handler 2 should be triggered
 
@@ -224,14 +206,14 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 	triggered2 = false;
 
 	// Unsubscribe handler1
-	event_manager.unsubscribe(handler1_id);
+	event_mgr.unsubscribe(handler1_id);
 
 	// Queue the same event again
-	event_manager.queue_event<MouseClickEvent>(
+	event_mgr.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - only handler 2 should be triggered, handler 1 should NOT
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_FALSE(triggered1); // Handler 1 should NOT be triggered
 	EXPECT_TRUE(triggered2); // Handler 2 should be triggered
 
@@ -239,14 +221,14 @@ TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 	triggered2 = false;
 
 	// Unsubscribe handler2
-	event_manager.unsubscribe(handler2_id);
+	event_mgr.unsubscribe(handler2_id);
 
 	// Queue the event again
-	event_manager.queue_event<MouseClickEvent>(
+	event_mgr.queue_event<MouseClickEvent>(
 		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
 
 	// Dispatch events - no handler should be triggered
-	event_manager.dispatch_events();
+	event_mgr.dispatch_events();
 	EXPECT_FALSE(triggered1); // Handler 1 should NOT be triggered
 	EXPECT_FALSE(triggered2); // Handler 2 should NOT be triggered
 }
diff --git a/src/test/LoopManagerTest.cpp b/src/test/LoopManagerTest.cpp
index 503eb1f..57f7a2e 100644
--- a/src/test/LoopManagerTest.cpp
+++ b/src/test/LoopManagerTest.cpp
@@ -2,13 +2,11 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <thread>
-#include <iostream>
 #define private public
 #define protected public
-#include "api/LoopManager.h"
-#include "api/LoopTimer.h"
-#include "manager/EventManager.h"
-#include "api/Event.h"
+#include <crepe/api/LoopManager.h>
+#include <crepe/manager/LoopTimerManager.h>
+#include <crepe/manager/EventManager.h>
 using namespace std::chrono;
 using namespace crepe;
 
@@ -24,19 +22,18 @@ protected:
     TestGameLoop test_loop;
 	// LoopManager test_loop;
     void SetUp() override {
-        test_loop.loop_timer->set_target_fps(10);
 		
     }
 };
 
 TEST_F(LoopManagerTest, FixedUpdate) {
     // Arrange
-    test_loop.loop_timer->set_target_fps(60);
+    test_loop.loop_timer.set_target_fps(60);
 
     // Set expectations for the mock calls
     EXPECT_CALL(test_loop, render).Times(::testing::Exactly(60)); 
 	EXPECT_CALL(test_loop, update).Times(::testing::Exactly(60));
-    EXPECT_CALL(test_loop, fixed_update).Times(::testing::AtLeast(50));
+    EXPECT_CALL(test_loop, fixed_update).Times(::testing::Exactly(50));
 
     // Start the loop in a separate thread
     std::thread loop_thread([&]() { test_loop.start(); });
@@ -46,12 +43,26 @@ TEST_F(LoopManagerTest, FixedUpdate) {
 
     // Stop the game loop
     test_loop.game_running = false;
-
     // Wait for the loop thread to finish
     loop_thread.join();
 
     // Test finished
 }
+TEST_F(LoopManagerTest, ShutDown) {
+    // Arrange
+    test_loop.loop_timer.set_target_fps(60);
 
+	EXPECT_CALL(test_loop, render).Times(::testing::AtLeast(1)); 
+	EXPECT_CALL(test_loop, update).Times(::testing::AtLeast(1));
+    EXPECT_CALL(test_loop, fixed_update).Times(::testing::AtLeast(1));
+    // Start the loop in a separate thread
+    std::thread loop_thread([&]() { test_loop.start(); });
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+	test_loop.event_manager.trigger_event<ShutDownEvent>(ShutDownEvent{});
+    // Wait for the loop thread to finish
+    loop_thread.join();
+
+    // Test finished
+}
 
 
diff --git a/src/test/LoopTimerTest.cpp b/src/test/LoopTimerTest.cpp
index 7652093..09b4e00 100644
--- a/src/test/LoopTimerTest.cpp
+++ b/src/test/LoopTimerTest.cpp
@@ -1,16 +1,17 @@
 #include <chrono>
-#include <gtest/gtest.h>
 #include <thread>
+#include <gtest/gtest.h>
 #define private public
 #define protected public
-#include "api/LoopTimer.h"
-
+#include <crepe/manager/LoopTimerManager.h>
+#include <crepe/manager/Mediator.h>
 using namespace std::chrono;
 using namespace crepe;
 
 class LoopTimerTest : public ::testing::Test {
 protected:
-	LoopTimer loop_timer;
+	Mediator mediator;
+	LoopTimerManager loop_timer{mediator};
 
 	void SetUp() override { loop_timer.start(); }
 };
@@ -25,8 +26,7 @@ TEST_F(LoopTimerTest, EnforcesTargetFrameRate) {
 	auto elapsed_ms = duration_cast<milliseconds>(elapsed_time).count();
 
 	// For 60 FPS, the target frame time is around 16.67ms
-	ASSERT_GE(elapsed_ms, 16); // Make sure it's at least 16 ms (could be slightly more)
-	ASSERT_LE(elapsed_ms, 18); // Ensure it's not too much longer
+	ASSERT_NEAR(elapsed_ms,16.7,1);
 }
 TEST_F(LoopTimerTest, SetTargetFps) {
 	// Set the target FPS to 120
@@ -48,11 +48,10 @@ TEST_F(LoopTimerTest, DeltaTimeCalculation) {
 	// Check the delta time
 	double delta_time = loop_timer.get_delta_time();
 
-	auto elapsed_time = duration_cast<milliseconds>(end_time - start_time).count();
+	auto elapsed_time = duration_cast<seconds>(end_time - start_time).count();
 
 	// Assert that delta_time is close to the elapsed time
-	ASSERT_GE(delta_time, elapsed_time / 1000.0);
-	ASSERT_LE(delta_time, (elapsed_time + 2) / 1000.0);
+	ASSERT_NEAR(delta_time, elapsed_time, 1);
 }
 
 TEST_F(LoopTimerTest, getCurrentTime) {
diff --git a/src/test/ScriptTest.h b/src/test/ScriptTest.h
index 1bbfdd3..ee68c23 100644
--- a/src/test/ScriptTest.h
+++ b/src/test/ScriptTest.h
@@ -7,7 +7,7 @@
 #include <crepe/api/Script.h>
 #include <crepe/manager/ComponentManager.h>
 #include <crepe/system/ScriptSystem.h>
-
+#include <crepe/manager/EventManager.h>
 class ScriptTest : public testing::Test {
 protected:
 	crepe::Mediator mediator;
@@ -15,7 +15,7 @@ protected:
 public:
 	crepe::ComponentManager component_manager{mediator};
 	crepe::ScriptSystem system{mediator};
-
+	crepe::EventManager event_mgr{mediator};
 	class MyScript : public crepe::Script {
 		// NOTE: explicitly stating `public:` is not required on actual scripts