Merge branch 'jaro/collision-system' of github.com:lonkaars/crepe into max/AI

4 files changed, 641 insertions, 21 deletions

diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index e19d7de..a863598 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,18 +1,20 @@
 target_sources(test_main PUBLIC
 	main.cpp
-	PhysicsTest.cpp
-	ScriptTest.cpp
-	ParticleTest.cpp
-	AssetTest.cpp
-	OptionalRefTest.cpp
-	RenderSystemTest.cpp
-	EventTest.cpp
-	ECSTest.cpp
-	SceneManagerTest.cpp
-	ValueBrokerTest.cpp
-	DBTest.cpp
-	Vector2Test.cpp
-	InputTest.cpp
-	ScriptEventTest.cpp
-	ScriptSceneTest.cpp
+	CollisionTest.cpp
+	# PhysicsTest.cpp
+	# ScriptTest.cpp
+	# ParticleTest.cpp
+	# AssetTest.cpp
+	# OptionalRefTest.cpp
+	# RenderSystemTest.cpp
+	# EventTest.cpp
+	# ECSTest.cpp
+	# SceneManagerTest.cpp
+	# 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
new file mode 100644
index 0000000..a683b1f
--- /dev/null
+++ b/src/test/CollisionTest.cpp
@@ -0,0 +1,390 @@
+#include "api/BoxCollider.h"
+#include "manager/Mediator.h"
+#include <cmath>
+#include <cstddef>
+#include <gtest/gtest.h>
+
+#define private public
+#define protected public
+
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/Mediator.h>
+#include <crepe/api/Event.h>
+#include <crepe/manager/EventManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Transform.h>
+#include <crepe/system/CollisionSystem.h>
+#include <crepe/system/ScriptSystem.h>
+#include <crepe/types.h>
+#include <crepe/util/Log.h>
+
+using namespace std;
+using namespace std::chrono_literals;
+using namespace crepe;
+using namespace testing;
+
+class CollisionHandler : public Script {
+public:
+	int box_id;
+	function<void(const CollisionEvent & ev)> test_fn = [](const CollisionEvent & ev) {};
+
+	CollisionHandler(int box_id) { this->box_id = box_id; }
+
+	bool on_collision(const CollisionEvent & ev) {
+		//Log::logf("Box {} script on_collision()", box_id);
+		test_fn(ev);
+		return true;
+	}
+
+	void init() {
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->on_collision(ev); });
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+	}
+};
+
+class CollisionTest : public Test {
+public:
+	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});
+	GameObject game_object2 = mgr.new_object("object2", "", {50, 30});
+
+	CollisionHandler * script_object1_ref = nullptr;
+	CollisionHandler * script_object2_ref = nullptr;
+
+	void SetUp() override {
+		world.add_component<Rigidbody>(Rigidbody::Data{
+			// TODO: remove unrelated properties:
+			.body_type = Rigidbody::BodyType::STATIC,
+			.offset = {0, 0},
+		});
+		// Create a box with an inner size of 10x10 units
+		world.add_component<BoxCollider>(vec2{0, -100}, vec2{100, 100}); // Top
+		world.add_component<BoxCollider>(vec2{0, 100}, vec2{100, 100}); // Bottom
+		world.add_component<BoxCollider>(vec2{-100, 0}, vec2{100, 100}); // Left
+		world.add_component<BoxCollider>(vec2{100, 0}, vec2{100, 100}); // right
+
+		game_object1.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {0, 0},
+			.constraints = {0, 0, 0},
+			.elastisity_coefficient = 1,
+			.offset = {0, 0},
+			.collision_layers = {0},
+		});
+		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
+		BehaviorScript & script_object1
+			= game_object1.add_component<BehaviorScript>().set_script<CollisionHandler>(1);
+		script_object1_ref = static_cast<CollisionHandler *>(script_object1.script.get());
+		ASSERT_NE(script_object1_ref, nullptr);
+
+		game_object2.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {0, 0},
+			.constraints = {0, 0, 0},
+			.elastisity_coefficient = 1,
+			.offset = {0, 0},
+			.collision_layers = {0},
+		});
+		game_object2.add_component<BoxCollider>(vec2{0, 0}, vec2{10, 10});
+		BehaviorScript & script_object2
+			= game_object2.add_component<BehaviorScript>().set_script<CollisionHandler>(2);
+		script_object2_ref = static_cast<CollisionHandler *>(script_object2.script.get());
+		ASSERT_NE(script_object2_ref, nullptr);
+
+		// Ensure Script::init() is called on all BehaviorScript instances
+		script_sys.update();
+	}
+};
+
+TEST_F(CollisionTest, collision_example) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+	};
+	EXPECT_FALSE(collision_happend);
+	collision_sys.update();
+	EXPECT_FALSE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, 10);
+		EXPECT_EQ(ev.info.resolution.y, 10);
+		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 10);
+		EXPECT_EQ(ev.info.resolution.y, 10);
+		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 30};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, -5);
+		EXPECT_EQ(ev.info.resolution.y, 0);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 5);
+		EXPECT_EQ(ev.info.resolution.y, 0);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {45, 30};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, 0);
+		EXPECT_EQ(ev.info.resolution.y, -5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 0);
+		EXPECT_EQ(ev.info.resolution.y, 5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 25};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_both) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, 10);
+		EXPECT_EQ(ev.info.resolution.y, 10);
+		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 10);
+		EXPECT_EQ(ev.info.resolution.y, 10);
+		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 30};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.linear_velocity = {10, 10};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, -5);
+		EXPECT_EQ(ev.info.resolution.y, -5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 5);
+		EXPECT_EQ(ev.info.resolution.y, 5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {45, 30};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.linear_velocity = {10, 10};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, -5);
+		EXPECT_EQ(ev.info.resolution.y, -5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.resolution.x, 5);
+		EXPECT_EQ(ev.info.resolution.y, 5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 25};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.linear_velocity = {10, 10};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_static_both) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, 10);
+		EXPECT_EQ(ev.info.resolution.y, 10);
+		EXPECT_EQ(ev.info.resolution_direction, crepe::CollisionSystem::Direction::BOTH);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		// is static should not be called
+		FAIL();
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 30};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_static_x_direction) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, -5);
+		EXPECT_EQ(ev.info.resolution.y, -5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::X_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		// is static should not be called
+		FAIL();
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {45, 30};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_static_y_direction) {
+	bool collision_happend = false;
+	script_object1_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.resolution.x, -5);
+		EXPECT_EQ(ev.info.resolution.y, -5);
+		EXPECT_EQ(ev.info.resolution_direction,
+				  crepe::CollisionSystem::Direction::Y_DIRECTION);
+	};
+	script_object2_ref->test_fn = [&collision_happend](const CollisionEvent & ev) {
+		// is static should not be called
+		FAIL();
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {50, 25};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
+
+TEST_F(CollisionTest, collision_box_box_static_multiple) { //todo check visually
+	bool collision_happend = false;
+	float offset_value = 0;
+	float resolution = 0;
+	script_object1_ref->test_fn = [&](const CollisionEvent & ev) {
+		collision_happend = true;
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 1);
+		EXPECT_EQ(ev.info.this_collider.offset.x, offset_value);
+		EXPECT_EQ(ev.info.resolution.x, resolution);
+	};
+	script_object2_ref->test_fn = [&](const CollisionEvent & ev) {
+		// is static should not be called
+		FAIL();
+	};
+	EXPECT_FALSE(collision_happend);
+	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
+	tf.position = {45, 30};
+	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
+	rg1.data.linear_velocity = {10, 10};
+	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
+	rg2.data.body_type = crepe::Rigidbody::BodyType::STATIC;
+	BoxCollider & bxc = this->mgr.get_components_by_id<BoxCollider>(1).front().get();
+	bxc.offset = {5, 0};
+	this->game_object1.add_component<BoxCollider>(vec2{-5, 0}, vec2{10, 10});
+	offset_value = 5;
+	resolution = 10;
+	collision_sys.update();
+	offset_value = -5;
+	resolution = 10;
+	tf.position = {55, 30};
+	collision_sys.update();
+	EXPECT_TRUE(collision_happend);
+}
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index 43af8e4..43d2931 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -30,8 +30,6 @@ public:
 				.max_linear_velocity = vec2{10, 10},
 				.max_angular_velocity = 10,
 				.constraints = {0, 0},
-				.use_gravity = true,
-				.bounce = false,
 			});
 		}
 		transforms = mgr.get_components_by_id<Transform>(0);
@@ -107,16 +105,16 @@ TEST_F(PhysicsTest, movement) {
 	EXPECT_EQ(transform.position.y, 1);
 	EXPECT_EQ(transform.rotation, 1);
 
-	rigidbody.data.linear_damping.x = 0.5;
-	rigidbody.data.linear_damping.y = 0.5;
-	rigidbody.data.angular_damping = 0.5;
+	rigidbody.data.linear_velocity_coefficient.x = 0.5;
+	rigidbody.data.linear_velocity_coefficient.y = 0.5;
+	rigidbody.data.angular_velocity_coefficient = 0.5;
 	system.update();
 	EXPECT_EQ(rigidbody.data.linear_velocity.x, 0.5);
 	EXPECT_EQ(rigidbody.data.linear_velocity.y, 0.5);
 	EXPECT_EQ(rigidbody.data.angular_velocity, 0.5);
 
 	rigidbody.data.constraints = {1, 1, 0};
-	rigidbody.data.angular_damping = 0;
+	rigidbody.data.angular_velocity_coefficient = 0;
 	rigidbody.data.max_angular_velocity = 1000;
 	rigidbody.data.angular_velocity = 360;
 	system.update();
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
new file mode 100644
index 0000000..91be769
--- /dev/null
+++ b/src/test/Profiling.cpp
@@ -0,0 +1,230 @@
+#include "manager/Mediator.h"
+#include "system/ParticleSystem.h"
+#include "system/PhysicsSystem.h"
+#include "system/RenderSystem.h"
+#include <chrono>
+#include <cmath>
+#include <gtest/gtest.h>
+
+#define private public
+#define protected public
+
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/api/Event.h>
+#include <crepe/manager/EventManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/ParticleEmitter.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Transform.h>
+#include <crepe/system/CollisionSystem.h>
+#include <crepe/system/ScriptSystem.h>
+#include <crepe/types.h>
+#include <crepe/util/Log.h>
+
+using namespace std;
+using namespace std::chrono_literals;
+using namespace crepe;
+using namespace testing;
+
+class TestScript : public Script {
+	bool oncollision(const CollisionEvent & test) {
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
+		return true;
+	}
+	void init() {
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+	}
+};
+
+class Profiling : public Test {
+public:
+	// Config for test
+	// Minimum amount to let test pass
+	const int min_gameobject_count = 100;
+	// Maximum amount to stop test
+	const int max_gameobject_count = 150;
+	// Amount of times a test runs to calculate average
+	const int average = 5;
+	// Maximum duration to stop test
+	const std::chrono::microseconds duration = 16000us;
+
+	Mediator m;
+	ComponentManager mgr{m};
+	// Add system used for profling tests
+	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;
+	int game_object_count = 0;
+	std::chrono::microseconds total_time = 0us;
+
+	void SetUp() override {
+
+		GameObject do_not_use = mgr.new_object("DO_NOT_USE", "", {0, 0});
+		do_not_use.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000},
+										 1.0f);
+		// initialize systems here:
+		//calls init
+		script_sys.update();
+		//creates window
+		render_sys.update();
+	}
+
+	// Helper function to time an update call and store its duration
+	template <typename Func>
+	std::chrono::microseconds time_function(const std::string & name, Func && func) {
+		auto start = std::chrono::steady_clock::now();
+		func();
+		auto end = std::chrono::steady_clock::now();
+		std::chrono::microseconds duration
+			= std::chrono::duration_cast<std::chrono::microseconds>(end - start);
+		timings[name] += duration;
+		return duration;
+	}
+
+	// Run and profile all systems, return the total time in milliseconds
+	std::chrono::microseconds run_all_systems() {
+		std::chrono::microseconds total_microseconds = 0us;
+		total_microseconds += time_function("PhysicsSystem", [&]() { physics_sys.update(); });
+		total_microseconds
+			+= time_function("CollisionSystem", [&]() { collision_sys.update(); });
+		total_microseconds
+			+= time_function("ParticleSystem", [&]() { particle_sys.update(); });
+		total_microseconds += time_function("RenderSystem", [&]() { render_sys.update(); });
+		return total_microseconds;
+	}
+
+	// Print timings of all functions
+	void log_timings() const {
+		std::string result = "\nFunction timings:\n";
+
+		for (const auto & [name, duration] : timings) {
+			result += name + " took " + std::to_string(duration.count() / 1000.0 / average)
+					  + " ms (" + std::to_string(duration.count() / average) + " µs).\n";
+		}
+
+		result += "Total time: " + std::to_string(this->total_time.count() / 1000.0 / average)
+				  + " ms (" + std::to_string(this->total_time.count() / average) + " µs)\n";
+
+		result += "Amount of gameobjects: " + std::to_string(game_object_count) + "\n";
+
+		GTEST_LOG_(INFO) << result;
+	}
+
+	void clear_timings() {
+		for (auto & [key, value] : timings) {
+			value = std::chrono::microseconds(0);
+		}
+	}
+};
+
+TEST_F(Profiling, Profiling_1) {
+	while (this->total_time / this->average < this->duration) {
+
+		{
+			//define gameobject used for testing
+			GameObject gameobject = mgr.new_object("gameobject", "", {0, 0});
+		}
+
+		this->game_object_count++;
+
+		this->total_time = 0us;
+		clear_timings();
+
+		for (int amount = 0; amount < this->average; amount++) {
+			this->total_time += run_all_systems();
+		}
+
+		if (this->game_object_count >= this->max_gameobject_count) break;
+	}
+	log_timings();
+	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
+}
+
+TEST_F(Profiling, Profiling_2) {
+	while (this->total_time / this->average < this->duration) {
+
+		{
+			//define gameobject used for testing
+			GameObject gameobject = mgr.new_object(
+				"gameobject", "", {static_cast<float>(game_object_count * 2), 0});
+			gameobject.add_component<Rigidbody>(Rigidbody::Data{
+				.gravity_scale = 0.0,
+				.body_type = Rigidbody::BodyType::STATIC,
+			});
+			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");
+			Sprite & test_sprite = gameobject.add_component<Sprite>(
+				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+		}
+
+		this->game_object_count++;
+
+		this->total_time = 0us;
+		clear_timings();
+		for (int amount = 0; amount < this->average; amount++) {
+			this->total_time += run_all_systems();
+		}
+
+		if (this->game_object_count >= this->max_gameobject_count) break;
+	}
+	log_timings();
+	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
+}
+
+TEST_F(Profiling, Profiling_3) {
+	while (this->total_time / this->average < this->duration) {
+
+		{
+			//define gameobject used for testing
+			GameObject gameobject = mgr.new_object(
+				"gameobject", "", {static_cast<float>(game_object_count * 2), 0});
+			gameobject.add_component<Rigidbody>(Rigidbody::Data{
+				.gravity_scale = 0,
+				.body_type = Rigidbody::BodyType::STATIC,
+			});
+			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");
+			Sprite & test_sprite = gameobject.add_component<Sprite>(
+				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+			auto & test = gameobject.add_component<ParticleEmitter>(ParticleEmitter::Data{
+				.max_particles = 10,
+				.emission_rate = 100,
+				.end_lifespan = 100000,
+				.boundary{
+					.width = 1000,
+					.height = 1000,
+					.offset = vec2{0, 0},
+					.reset_on_exit = false,
+				},
+				.sprite = test_sprite,
+			});
+		}
+		render_sys.update();
+		this->game_object_count++;
+
+		this->total_time = 0us;
+		clear_timings();
+		for (int amount = 0; amount < this->average; amount++) {
+			this->total_time += run_all_systems();
+		}
+
+		if (this->game_object_count >= this->max_gameobject_count) break;
+	}
+	log_timings();
+	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
+}