merge with master and keypressed added to game

15 files changed, 545 insertions, 164 deletions

diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 616e238..a863598 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,6 +1,6 @@
 target_sources(test_main PUBLIC
-	CollisionTest.cpp
 	main.cpp
+	CollisionTest.cpp
 	# PhysicsTest.cpp
 	# ScriptTest.cpp
 	# ParticleTest.cpp
@@ -13,5 +13,8 @@ target_sources(test_main PUBLIC
 	# ValueBrokerTest.cpp
 	# DBTest.cpp
 	# Vector2Test.cpp
+	# InputTest.cpp
+	# ScriptEventTest.cpp
+	# ScriptSceneTest.cpp
 	# Profiling.cpp
 )
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 3da04b5..a683b1f 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,4 +1,5 @@
 #include "api/BoxCollider.h"
+#include "manager/Mediator.h"
 #include <cmath>
 #include <cstddef>
 #include <gtest/gtest.h>
@@ -6,9 +7,10 @@
 #define private public
 #define protected public
 
-#include <crepe/ComponentManager.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/Mediator.h>
 #include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
+#include <crepe/manager/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Script.h>
@@ -47,9 +49,10 @@ public:
 
 class CollisionTest : public Test {
 public:
-	ComponentManager mgr;
-	CollisionSystem collision_sys{mgr};
-	ScriptSystem script_sys{mgr};
+	Mediator m;
+	ComponentManager mgr{m};
+	CollisionSystem collision_sys{m};
+	ScriptSystem script_sys{m};
 
 	GameObject world = mgr.new_object("world", "", {50, 50});
 	GameObject game_object1 = mgr.new_object("object1", "", {50, 50});
diff --git a/src/test/DBTest.cpp b/src/test/DBTest.cpp
index e80814c..99dedff 100644
--- a/src/test/DBTest.cpp
+++ b/src/test/DBTest.cpp
@@ -1,6 +1,7 @@
-#include <crepe/facade/DB.h>
 #include <gtest/gtest.h>
 
+#include <crepe/facade/DB.h>
+
 using namespace std;
 using namespace crepe;
 using namespace testing;
diff --git a/src/test/ECSTest.cpp b/src/test/ECSTest.cpp
index af9d6f2..3e6c61c 100644
--- a/src/test/ECSTest.cpp
+++ b/src/test/ECSTest.cpp
@@ -2,18 +2,20 @@
 
 #define protected public
 
-#include <crepe/ComponentManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Metadata.h>
 #include <crepe/api/Transform.h>
 #include <crepe/api/Vector2.h>
+#include <crepe/manager/ComponentManager.h>
 
 using namespace std;
 using namespace crepe;
 
 class ECSTest : public ::testing::Test {
+	Mediator m;
+
 public:
-	ComponentManager mgr{};
+	ComponentManager mgr{m};
 };
 
 TEST_F(ECSTest, createGameObject) {
diff --git a/src/test/EventTest.cpp b/src/test/EventTest.cpp
index b0e6c9c..4a4872d 100644
--- a/src/test/EventTest.cpp
+++ b/src/test/EventTest.cpp
@@ -1,10 +1,11 @@
-
-#include "api/Event.h"
-#include "api/EventManager.h"
-#include "api/IKeyListener.h"
-#include "api/IMouseListener.h"
 #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>
+
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
@@ -36,10 +37,7 @@ public:
 };
 
 TEST_F(EventManagerTest, EventSubscription) {
-	EventHandler<KeyPressEvent> key_handler = [](const KeyPressEvent & e) {
-		std::cout << "Key Event Triggered" << std::endl;
-		return true;
-	};
+	EventHandler<KeyPressEvent> key_handler = [](const KeyPressEvent & e) { return true; };
 
 	// Subscribe to KeyPressEvent
 	EventManager::get_instance().subscribe<KeyPressEvent>(key_handler, 1);
@@ -158,29 +156,37 @@ TEST_F(EventManagerTest, EventManagerTest_queue_dispatch) {
 	bool triggered1 = false;
 	bool triggered2 = false;
 	int test_channel = 1;
-	EventHandler<MouseClickEvent> mouse_handler1 = [&](const MouseClickEvent & e) {
+
+	// Adjusted to use KeyPressEvent with repeat as the first variable
+	EventHandler<KeyPressEvent> key_handler1 = [&](const KeyPressEvent & e) {
 		triggered1 = true;
-		EXPECT_EQ(e.mouse_x, 100);
-		EXPECT_EQ(e.mouse_y, 200);
-		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
+		EXPECT_EQ(e.repeat, false); // Expecting repeat to be false
+		EXPECT_EQ(e.key, Keycode::A); // Adjust expected key code
 		return false; // Allows propagation
 	};
-	EventHandler<MouseClickEvent> mouse_handler2 = [&](const MouseClickEvent & e) {
+
+	EventHandler<KeyPressEvent> key_handler2 = [&](const KeyPressEvent & e) {
 		triggered2 = true;
-		EXPECT_EQ(e.mouse_x, 100);
-		EXPECT_EQ(e.mouse_y, 200);
-		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
+		EXPECT_EQ(e.repeat, false); // Expecting repeat to be false
+		EXPECT_EQ(e.key, Keycode::A); // Adjust expected key code
 		return false; // Allows propagation
 	};
-	event_manager.subscribe<MouseClickEvent>(mouse_handler1);
-	event_manager.subscribe<MouseClickEvent>(mouse_handler2, test_channel);
 
-	event_manager.queue_event<MouseClickEvent>(
-		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE});
-	event_manager.queue_event<MouseClickEvent>(
-		MouseClickEvent{.mouse_x = 100, .mouse_y = 200, .button = MouseButton::LEFT_MOUSE},
+	// Subscribe handlers to KeyPressEvent
+	event_manager.subscribe<KeyPressEvent>(key_handler1);
+	event_manager.subscribe<KeyPressEvent>(key_handler2, test_channel);
+
+	// Queue a KeyPressEvent instead of KeyDownEvent
+	event_manager.queue_event<KeyPressEvent>(KeyPressEvent{
+		.repeat = false, .key = Keycode::A}); // Adjust event with repeat flag first
+
+	event_manager.queue_event<KeyPressEvent>(
+		KeyPressEvent{.repeat = false,
+					  .key = Keycode::A}, // Adjust event for second subscription
 		test_channel);
+
 	event_manager.dispatch_events();
+
 	EXPECT_TRUE(triggered1);
 	EXPECT_TRUE(triggered2);
 }
diff --git a/src/test/InputTest.cpp b/src/test/InputTest.cpp
new file mode 100644
index 0000000..cb9833f
--- /dev/null
+++ b/src/test/InputTest.cpp
@@ -0,0 +1,293 @@
+#include <gtest/gtest.h>
+#define protected public
+#define private public
+#include "api/KeyCodes.h"
+#include "manager/ComponentManager.h"
+#include "manager/EventManager.h"
+#include "manager/Mediator.h"
+#include "system/InputSystem.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_keycode.h>
+#include <crepe/api/Button.h>
+#include <crepe/api/Camera.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Metadata.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
+#include <gmock/gmock.h>
+
+using namespace std;
+using namespace std::chrono_literals;
+using namespace crepe;
+
+class InputTest : public ::testing::Test {
+public:
+	Mediator mediator;
+	ComponentManager mgr{mediator};
+
+	InputSystem input_system{mediator};
+
+	EventManager & event_manager = EventManager::get_instance();
+	//GameObject camera;
+
+protected:
+	void SetUp() override {
+		mediator.event_manager = event_manager;
+		mediator.component_manager = mgr;
+		event_manager.clear();
+	}
+
+	void simulate_mouse_click(int mouse_x, int mouse_y, Uint8 mouse_button) {
+		SDL_Event event;
+
+		// Simulate Mouse Button Down event
+		SDL_zero(event);
+		event.type = SDL_MOUSEBUTTONDOWN;
+		event.button.x = mouse_x;
+		event.button.y = mouse_y;
+		event.button.button = mouse_button;
+		SDL_PushEvent(&event);
+
+		// Simulate Mouse Button Up event
+		SDL_zero(event);
+		event.type = SDL_MOUSEBUTTONUP;
+		event.button.x = mouse_x;
+		event.button.y = mouse_y;
+		event.button.button = mouse_button;
+		SDL_PushEvent(&event);
+	}
+};
+
+TEST_F(InputTest, MouseDown) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool mouse_triggered = false;
+	EventHandler<MousePressEvent> on_mouse_down = [&](const MousePressEvent & event) {
+		mouse_triggered = true;
+		//middle of the screen = 0,0
+		EXPECT_EQ(event.mouse_x, 0);
+		EXPECT_EQ(event.mouse_y, 0);
+		EXPECT_EQ(event.button, MouseButton::LEFT_MOUSE);
+		return false;
+	};
+	event_manager.subscribe<MousePressEvent>(on_mouse_down);
+
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_MOUSEBUTTONDOWN;
+	// middle of the screen of a 500*500 camera = 250*250
+	event.button.x = 250;
+	event.button.y = 250;
+	event.button.button = SDL_BUTTON_LEFT;
+	SDL_PushEvent(&event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(mouse_triggered);
+}
+
+TEST_F(InputTest, MouseUp) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool function_triggered = false;
+	EventHandler<MouseReleaseEvent> on_mouse_release = [&](const MouseReleaseEvent & e) {
+		function_triggered = true;
+		EXPECT_EQ(e.mouse_x, 0);
+		EXPECT_EQ(e.mouse_y, 0);
+		EXPECT_EQ(e.button, MouseButton::LEFT_MOUSE);
+		return false;
+	};
+	event_manager.subscribe<MouseReleaseEvent>(on_mouse_release);
+
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_MOUSEBUTTONUP;
+	event.button.x = 250;
+	event.button.y = 250;
+	event.button.button = SDL_BUTTON_LEFT;
+	SDL_PushEvent(&event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(function_triggered);
+}
+
+TEST_F(InputTest, MouseMove) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool function_triggered = false;
+	EventHandler<MouseMoveEvent> on_mouse_move = [&](const MouseMoveEvent & e) {
+		function_triggered = true;
+		EXPECT_EQ(e.mouse_x, 0);
+		EXPECT_EQ(e.mouse_y, 0);
+		EXPECT_EQ(e.delta_x, 10);
+		EXPECT_EQ(e.delta_y, 10);
+		return false;
+	};
+	event_manager.subscribe<MouseMoveEvent>(on_mouse_move);
+
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_MOUSEMOTION;
+	event.motion.x = 250;
+	event.motion.y = 250;
+	event.motion.xrel = 10;
+	event.motion.yrel = 10;
+	SDL_PushEvent(&event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(function_triggered);
+}
+
+TEST_F(InputTest, KeyDown) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool function_triggered = false;
+
+	// Define event handler for KeyPressEvent
+	EventHandler<KeyPressEvent> on_key_press = [&](const KeyPressEvent & event) {
+		function_triggered = true;
+		EXPECT_EQ(event.key, Keycode::B); // Validate the key is 'B'
+		EXPECT_EQ(event.repeat, true); // Validate repeat flag
+		return false;
+	};
+
+	event_manager.subscribe<KeyPressEvent>(on_key_press);
+
+	// Simulate SDL_KEYDOWN event
+	SDL_Event test_event;
+	SDL_zero(test_event);
+	test_event.type = SDL_KEYDOWN; // Key down event
+	test_event.key.keysym.scancode = SDL_SCANCODE_B; // Set scancode for 'B'
+	test_event.key.repeat = 1; // Set repeat flag
+	SDL_PushEvent(&test_event);
+
+	input_system.update(); // Process the event
+	event_manager.dispatch_events(); // Dispatch events to handlers
+
+	EXPECT_TRUE(function_triggered); // Check if the handler was triggered
+}
+
+TEST_F(InputTest, KeyUp) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool function_triggered = false;
+	EventHandler<KeyReleaseEvent> on_key_release = [&](const KeyReleaseEvent & event) {
+		function_triggered = true;
+		EXPECT_EQ(event.key, Keycode::B);
+		return false;
+	};
+	event_manager.subscribe<KeyReleaseEvent>(on_key_release);
+
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_KEYUP;
+	event.key.keysym.scancode = SDL_SCANCODE_B;
+	SDL_PushEvent(&event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(function_triggered);
+}
+
+TEST_F(InputTest, MouseClick) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	bool on_click_triggered = false;
+	EventHandler<MouseClickEvent> on_mouse_click = [&](const MouseClickEvent & event) {
+		on_click_triggered = true;
+		EXPECT_EQ(event.button, MouseButton::LEFT_MOUSE);
+		EXPECT_EQ(event.mouse_x, 0);
+		EXPECT_EQ(event.mouse_y, 0);
+		return false;
+	};
+	event_manager.subscribe<MouseClickEvent>(on_mouse_click);
+
+	this->simulate_mouse_click(250, 250, SDL_BUTTON_LEFT);
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(on_click_triggered);
+}
+
+TEST_F(InputTest, testButtonClick) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	bool button_clicked = false;
+	std::function<void()> on_click = [&]() { button_clicked = true; };
+	auto & button
+		= button_obj.add_component<Button>(vec2{100, 100}, vec2{0, 0}, on_click, false);
+
+	bool hover = false;
+	button.active = true;
+
+	button.is_pressed = false;
+	button.is_toggle = false;
+	this->simulate_mouse_click(999, 999, SDL_BUTTON_LEFT);
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_FALSE(button_clicked);
+
+	this->simulate_mouse_click(250, 250, SDL_BUTTON_LEFT);
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(button_clicked);
+}
+
+TEST_F(InputTest, testButtonHover) {
+	GameObject obj = mgr.new_object("camera", "camera", vec2{0, 0}, 0, 1);
+	auto & camera = obj.add_component<Camera>(Color::BLACK, ivec2{0, 0}, vec2{500, 500}, 0.0,
+											  vec2{0, 0});
+	camera.active = true;
+	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	bool button_clicked = false;
+	std::function<void()> on_click = [&]() { button_clicked = true; };
+	auto & button
+		= button_obj.add_component<Button>(vec2{100, 100}, vec2{0, 0}, on_click, false);
+	button.active = true;
+	button.is_pressed = false;
+	button.is_toggle = false;
+
+	// Mouse not on button
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_MOUSEMOTION;
+	event.motion.x = 700;
+	event.motion.y = 700;
+	event.motion.xrel = 10;
+	event.motion.yrel = 10;
+	SDL_PushEvent(&event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_FALSE(button.hover);
+
+	// Mouse on button
+	SDL_Event hover_event;
+	SDL_zero(hover_event);
+	hover_event.type = SDL_MOUSEMOTION;
+	hover_event.motion.x = 250;
+	hover_event.motion.y = 250;
+	hover_event.motion.xrel = 10;
+	hover_event.motion.yrel = 10;
+	SDL_PushEvent(&hover_event);
+
+	input_system.update();
+	event_manager.dispatch_events();
+	EXPECT_TRUE(button.hover);
+}
diff --git a/src/test/ParticleTest.cpp b/src/test/ParticleTest.cpp
index 976f9a1..a659fe5 100644
--- a/src/test/ParticleTest.cpp
+++ b/src/test/ParticleTest.cpp
@@ -1,12 +1,12 @@
-#include "api/Texture.h"
-#include <crepe/ComponentManager.h>
 #include <crepe/Particle.h>
 #include <crepe/api/Config.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/ParticleEmitter.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
 #include <crepe/api/Transform.h>
+#include <crepe/manager/ComponentManager.h>
 #include <crepe/system/ParticleSystem.h>
 #include <gtest/gtest.h>
 #include <math.h>
@@ -16,9 +16,11 @@ using namespace std::chrono_literals;
 using namespace crepe;
 
 class ParticlesTest : public ::testing::Test {
+	Mediator m;
+
 public:
-	ComponentManager component_manager;
-	ParticleSystem particle_system{component_manager};
+	ComponentManager component_manager{m};
+	ParticleSystem particle_system{m};
 
 	void SetUp() override {
 		ComponentManager & mgr = this->component_manager;
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index ad7cb03..43d2931 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -1,8 +1,8 @@
-#include <crepe/ComponentManager.h>
 #include <crepe/api/Config.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Rigidbody.h>
 #include <crepe/api/Transform.h>
+#include <crepe/manager/ComponentManager.h>
 #include <crepe/system/PhysicsSystem.h>
 #include <gtest/gtest.h>
 
@@ -11,9 +11,11 @@ using namespace std::chrono_literals;
 using namespace crepe;
 
 class PhysicsTest : public ::testing::Test {
+	Mediator m;
+
 public:
-	ComponentManager component_manager;
-	PhysicsSystem system{component_manager};
+	ComponentManager component_manager{m};
+	PhysicsSystem system{m};
 
 	void SetUp() override {
 		ComponentManager & mgr = this->component_manager;
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index d2f219e..91be769 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -1,3 +1,4 @@
+#include "manager/Mediator.h"
 #include "system/ParticleSystem.h"
 #include "system/PhysicsSystem.h"
 #include "system/RenderSystem.h"
@@ -8,9 +9,9 @@
 #define private public
 #define protected public
 
-#include <crepe/ComponentManager.h>
+#include <crepe/manager/ComponentManager.h>
 #include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
+#include <crepe/manager/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/ParticleEmitter.h>
 #include <crepe/api/Rigidbody.h>
@@ -52,13 +53,14 @@ public:
 	// Maximum duration to stop test
 	const std::chrono::microseconds duration = 16000us;
 
-	ComponentManager mgr;
+	Mediator m;
+	ComponentManager mgr{m};
 	// Add system used for profling tests
-	CollisionSystem collision_sys{mgr};
-	PhysicsSystem physics_sys{mgr};
-	ParticleSystem particle_sys{mgr};
-	RenderSystem render_sys{mgr};
-	ScriptSystem script_sys{mgr};
+	CollisionSystem collision_sys{m};
+	PhysicsSystem physics_sys{m};
+	ParticleSystem particle_sys{m};
+	RenderSystem render_sys{m};
+	ScriptSystem script_sys{m};
 
 	// Test data
 	std::map<std::string, std::chrono::microseconds> timings;
@@ -159,7 +161,8 @@ TEST_F(Profiling, Profiling_2) {
 				.gravity_scale = 0.0,
 				.body_type = Rigidbody::BodyType::STATIC,
 			});
-			gameobject.add_component<BoxCollider>(vec2{0, 0}, 1, 1);
+			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
+			
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/green_square.png");
@@ -192,7 +195,7 @@ TEST_F(Profiling, Profiling_3) {
 				.gravity_scale = 0,
 				.body_type = Rigidbody::BodyType::STATIC,
 			});
-			gameobject.add_component<BoxCollider>(vec2{0, 0}, 1, 1);
+			gameobject.add_component<BoxCollider>(vec2{0, 0}, vec2{1, 1});
 			gameobject.add_component<BehaviorScript>().set_script<TestScript>();
 			Color color(0, 0, 0, 0);
 			auto img = Texture("asset/texture/green_square.png");
diff --git a/src/test/RenderSystemTest.cpp b/src/test/RenderSystemTest.cpp
index bb5b81a..c105dcb 100644
--- a/src/test/RenderSystemTest.cpp
+++ b/src/test/RenderSystemTest.cpp
@@ -1,4 +1,3 @@
-#include "types.h"
 #include <functional>
 #include <gtest/gtest.h>
 #include <memory>
@@ -7,12 +6,12 @@
 #define private public
 #define protected public
 
-#include "crepe/api/Camera.h"
-#include <crepe/ComponentManager.h>
+#include <crepe/api/Camera.h>
 #include <crepe/api/Color.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Sprite.h>
 #include <crepe/api/Texture.h>
+#include <crepe/manager/ComponentManager.h>
 
 #include <crepe/system/RenderSystem.h>
 
@@ -21,9 +20,11 @@ using namespace crepe;
 using namespace testing;
 
 class RenderSystemTest : public Test {
+	Mediator m;
+
 public:
-	ComponentManager mgr{};
-	RenderSystem sys{mgr};
+	ComponentManager mgr{m};
+	RenderSystem sys{m};
 	GameObject entity1 = this->mgr.new_object("name");
 	GameObject entity2 = this->mgr.new_object("name");
 	GameObject entity3 = this->mgr.new_object("name");
diff --git a/src/test/SceneManagerTest.cpp b/src/test/SceneManagerTest.cpp
index 62b7d33..9bb260c 100644
--- a/src/test/SceneManagerTest.cpp
+++ b/src/test/SceneManagerTest.cpp
@@ -1,12 +1,13 @@
-#include "types.h"
-#include <crepe/ComponentManager.h>
+#include <gtest/gtest.h>
+
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Metadata.h>
 #include <crepe/api/Scene.h>
-#include <crepe/api/SceneManager.h>
 #include <crepe/api/Transform.h>
 #include <crepe/api/Vector2.h>
-#include <gtest/gtest.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/SceneManager.h>
+#include <crepe/types.h>
 
 using namespace std;
 using namespace crepe;
@@ -14,7 +15,8 @@ using namespace crepe;
 class ConcreteScene1 : public Scene {
 public:
 	void load_scene() {
-		ComponentManager & mgr = this->component_manager;
+		Mediator & mediator = this->mediator;
+		ComponentManager & mgr = mediator.component_manager;
 		GameObject object1 = mgr.new_object("scene_1", "tag_scene_1", vec2{0, 0}, 0, 1);
 		GameObject object2 = mgr.new_object("scene_1", "tag_scene_1", vec2{1, 0}, 0, 1);
 		GameObject object3 = mgr.new_object("scene_1", "tag_scene_1", vec2{2, 0}, 0, 1);
@@ -26,7 +28,8 @@ public:
 class ConcreteScene2 : public Scene {
 public:
 	void load_scene() {
-		ComponentManager & mgr = this->component_manager;
+		Mediator & mediator = this->mediator;
+		ComponentManager & mgr = mediator.component_manager;
 		GameObject object1 = mgr.new_object("scene_2", "tag_scene_2", vec2{0, 0}, 0, 1);
 		GameObject object2 = mgr.new_object("scene_2", "tag_scene_2", vec2{0, 1}, 0, 1);
 		GameObject object3 = mgr.new_object("scene_2", "tag_scene_2", vec2{0, 2}, 0, 1);
@@ -41,7 +44,8 @@ public:
 	ConcreteScene3(const string & name) : name(name) {}
 
 	void load_scene() {
-		ComponentManager & mgr = this->component_manager;
+		Mediator & mediator = this->mediator;
+		ComponentManager & mgr = mediator.component_manager;
 		GameObject object1 = mgr.new_object("scene_3", "tag_scene_3", vec2{0, 0}, 0, 1);
 	}
 
@@ -52,9 +56,11 @@ private:
 };
 
 class SceneManagerTest : public ::testing::Test {
+	Mediator m;
+
 public:
-	ComponentManager component_mgr{};
-	SceneManager scene_mgr{component_mgr};
+	ComponentManager component_mgr{m};
+	SceneManager scene_mgr{m};
 };
 
 TEST_F(SceneManagerTest, loadScene) {
diff --git a/src/test/ScriptEventTest.cpp b/src/test/ScriptEventTest.cpp
new file mode 100644
index 0000000..5da31e7
--- /dev/null
+++ b/src/test/ScriptEventTest.cpp
@@ -0,0 +1,50 @@
+#include <gtest/gtest.h>
+
+// stupid hack to allow access to private/protected members under test
+#define private public
+#define protected public
+
+#include <crepe/api/BehaviorScript.h>
+#include <crepe/api/Event.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Vector2.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/EventManager.h>
+#include <crepe/system/ScriptSystem.h>
+
+#include "ScriptTest.h"
+
+using namespace std;
+using namespace crepe;
+using namespace testing;
+
+class ScriptEventTest : public ScriptTest {
+public:
+	EventManager & event_manager = mediator.event_manager;
+
+	class MyEvent : public Event {};
+};
+
+TEST_F(ScriptEventTest, Inactive) {
+	BehaviorScript & behaviorscript = this->behaviorscript;
+	MyScript & script = this->script;
+	EventManager & evmgr = this->event_manager;
+
+	unsigned event_count = 0;
+	script.subscribe<MyEvent>([&](const MyEvent &) {
+		event_count++;
+		return true;
+	});
+
+	system.update();
+	behaviorscript.active = false;
+	EXPECT_EQ(0, event_count);
+
+	evmgr.trigger_event<MyEvent>();
+	EXPECT_EQ(0, event_count);
+
+	behaviorscript.active = true;
+	evmgr.trigger_event<MyEvent>();
+	EXPECT_EQ(1, event_count);
+}
diff --git a/src/test/ScriptSceneTest.cpp b/src/test/ScriptSceneTest.cpp
new file mode 100644
index 0000000..9ee1e52
--- /dev/null
+++ b/src/test/ScriptSceneTest.cpp
@@ -0,0 +1,30 @@
+#include <gtest/gtest.h>
+
+// stupid hack to allow access to private/protected members under test
+#define private public
+#define protected public
+
+#include "ScriptTest.h"
+#include <crepe/manager/SceneManager.h>
+
+using namespace std;
+using namespace crepe;
+using namespace testing;
+
+class ScriptSceneTest : public ScriptTest {
+public:
+	SceneManager scene_manager{mediator};
+
+	class MyScene : public Scene {};
+};
+
+TEST_F(ScriptSceneTest, Inactive) {
+	BehaviorScript & behaviorscript = this->behaviorscript;
+	MyScript & script = this->script;
+
+	const char * non_default_value = "foo";
+	ASSERT_NE(non_default_value, scene_manager.next_scene);
+
+	script.set_next_scene(non_default_value);
+	EXPECT_EQ(non_default_value, scene_manager.next_scene);
+}
diff --git a/src/test/ScriptTest.cpp b/src/test/ScriptTest.cpp
index 78d5061..1d2d6dd 100644
--- a/src/test/ScriptTest.cpp
+++ b/src/test/ScriptTest.cpp
@@ -1,129 +1,77 @@
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 // stupid hack to allow access to private/protected members under test
 #define private public
 #define protected public
 
-#include <crepe/ComponentManager.h>
-#include <crepe/api/BehaviorScript.h>
-#include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
+#include "ScriptTest.h"
 #include <crepe/api/GameObject.h>
-#include <crepe/api/Script.h>
-#include <crepe/api/Vector2.h>
-#include <crepe/system/ScriptSystem.h>
 
 using namespace std;
 using namespace crepe;
 using namespace testing;
 
-class MyEvent : public Event {};
-
-class ScriptTest : public Test {
-public:
-	ComponentManager component_manager{};
-	ScriptSystem system{component_manager};
-	EventManager & event_manager = EventManager::get_instance();
-
-	class MyScript : public Script {
-		// NOTE: default (private) visibility of init and update shouldn't cause
-		// issues!
-		void init() {
-			this->init_count++;
-
-			subscribe<MyEvent>([this](const MyEvent &) {
-				this->event_count++;
-				return true;
-			});
-
-			// init should never be called more than once
-			EXPECT_LE(this->init_count, 1);
-		}
-		void update() { this->update_count++; }
-
-	public:
-		unsigned init_count = 0;
-		unsigned update_count = 0;
-		unsigned event_count = 0;
-	};
-
-	OptionalRef<BehaviorScript> behaviorscript;
-	OptionalRef<MyScript> script;
-
-	void SetUp() override {
-		auto & mgr = this->component_manager;
-		GameObject entity = mgr.new_object("name");
-		BehaviorScript & component = entity.add_component<BehaviorScript>();
-
-		this->behaviorscript = component;
-		ASSERT_TRUE(this->behaviorscript);
-		EXPECT_EQ(component.script.get(), nullptr);
-		component.set_script<MyScript>();
-		ASSERT_NE(component.script.get(), nullptr);
-
-		this->script = *(MyScript *) component.script.get();
-		ASSERT_TRUE(this->script);
-
-		// sanity
-		MyScript & script = this->script;
-		ASSERT_EQ(script.init_count, 0);
-		ASSERT_EQ(script.update_count, 0);
-		ASSERT_EQ(script.event_count, 0);
-	}
-};
+void ScriptTest::SetUp() {
+	auto & mgr = this->component_manager;
+	GameObject entity = mgr.new_object("name");
+	BehaviorScript & component = entity.add_component<BehaviorScript>();
+
+	this->behaviorscript = component;
+	ASSERT_TRUE(this->behaviorscript);
+	EXPECT_EQ(component.script.get(), nullptr);
+	component.set_script<NiceMock<MyScript>>();
+	ASSERT_NE(component.script.get(), nullptr);
+
+	this->script = *(MyScript *) component.script.get();
+	ASSERT_TRUE(this->script);
+}
 
 TEST_F(ScriptTest, Default) {
 	MyScript & script = this->script;
-	EXPECT_EQ(0, script.init_count);
-	EXPECT_EQ(0, script.update_count);
-	EXPECT_EQ(0, script.event_count);
+	EXPECT_CALL(script, init()).Times(0);
+	EXPECT_CALL(script, update()).Times(0);
 }
 
 TEST_F(ScriptTest, UpdateOnce) {
 	MyScript & script = this->script;
 
-	system.update();
-	EXPECT_EQ(1, script.init_count);
-	EXPECT_EQ(1, script.update_count);
-	EXPECT_EQ(0, script.event_count);
+	{
+		InSequence seq;
+
+		EXPECT_CALL(script, init()).Times(1);
+		EXPECT_CALL(script, update()).Times(1);
+		system.update();
+	}
+
+	{
+		InSequence seq;
+
+		EXPECT_CALL(script, init()).Times(0);
+		EXPECT_CALL(script, update()).Times(1);
+		system.update();
+	}
 }
 
 TEST_F(ScriptTest, UpdateInactive) {
 	BehaviorScript & behaviorscript = this->behaviorscript;
 	MyScript & script = this->script;
 
-	behaviorscript.active = false;
-	system.update();
-	EXPECT_EQ(0, script.init_count);
-	EXPECT_EQ(0, script.update_count);
-	EXPECT_EQ(0, script.event_count);
-
-	behaviorscript.active = true;
-	system.update();
-	EXPECT_EQ(1, script.init_count);
-	EXPECT_EQ(1, script.update_count);
-	EXPECT_EQ(0, script.event_count);
-}
+	{
+		InSequence seq;
 
-TEST_F(ScriptTest, EventInactive) {
-	BehaviorScript & behaviorscript = this->behaviorscript;
-	MyScript & script = this->script;
-	EventManager & evmgr = this->event_manager;
-
-	system.update();
-	behaviorscript.active = false;
-	EXPECT_EQ(1, script.init_count);
-	EXPECT_EQ(1, script.update_count);
-	EXPECT_EQ(0, script.event_count);
-
-	evmgr.trigger_event<MyEvent>();
-	EXPECT_EQ(1, script.init_count);
-	EXPECT_EQ(1, script.update_count);
-	EXPECT_EQ(0, script.event_count);
-
-	behaviorscript.active = true;
-	evmgr.trigger_event<MyEvent>();
-	EXPECT_EQ(1, script.init_count);
-	EXPECT_EQ(1, script.update_count);
-	EXPECT_EQ(1, script.event_count);
+		EXPECT_CALL(script, init()).Times(0);
+		EXPECT_CALL(script, update()).Times(0);
+		behaviorscript.active = false;
+		system.update();
+	}
+
+	{
+		InSequence seq;
+
+		EXPECT_CALL(script, init()).Times(1);
+		EXPECT_CALL(script, update()).Times(1);
+		behaviorscript.active = true;
+		system.update();
+	}
 }
diff --git a/src/test/ScriptTest.h b/src/test/ScriptTest.h
new file mode 100644
index 0000000..1bbfdd3
--- /dev/null
+++ b/src/test/ScriptTest.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <crepe/api/BehaviorScript.h>
+#include <crepe/api/Script.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/system/ScriptSystem.h>
+
+class ScriptTest : public testing::Test {
+protected:
+	crepe::Mediator mediator;
+
+public:
+	crepe::ComponentManager component_manager{mediator};
+	crepe::ScriptSystem system{mediator};
+
+	class MyScript : public crepe::Script {
+		// NOTE: explicitly stating `public:` is not required on actual scripts
+
+	public:
+		MOCK_METHOD(void, init, (), (override));
+		MOCK_METHOD(void, update, (), (override));
+	};
+
+	crepe::OptionalRef<crepe::BehaviorScript> behaviorscript;
+	crepe::OptionalRef<MyScript> script;
+
+	virtual void SetUp();
+};