From 47dd27c42f375b65ee53f8b1e8c1b25327315a92 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 10 Nov 2024 21:38:58 +0100
Subject: box-box collision

---
 src/example/CMakeLists.txt |  1 +
 src/example/collision.cpp  | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)
 create mode 100644 src/example/collision.cpp

(limited to 'src/example')

diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 36f9d4d..d43d56c 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -28,4 +28,5 @@ add_example(proxy)
 add_example(db)
 add_example(ecs)
 add_example(scene_manager)
+add_example(collision)
 
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
new file mode 100644
index 0000000..9faac69
--- /dev/null
+++ b/src/example/collision.cpp
@@ -0,0 +1,42 @@
+#include "api/BoxCollider.h"
+#include "system/CollisionSystem.h"
+#include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/BoxCollider.h>
+#include <crepe/api/Transform.h>
+#include <crepe/system/PhysicsSystem.h>
+
+using namespace crepe;
+using namespace std;
+
+int main(int argc, char * argv[]) {
+
+	GameObject game_object1(0, "Name", "Tag", Vector2{1, 1}, 90, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 1,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = false,
+		.offset = {3,3}
+	});
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 100, 50);
+
+	GameObject game_object2(1, "Name", "Tag", Vector2{20, 2}, 90, 1);
+	game_object2.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 1,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = false,
+		.offset = {4,4}
+	});
+	game_object2.add_component<BoxCollider>(Vector2{6, 6}, 100, 50);
+	CollisionSystem coltest;
+	coltest.update();
+	return 0;
+}
-- 
cgit v1.2.3


From f2e5b685fd1357b55beeea967b12b353c5d65fb5 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 11 Nov 2024 20:49:55 +0100
Subject: fixed build issue

---
 src/crepe/api/Vector2.cpp | 10 +++++++---
 src/crepe/api/Vector2.h   | 13 ++++++++-----
 src/example/collision.cpp | 12 ++++++------
 3 files changed, 21 insertions(+), 14 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Vector2.cpp b/src/crepe/api/Vector2.cpp
index 09bb59b..947c49e 100644
--- a/src/crepe/api/Vector2.cpp
+++ b/src/crepe/api/Vector2.cpp
@@ -3,7 +3,7 @@
 namespace crepe {
 
 // Constructor with initial values
-Vector2::Vector2(float x, float y) : x(x), y(y) {}
+Vector2::Vector2(double x, double y) : x(x), y(y) {}
 
 // Subtracts another vector from this vector and returns the result.
 Vector2 Vector2::operator-(const Vector2 & other) const {
@@ -16,7 +16,7 @@ Vector2 Vector2::operator+(const Vector2 & other) const {
 }
 
 // Multiplies this vector by a scalar and returns the result.
-Vector2 Vector2::operator*(float scalar) const {
+Vector2 Vector2::operator*(double scalar) const {
 	return {x * scalar, y * scalar};
 }
 
@@ -35,7 +35,7 @@ Vector2 & Vector2::operator+=(const Vector2 & other) {
 }
 
 // Adds a scalar value to both components of this vector and updates this vector.
-Vector2 & Vector2::operator+=(float other) {
+Vector2 & Vector2::operator+=(double other) {
 	x += other;
 	y += other;
 	return *this;
@@ -54,4 +54,8 @@ bool Vector2::operator!=(const Vector2 & other) const {
 	return !(*this == other);
 }
 
+double Vector2::dot(const Vector2& other) const {
+	return this->x * other.x + this->y * other.y;
+}
+
 } // namespace crepe
diff --git a/src/crepe/api/Vector2.h b/src/crepe/api/Vector2.h
index 741951b..90d9d57 100644
--- a/src/crepe/api/Vector2.h
+++ b/src/crepe/api/Vector2.h
@@ -6,15 +6,15 @@ namespace crepe {
 class Vector2 {
 public:
 	//! X component of the vector
-	float x;
+	double x;
 	//! Y component of the vector
-	float y;
+	double y;
 
 	//! Default constructor
 	Vector2() = default;
 
 	//! Constructor with initial values
-	Vector2(float x, float y);
+	Vector2(double x, double y);
 
 	//! Subtracts another vector from this vector and returns the result.
 	Vector2 operator-(const Vector2 & other) const;
@@ -23,7 +23,7 @@ public:
 	Vector2 operator+(const Vector2 & other) const;
 
 	//! Multiplies this vector by a scalar and returns the result.
-	Vector2 operator*(float scalar) const;
+	Vector2 operator*(double scalar) const;
 
 	//! Multiplies this vector by another vector element-wise and updates this vector.
 	Vector2 & operator*=(const Vector2 & other);
@@ -32,7 +32,7 @@ public:
 	Vector2 & operator+=(const Vector2 & other);
 
 	//! Adds a scalar value to both components of this vector and updates this vector.
-	Vector2 & operator+=(float other);
+	Vector2 & operator+=(double other);
 
 	//! Returns the negation of this vector.
 	Vector2 operator-() const;
@@ -42,6 +42,9 @@ public:
 
 	//! Checks if this vector is not equal to another vector.
 	bool operator!=(const Vector2 & other) const;
+
+	//!
+	double dot(const Vector2& other) const;
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 9faac69..dc97c81 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -13,7 +13,7 @@ using namespace std;
 
 int main(int argc, char * argv[]) {
 
-	GameObject game_object1(0, "Name", "Tag", Vector2{1, 1}, 90, 1);
+	GameObject game_object1(0, "Name", "Tag", Vector2{10, 10}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -21,11 +21,11 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = false,
-		.offset = {3,3}
+		.offset = {0,0}
 	});
-	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 100, 50);
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{20, 2}, 90, 1);
+	GameObject game_object2(1, "Name", "Tag", Vector2{20, 0}, 90, 1);
 	game_object2.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -33,9 +33,9 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = false,
-		.offset = {4,4}
+		.offset = {0,0}
 	});
-	game_object2.add_component<BoxCollider>(Vector2{6, 6}, 100, 50);
+	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
 	CollisionSystem coltest;
 	coltest.update();
 	return 0;
-- 
cgit v1.2.3


From 73127fd15a3b074cb3c964da448b6bb3d237ee73 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 12 Nov 2024 16:09:43 +0100
Subject: added collision methodes

---
 src/crepe/system/CollisionSystem.cpp | 156 ++++++++++++++++++++++++++---------
 src/crepe/system/CollisionSystem.h   |   7 +-
 src/example/collision.cpp            |  26 ++++++
 3 files changed, 147 insertions(+), 42 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 75d5c58..71bca6b 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,4 +1,6 @@
 #include <cmath>
+#include <algorithm>
+#include <cstddef>
 
 #include "CollisionSystem.h"
 
@@ -19,48 +21,55 @@ CollisionSystem::CollisionSystem() {}
 void CollisionSystem::update() {
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
-	
-	Transform & transform1 = mgr.get_components_by_id<Transform>(boxcolliders[0].get().game_object_id).front().get();
-	Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(boxcolliders[0].get().game_object_id).front().get();
-	Transform & transform2 = mgr.get_components_by_id<Transform>(boxcolliders[1].get().game_object_id).front().get();
-	Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(boxcolliders[1].get().game_object_id).front().get();
-	BoxCollider & collider1 = boxcolliders[0].get();
-	BoxCollider & collider2 = boxcolliders[1].get();
-	bool test = check_box_box_collision(collider1, collider2, transform1, transform2, rigidbody1, rigidbody2);
-	std::cout << "collided? " << test << std::endl;
+	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+	check_collisions(boxcolliders,circlecolliders);
 }
 
+void CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
+		ComponentManager & mgr = ComponentManager::get_instance();
+	//if no colliders skip
+	//check if colliders has rigibocdy if not skip
+
+	//if amount is higer than lets say 16 for now use quadtree otwerwise skip
+	//quadtree code
+	//quadtree is placed over the input vector
+
+	//check collision
+	for (size_t i = 0; i < boxcolliders.size(); ++i) {
+		for (size_t j = i + 1; j < boxcolliders.size(); ++j) {
+			if(boxcolliders[i].get().game_object_id == boxcolliders[j].get().game_object_id){continue;}
+			Transform & transform1 = mgr.get_components_by_id<Transform>(boxcolliders[i].get().game_object_id).front().get();
+			Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(boxcolliders[i].get().game_object_id).front().get();
+			Transform & transform2 = mgr.get_components_by_id<Transform>(boxcolliders[j].get().game_object_id).front().get();
+			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(boxcolliders[j].get().game_object_id).front().get();
+			check_box_box_collision(boxcolliders[i], boxcolliders[j], transform1, transform2, rigidbody1, rigidbody2);
+		}
+		for (size_t j = 0; j < circlecolliders.size(); ++j) {
+			if(boxcolliders[i].get().game_object_id == circlecolliders[j].get().game_object_id){continue;}
+			Transform & transform1 = mgr.get_components_by_id<Transform>(boxcolliders[i].get().game_object_id).front().get();
+			Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(boxcolliders[i].get().game_object_id).front().get();
+			Transform & transform2 = mgr.get_components_by_id<Transform>(circlecolliders[j].get().game_object_id).front().get();
+			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(circlecolliders[j].get().game_object_id).front().get();
+			check_box_circle_collision(boxcolliders[i], circlecolliders[j], transform1, transform2, rigidbody1, rigidbody2);
+		}
+	}
+	for (size_t i = 0; i < circlecolliders.size(); ++i) {
+		for (size_t j = i + 1; j < circlecolliders.size(); ++j) {
+			if(circlecolliders[i].get().game_object_id == circlecolliders[j].get().game_object_id){continue;}
+			Transform & transform1 = mgr.get_components_by_id<Transform>(circlecolliders[i].get().game_object_id).front().get();
+			Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(circlecolliders[i].get().game_object_id).front().get();
+			Transform & transform2 = mgr.get_components_by_id<Transform>(circlecolliders[j].get().game_object_id).front().get();
+			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(circlecolliders[j].get().game_object_id).front().get();
+			check_circle_circle_collision(circlecolliders[i], circlecolliders[j], transform1, transform2, rigidbody1, rigidbody2);
+		}
+	}
+}
 
-
-bool CollisionSystem::check_collisions(const std::vector<Collider*>& colliders1, const std::vector<Collider*>& colliders2) {}
 bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2)
 {
-	// Function to convert degrees to radians
-	auto degrees_to_radians = [](double degrees) {
-			return degrees * (M_PI / 180.0);
-	};
-
-	// Get the rotation in radians
-	double radians1 = degrees_to_radians(transform1.rotation);
-	double radians2 = degrees_to_radians(transform2.rotation);
-
-	// Calculate the scale factor (for both rigidbody and box offsets)
-	double scale1 = transform1.scale;
-	double scale2 = transform2.scale;
-
-	Vector2 total_offset1 = (rigidbody1.data.offset + box1.offset) * transform1.scale;
-	Vector2 total_offset2 = (rigidbody2.data.offset + box2.offset) * transform2.scale;
-
-	// Rotate
-	double rotated_total_offset_x1 = total_offset1.x * cos(radians1) - total_offset1.y * sin(radians1);
-	double rotated_total_offset_y1 = total_offset1.x * sin(radians1) + total_offset1.y * cos(radians1);
-
-	double rotated_total_offset_x2 = total_offset2.x * cos(radians2) - total_offset2.y * sin(radians2);
-	double rotated_total_offset_y2 = total_offset2.x * sin(radians2) + total_offset2.y * cos(radians2);
-
-	// Final positions considering scaling and rotation
-	Vector2 final_position1 = transform1.position + Vector2(rotated_total_offset_x1, rotated_total_offset_y1);
-	Vector2 final_position2 = transform2.position + Vector2(rotated_total_offset_x2, rotated_total_offset_y2);
+	// Get current positions of colliders
+	Vector2 final_position1 = current_position(box1,transform1,rigidbody1);
+	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	 // Log final positions for debugging purposes
 	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
@@ -83,5 +92,74 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 						final_position1.y + half_height1 < final_position2.y - half_height2 || // box1 is above box2
 						final_position1.y - half_height1 > final_position2.y + half_height2);  // box1 is below box2
 }
-bool CollisionSystem::check_box_circle_collision(const BoxCollider& box, const CircleCollider& circle) {}
-bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2) {}
+
+bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
+	// Get current positions of colliders
+	Vector2 final_position1 = current_position(box1, transform1, rigidbody1);
+	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
+
+	// Log final positions for debugging purposes
+	std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+
+	// Calculate box half-extents
+	double half_width = box1.width / 2.0;
+	double half_height = box1.height / 2.0;
+
+	// Find the closest point on the box to the circle's center
+	double closest_x = std::clamp(final_position2.x, final_position1.x - half_width, final_position1.x + half_width);
+	double closest_y = std::clamp(final_position2.y, final_position1.y - half_height, final_position1.y + half_height);
+
+	// Calculate the distance squared between the circle's center and the closest point on the box
+	double distance_x = final_position2.x - closest_x;
+	double distance_y = final_position2.y - closest_y;
+	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+
+	// Compare distance squared with the square of the circle's radius
+	return distance_squared <= circle2.radius * circle2.radius;
+}
+
+bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
+	// Get current positions of colliders
+	Vector2 final_position1 = current_position(circle1,transform1,rigidbody1);
+	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
+
+	// Log final positions for debugging purposes
+	std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+
+	// Log rotation values for debugging (circles do not rotate, so this might not be needed for circles)
+	std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
+	std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
+
+	double distance_x = final_position1.x - final_position2.x;
+	double distance_y = final_position1.y - final_position2.y;
+	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+
+	// Calculate the sum of the radii
+	double radius_sum = circle1.radius + circle2.radius;
+
+	// Check if the distance between the centers is less than or equal to the sum of the radii
+	return distance_squared <= radius_sum * radius_sum;
+}
+
+Vector2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
+	// Function to convert degrees to radians
+	auto degrees_to_radians = [](double degrees) {
+			return degrees * (M_PI / 180.0);
+	};
+
+	// Get the rotation in radians
+	double radians1 = degrees_to_radians(transform.rotation);
+
+	// Calculate total offset with scale
+	Vector2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
+
+	// Rotate
+	double rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
+	double rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
+
+	// Final positions considering scaling and rotation
+	return(transform.position + Vector2(rotated_total_offset_x1, rotated_total_offset_y1));
+
+}
\ No newline at end of file
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 402ba64..a369ee9 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -16,10 +16,11 @@ public:
 	CollisionSystem();
 	void update();
 private:
-	bool check_collisions(const std::vector<Collider*>& colliders1, const std::vector<Collider*>& colliders2);
+  void check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) ;
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	bool check_box_circle_collision(const BoxCollider& box, const CircleCollider& circle);
-	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2);
+	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index dc97c81..e82b493 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -7,11 +7,24 @@
 #include <crepe/api/BoxCollider.h>
 #include <crepe/api/Transform.h>
 #include <crepe/system/PhysicsSystem.h>
+#include <crepe/system/RenderSystem.h>
+#include <crepe/util/log.h>
+
+#include <crepe/api/AssetManager.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
+
+#include <chrono>
+#include <memory>
 
 using namespace crepe;
 using namespace std;
 
 int main(int argc, char * argv[]) {
+	Color color(0, 0, 0, 0);
 
 	GameObject game_object1(0, "Name", "Tag", Vector2{10, 10}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
@@ -24,6 +37,10 @@ int main(int argc, char * argv[]) {
 		.offset = {0,0}
 	});
 	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	// game_object1.add_component<Sprite>(
+	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	// FlipSettings{true, true});
+	
 
 	GameObject game_object2(1, "Name", "Tag", Vector2{20, 0}, 90, 1);
 	game_object2.add_component<Rigidbody>(Rigidbody::Data{
@@ -36,7 +53,16 @@ int main(int argc, char * argv[]) {
 		.offset = {0,0}
 	});
 	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	// game_object2.add_component<Sprite>(
+	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	// FlipSettings{true, true});
+
 	CollisionSystem coltest;
 	coltest.update();
+	// auto & sys = crepe::RenderSystem::get_instance();
+	// auto start = std::chrono::steady_clock::now();
+	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
+	// 	sys.update();
+	// }
 	return 0;
 }
-- 
cgit v1.2.3


From b019b401c3a1de0ffea7e6776242ae73599651ef Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 15 Nov 2024 16:10:45 +0100
Subject: collision handeling example

---
 src/crepe/api/Event.h                |  1 -
 src/crepe/api/Rigidbody.h            |  5 +++--
 src/crepe/api/Script.h               |  2 +-
 src/crepe/system/CollisionSystem.cpp |  2 +-
 src/crepe/system/CollisionSystem.h   |  2 +-
 src/crepe/system/ScriptSystem.cpp    |  6 +++++-
 src/example/collision.cpp            | 39 ++++++++++++++++++++++++++++++++----
 7 files changed, 46 insertions(+), 11 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 3431f29..bd6a541 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -49,7 +49,6 @@ public:
 	crepe::CollisionSystem::CollisionInfo info;
 	CollisionEvent(const crepe::CollisionSystem::CollisionInfo& collisionInfo)
         : info(collisionInfo) {}
-
 };
 class TextSubmitEvent : public Event {
 public:
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b9edec2..a45623f 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <cmath>
 #include <cstdint>
 
 #include "../Component.h"
@@ -60,13 +61,13 @@ public:
 		//! linear velocity of object
 		Vector2 linear_velocity;
 		//! maximum linear velocity of object
-		Vector2 max_linear_velocity;
+		Vector2 max_linear_velocity = {INFINITY ,INFINITY};
 		//! linear damping of object
 		Vector2 linear_damping;
 		//! angular velocity of object
 		double angular_velocity = 0.0;
 		//! max angular velocity of object
-		double max_angular_velocity = 0.0;
+		double max_angular_velocity = INFINITY;
 		//! angular damping of object
 		double angular_damping = 0.0;
 		//! movements constraints of object
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 49e625f..0a10848 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -28,7 +28,7 @@ protected:
 	template <typename T>
 	std::vector<std::reference_wrapper<T>> get_components();
 
-private:
+public:
 	friend class crepe::BehaviorScript;
 	BehaviorScript * parent = nullptr;
 };
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 56f07cc..b9366df 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -93,7 +93,7 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
             { *collider2, data2.transform, data2.rigidbody }
         };
 		CollisionEvent data(collision_info);
-		EventManager::get_instance().trigger_event<CollisionEvent>(data, 0);
+		EventManager::get_instance().trigger_event<CollisionEvent>(data, first);
 	}		
 }
 
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index c7e8e0b..a31ac48 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -27,7 +27,7 @@ public:
 	void update();
 private:
 	void call_collision_handler(const CollidedInfoStor& data1,const CollidedInfoStor& data2);
-  std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+  	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
diff --git a/src/crepe/system/ScriptSystem.cpp b/src/crepe/system/ScriptSystem.cpp
index f2673e7..e41961e 100644
--- a/src/crepe/system/ScriptSystem.cpp
+++ b/src/crepe/system/ScriptSystem.cpp
@@ -17,7 +17,11 @@ void ScriptSystem::update() {
 	dbg_trace();
 
 	forward_list<Script *> scripts = this->get_scripts();
-	for (Script * script : scripts) script->update();
+	for (Script * script : scripts) 
+	{
+		script->init();
+		script->update();
+	};
 }
 
 forward_list<Script *> ScriptSystem::get_scripts() {
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index e82b493..45ed0b0 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -1,5 +1,6 @@
 #include "api/BoxCollider.h"
 #include "system/CollisionSystem.h"
+#include <crepe/system/ScriptSystem.h>
 #include <crepe/Component.h>
 #include <crepe/ComponentManager.h>
 #include <crepe/api/GameObject.h>
@@ -10,12 +11,15 @@
 #include <crepe/system/RenderSystem.h>
 #include <crepe/util/log.h>
 
+#include <crepe/api/Script.h>
 #include <crepe/api/AssetManager.h>
 #include <crepe/api/Color.h>
 #include <crepe/api/Sprite.h>
 #include <crepe/api/Texture.h>
 #include <crepe/api/Transform.h>
 #include <crepe/api/Vector2.h>
+#include <crepe/api/Event.h>
+#include <crepe/api/EventManager.h>
 
 #include <chrono>
 #include <memory>
@@ -23,6 +27,22 @@
 using namespace crepe;
 using namespace std;
 
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->parent->game_object_id);
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
+	
+	
+};
+
 int main(int argc, char * argv[]) {
 	Color color(0, 0, 0, 0);
 
@@ -33,16 +53,19 @@ int main(int argc, char * argv[]) {
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
-		.bounce = false,
+		.bounce = true,
 		.offset = {0,0}
 	});
 	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+
 	// game_object1.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
 	
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{20, 0}, 90, 1);
+	GameObject game_object2(1, "Name", "Tag", Vector2{10, 10}, 0, 1);
 	game_object2.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
@@ -53,16 +76,24 @@ int main(int argc, char * argv[]) {
 		.offset = {0,0}
 	});
 	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
 
-	CollisionSystem coltest;
-	coltest.update();
+	
+	ScriptSystem sys;
+	// Update all scripts. This should result in MyScript::update being called
+	sys.update();
 	// auto & sys = crepe::RenderSystem::get_instance();
 	// auto start = std::chrono::steady_clock::now();
 	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
 	// 	sys.update();
 	// }
+	CollisionSystem coltest;
+	coltest.update();
+
+
+
 	return 0;
 }
-- 
cgit v1.2.3


From 876a2e2ba115f6f8afa45155c8c6ed90d10576de Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 15:34:32 +0100
Subject: added functionality to example and added pictures

---
 asset/texture/green_square.png       | Bin 0 -> 135 bytes
 asset/texture/red_square.png         | Bin 0 -> 135 bytes
 src/crepe/api/LoopManager.cpp        |  13 +++++--
 src/crepe/facade/SDLContext.cpp      |   4 +-
 src/crepe/system/CollisionSystem.cpp |  22 +++++------
 src/example/collision.cpp            |  72 ++++++++++++++++++++++-------------
 src/example/rendering.cpp            |   4 +-
 7 files changed, 70 insertions(+), 45 deletions(-)
 create mode 100755 asset/texture/green_square.png
 create mode 100755 asset/texture/red_square.png

(limited to 'src/example')

diff --git a/asset/texture/green_square.png b/asset/texture/green_square.png
new file mode 100755
index 0000000..7772c87
Binary files /dev/null and b/asset/texture/green_square.png differ
diff --git a/asset/texture/red_square.png b/asset/texture/red_square.png
new file mode 100755
index 0000000..6ffbbec
Binary files /dev/null and b/asset/texture/red_square.png differ
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 2e9823f..f9c5362 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -2,6 +2,8 @@
 #include "../facade/SDLContext.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
+#include "..//system/PhysicsSystem.h"
+#include "..//system/CollisionSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
@@ -18,7 +20,12 @@ void LoopManager::start() {
 }
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
-void LoopManager::fixed_update() {}
+void LoopManager::fixed_update() {
+	PhysicsSystem phys;
+	phys.update();
+	CollisionSystem col;
+	col.update();
+}
 
 void LoopManager::loop() {
 	LoopTimer & timer = LoopTimer::get_instance();
@@ -27,11 +34,11 @@ void LoopManager::loop() {
 	while (game_running) {
 		timer.update();
 
-		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
+		//while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
-		}
+		//}
 
 		this->update();
 		this->render();
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 236bf8c..274cd7a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -130,8 +130,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 	};
 
 	SDL_Rect dstrect = {
-		.x = static_cast<int>(adjusted_x),
-		.y = static_cast<int>(adjusted_y),
+		.x = static_cast<int>(adjusted_x/2),
+		.y = static_cast<int>(adjusted_y/2),
 		.w = static_cast<int>(adjusted_w),
 		.h = static_cast<int>(adjusted_h),
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index b9366df..d59539e 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -27,7 +27,7 @@ void CollisionSystem::update() {
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
-	std::cout << "DEBUG INFO" << std::endl;
+	// std::cout << "DEBUG INFO" << std::endl;
 	for (const auto& collision_pair : collided) {
 		call_collision_handler(collision_pair.first,collision_pair.second); // First collider
 		call_collision_handler(collision_pair.second,collision_pair.first); // First collider
@@ -202,12 +202,12 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	 // Log final positions for debugging purposes
-	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Log rotation values for debugging
-	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
 
 
 	// Calculate half-extents (half width and half height)
@@ -229,8 +229,8 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
 	// Log final positions for debugging purposes
-	std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Calculate box half-extents
 	double half_width = box1.width / 2.0;
@@ -256,12 +256,12 @@ bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle
 	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
 	// Log final positions for debugging purposes
-	std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	// std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Log rotation values for debugging (circles do not rotate, so this might not be needed for circles)
-	std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
+	// std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
 
 	double distance_x = final_position1.x - final_position2.x;
 	double distance_y = final_position1.y - final_position2.y;
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 45ed0b0..a1b22f0 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -20,6 +20,7 @@
 #include <crepe/api/Vector2.h>
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
+#include <crepe/api/LoopManager.h>
 
 #include <chrono>
 #include <memory>
@@ -44,55 +45,72 @@ class MyScript : public Script {
 };
 
 int main(int argc, char * argv[]) {
+	//setup
+	LoopManager gameloop;
 	Color color(0, 0, 0, 0);
 
-	GameObject game_object1(0, "Name", "Tag", Vector2{10, 10}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 1,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
+	//define playable world 
+	GameObject World(0, "Name", "Tag", Vector2{0, 0}, 0, 1);
+	World.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 0,
+		.gravity_scale = 0,
+		.body_type = Rigidbody::BodyType::STATIC,
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.offset = {0,0}
+		.use_gravity = false,
+		.bounce = false,
+		.offset = {320,240}
 	});
-	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	World.add_component<BoxCollider>(Vector2{0, -740}, 1000, 1000);	// Top
+	World.add_component<BoxCollider>(Vector2{0, 740}, 1000, 1000); // Bottom
+	World.add_component<BoxCollider>(Vector2{-820, 0}, 1000, 1000); // Left
+	World.add_component<BoxCollider>(Vector2{820, 0}, 1000, 1000); // right
 
-	// game_object1.add_component<Sprite>(
-	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
-	// FlipSettings{true, true});
-	
 
-	GameObject game_object2(1, "Name", "Tag", Vector2{10, 10}, 0, 1);
-	game_object2.add_component<Rigidbody>(Rigidbody::Data{
+	GameObject game_object1(1, "Name", "Tag", Vector2{320, 240}, 0, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
+		.use_gravity = false,
 		.bounce = false,
 		.offset = {0,0}
 	});
-	game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
-	game_object2.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<Sprite>(
+	make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	FlipSettings{true, true});
+	game_object1.add_component<Camera>(Color::get_white());
+	
+
+	// GameObject game_object2(2, "Name", "Tag", Vector2{10, 10}, 0, 1);
+	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
+	// 	.mass = 1,
+	// 	.gravity_scale = 1,
+	// 	.body_type = Rigidbody::BodyType::DYNAMIC,
+	// 	.constraints = {0, 0, 0},
+	// 	.use_gravity = false,
+	// 	.bounce = false,
+	// 	.offset = {0,0}
+	// });
+	// game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 	// FlipSettings{true, true});
-
 	
-	ScriptSystem sys;
+	
+	crepe::ScriptSystem sys;
 	// Update all scripts. This should result in MyScript::update being called
 	sys.update();
-	// auto & sys = crepe::RenderSystem::get_instance();
+	
+	gameloop.start();
+	// auto & render = crepe::RenderSystem::get_instance();
 	// auto start = std::chrono::steady_clock::now();
 	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-	// 	sys.update();
+	//	 render.update();
 	// }
-	CollisionSystem coltest;
-	coltest.update();
-
 
 
 	return 0;
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index 827ad07..813fd25 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -28,14 +28,14 @@ int main() {
 	{
 		Color color(0, 0, 0, 0);
 		obj.add_component<Sprite>(
-			make_shared<Texture>("../asset/texture/img.png"), color,
+			make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 			FlipSettings{false, false});
 		obj.add_component<Camera>(Color::get_red());
 	}
 	{
 		Color color(0, 0, 0, 0);
 		obj1.add_component<Sprite>(
-			make_shared<Texture>("../asset/texture/second.png"), color,
+			make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
 			FlipSettings{true, true});
 	}
 
-- 
cgit v1.2.3


From 9885c58817912125506de3b3555f3dc6206e0e6a Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 17:49:56 +0100
Subject: moved object after static collision

---
 src/crepe/system/CollisionSystem.cpp | 97 ++++++++++++++++++++++++++++++------
 src/crepe/system/CollisionSystem.h   | 37 ++++++++------
 src/example/collision.cpp            | 33 ++++++------
 3 files changed, 124 insertions(+), 43 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index d59539e..4b74e67 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -28,7 +28,7 @@ void CollisionSystem::update() {
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
 	// std::cout << "DEBUG INFO" << std::endl;
-	for (const auto& collision_pair : collided) {
+	for (auto& collision_pair : collided) {
 		call_collision_handler(collision_pair.first,collision_pair.second); // First collider
 		call_collision_handler(collision_pair.second,collision_pair.first); // First collider
 	}
@@ -38,9 +38,14 @@ void CollisionSystem::update() {
 	}
 }
 
-void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const CollidedInfoStor& data2){
+void CollisionSystem::call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
 	const Collider* collider1 = nullptr;
 	const Collider* collider2 = nullptr;
+	double height1 = 0,width1 = 0;
+	double height2 = 0,width2 = 0;
+	Vector2 final_position1;
+	Vector2 final_position2;
+	Vector2 temp;
 	// Check collision type and get values for handler
 	game_object_id_t first = 0,second = 0;
 	if (std::holds_alternative<BoxCollider>(data1.collider)) {
@@ -51,6 +56,38 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 			collider2 = &box_collider2;
 			first = box_collider1.game_object_id;
 			second = box_collider2.game_object_id;
+			height1 = box_collider1.height;
+			height2 = box_collider2.height;
+			width1 = box_collider1.width;
+			width2 = box_collider2.width;
+			final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
+			final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
+
+			Vector2 delta = final_position2 - final_position1;
+
+			double half_width1 = width1 / 2.0;
+			double half_height1 = height1 / 2.0;
+			double half_width2 = width2 / 2.0;
+			double half_height2 = height2 / 2.0;
+
+			// Compute overlap in X and Y directions
+			double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
+			double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
+
+			// Check if there is actually a collision
+			if (overlap_x > 0 && overlap_y > 0) {
+					// Resolve in the smallest overlap direction
+					if (overlap_x < overlap_y) {
+							// Resolve along X-axis
+							temp = {delta.x > 0 ? -overlap_x : overlap_x, 0};
+					} else {
+							// Resolve along Y-axis
+							temp = {0, delta.y > 0 ? -overlap_y : overlap_y};
+					}
+			}
+
+
+
 		}
 		else {
 			const BoxCollider& box_collider = std::get<BoxCollider>(data1.collider);
@@ -59,6 +96,10 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 			collider2 = &circle_collider;
 			first = box_collider.game_object_id;
 			second = circle_collider.game_object_id;
+			height1 = box_collider.height;
+			height2 = circle_collider.radius + circle_collider.radius;
+			width1 = box_collider.width;
+			width2 = circle_collider.radius + circle_collider.radius;
 		}
 	}
 	else {
@@ -69,6 +110,10 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 			collider2 = &circle_collider2;
 			first = circle_collider1.game_object_id;
 			second = circle_collider2.game_object_id;
+			height1 = circle_collider1.radius + circle_collider1.radius;
+			height2 = circle_collider2.radius + circle_collider2.radius;
+			width1 = circle_collider1.radius + circle_collider1.radius;
+			width2 = circle_collider2.radius + circle_collider2.radius;
 		}
 		else {
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data1.collider);
@@ -77,8 +122,17 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 			collider2 = &box_collider;
 			first = circle_collider.game_object_id;
 			second = box_collider.game_object_id;
+			height1 = circle_collider.radius + circle_collider.radius;
+			height2 = box_collider.height;
+			width1 = circle_collider.radius + circle_collider.radius;
+			width2 = box_collider.width;
 		}
 	}
+	crepe::CollisionSystem::CollisionInfo collision_info{
+            .first={ *collider1, data1.transform, data1.rigidbody },
+            .second={ *collider2, data2.transform, data2.rigidbody },
+						.move_back_value = temp,
+        };
 
 	// check rigidbody type
 	if(data1.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
@@ -86,17 +140,21 @@ void CollisionSystem::call_collision_handler(const CollidedInfoStor& data1,const
 		// If second body is static move back
 		if(data2.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
 			//call static handler (is bounce true?)
+			static_collision_handler(collision_info);
 		}; 
 		
-		crepe::CollisionSystem::CollisionInfo collision_info{
-            { *collider1, data1.transform, data1.rigidbody },
-            { *collider2, data2.transform, data2.rigidbody }
-        };
+		
 		CollisionEvent data(collision_info);
 		EventManager::get_instance().trigger_event<CollisionEvent>(data, first);
 	}		
 }
 
+void CollisionSystem::static_collision_handler(CollisionInfo& info){
+	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
+	info.first.transform.position += info.move_back_value;
+	info.first.rigidbody.data.linear_velocity = {0,0};
+}
+
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
@@ -202,12 +260,12 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	 // Log final positions for debugging purposes
-	// std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	// std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
+	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
+	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
 
 	// Log rotation values for debugging
-	// std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
-	// std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
+	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
+	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
 
 
 	// Calculate half-extents (half width and half height)
@@ -216,11 +274,22 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	double half_width2 = box2.width / 2.0;
 	double half_height2 = box2.height / 2.0;
 
+	std::cout << "half_width of Box 1: " << half_width1 << std::endl;
+	std::cout << "half_height of Box 2: " << half_height1 << std::endl;
+	std::cout << "half_width of Box 1: " << half_width2 << std::endl;
+	std::cout << "half_height of Box 2: " << half_height2 << std::endl;
+
+
+	std::cout << "final_position1.x + half_width1 < final_position2.x - half_width2 " << (final_position1.x + half_width1 < final_position2.x - half_width2) << std::endl;
+	std::cout << "final_position1.x - half_width1 > final_position2.x + half_width2 " << (final_position1.x - half_width1 > final_position2.x + half_width2) << std::endl;
+	std::cout << "final_position1.y + half_height1 < final_position2.y - half_height2 " << (final_position1.y + half_height1 < final_position2.y - half_height2) << std::endl;
+	std::cout << "final_position1.y - half_height1 > final_position2.y + half_height2 " << (final_position1.y - half_height1 > final_position2.y + half_height2) << std::endl;
+
 	// Check if the boxes overlap along the X and Y axes
-	return !(final_position1.x + half_width1 < final_position2.x - half_width2 ||  // box1 is left of box2
-						final_position1.x - half_width1 > final_position2.x + half_width2 ||  // box1 is right of box2
-						final_position1.y + half_height1 < final_position2.y - half_height2 || // box1 is above box2
-						final_position1.y - half_height1 > final_position2.y + half_height2);  // box1 is below box2
+	return !(final_position1.x + half_width1 <= final_position2.x - half_width2 ||  // box1 is left of box2
+						final_position1.x - half_width1 >= final_position2.x + half_width2 ||  // box1 is right of box2
+						final_position1.y + half_height1 <= final_position2.y - half_height2 || // box1 is above box2
+						final_position1.y - half_height1 >= final_position2.y + half_height2);  // box1 is below box2
 }
 
 bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index a31ac48..cfa599e 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -5,6 +5,7 @@
 #include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Vector2.h"
 #include <tuple>
 #include <vector>
 #include <variant>
@@ -19,29 +20,35 @@ private:
 	struct CollidedInfoStor {
 		//! Store either BoxCollider or CircleCollider
 		collider_stor collider; 
-		Transform transform;
-		Rigidbody rigidbody;      // Rigidbody data
+		Transform& transform;
+		Rigidbody& rigidbody;      // Rigidbody data
 	};
-public:
-	CollisionSystem();
-	void update();
-private:
-	void call_collision_handler(const CollidedInfoStor& data1,const CollidedInfoStor& data2);
-  	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
-	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
 public:
 	struct ColliderInfo {
-		Collider collider;
-		Transform transform;
-		Rigidbody rigidbody;
+		const Collider& collider;
+		Transform& transform;
+		Rigidbody& rigidbody;
 	};
 	struct CollisionInfo{
     ColliderInfo first;
     ColliderInfo second;
+		Vector2 move_back_value;
 	};
+public:
+	CollisionSystem();
+	void update();
+private: //handling
+	void call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
+	void static_collision_handler(CollisionInfo& info);
+private: //detection
+	
+	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
+
+
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index a1b22f0..a5cec83 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -49,8 +49,11 @@ int main(int argc, char * argv[]) {
 	LoopManager gameloop;
 	Color color(0, 0, 0, 0);
 
+	double screen_size_width = 1280;
+	double screen_size_height = 960;
+	double world_collider = 1000;
 	//define playable world 
-	GameObject World(0, "Name", "Tag", Vector2{0, 0}, 0, 1);
+	GameObject World(0, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	World.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 0,
 		.gravity_scale = 0,
@@ -58,46 +61,48 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = false,
 		.bounce = false,
-		.offset = {320,240}
+		.offset = {0,0}
 	});
-	World.add_component<BoxCollider>(Vector2{0, -740}, 1000, 1000);	// Top
-	World.add_component<BoxCollider>(Vector2{0, 740}, 1000, 1000); // Bottom
-	World.add_component<BoxCollider>(Vector2{-820, 0}, 1000, 1000); // Left
-	World.add_component<BoxCollider>(Vector2{820, 0}, 1000, 1000); // right
+	// World.add_component<BoxCollider>(Vector2{0, -740}, 1000, 1000);	// Top
+	World.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+	// World.add_component<BoxCollider>(Vector2{-820, 0}, 1000, 1000); // Left
+	// World.add_component<BoxCollider>(Vector2{820, 0}, 1000, 1000); // right
 
 
-	GameObject game_object1(1, "Name", "Tag", Vector2{320, 240}, 0, 1);
+	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 1,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.linear_velocity = {0,1},
 		.constraints = {0, 0, 0},
 		.use_gravity = false,
 		.bounce = false,
-		.offset = {0,0}
+		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	game_object1.add_component<Sprite>(
-	make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 	FlipSettings{true, true});
 	game_object1.add_component<Camera>(Color::get_white());
 	
 
-	// GameObject game_object2(2, "Name", "Tag", Vector2{10, 10}, 0, 1);
+	// GameObject game_object2(2, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2+100}, 0, 1);
 	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
 	// 	.mass = 1,
 	// 	.gravity_scale = 1,
 	// 	.body_type = Rigidbody::BodyType::DYNAMIC,
+	// 	.linear_velocity = {0,0},
 	// 	.constraints = {0, 0, 0},
 	// 	.use_gravity = false,
 	// 	.bounce = false,
-	// 	.offset = {0,0}
+	// 	.offset = {0,0},
 	// });
-	// game_object2.add_component<BoxCollider>(Vector2{5, 5}, 5, 5);
+	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
 	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
-	// make_shared<Texture>("/home/jaro/crepe/asset/texture/img.png"), color,
+	// make_shared<Texture>("/home/jaro/crepe/asset/texture/red_square.png"), color,
 	// FlipSettings{true, true});
 	
 	
-- 
cgit v1.2.3


From b1c82f914f18457f9a30791b01896ea40832c2d3 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 18:45:46 +0100
Subject: bounce

---
 src/crepe/api/Rigidbody.h            |  2 ++
 src/crepe/facade/SDLContext.cpp      |  8 ++++----
 src/crepe/system/CollisionSystem.cpp |  8 +++++++-
 src/example/collision.cpp            | 19 ++++++++++---------
 4 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index a45623f..b55297c 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -76,6 +76,8 @@ public:
 		bool use_gravity = true;
 		//! if object bounces
 		bool bounce = false;
+		//! bounce factor of material
+		double bouncie_factor = 0.0;
 		//! offset of all colliders
 		Vector2 offset;
 	};
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 274cd7a..5d22cdf 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -117,8 +117,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * sprite.flip.flip_x)
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
-	double adjusted_x = (transform.position.x - cam.x) * cam.zoom;
-	double adjusted_y = (transform.position.y - cam.y) * cam.zoom;
+	double adjusted_x = (transform.position.x - cam.x -(sprite.sprite_rect.w/2)) * cam.zoom;
+	double adjusted_y = (transform.position.y - cam.y -(sprite.sprite_rect.h/2)) * cam.zoom;
 	double adjusted_w = sprite.sprite_rect.w * transform.scale * cam.zoom;
 	double adjusted_h = sprite.sprite_rect.h * transform.scale * cam.zoom;
 
@@ -130,8 +130,8 @@ void SDLContext::draw(const Sprite & sprite, const Transform & transform,
 	};
 
 	SDL_Rect dstrect = {
-		.x = static_cast<int>(adjusted_x/2),
-		.y = static_cast<int>(adjusted_y/2),
+		.x = static_cast<int>(adjusted_x),
+		.y = static_cast<int>(adjusted_y),
 		.w = static_cast<int>(adjusted_w),
 		.h = static_cast<int>(adjusted_h),
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 4b74e67..8377823 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -152,7 +152,13 @@ void CollisionSystem::call_collision_handler(CollidedInfoStor& data1,CollidedInf
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
 	info.first.transform.position += info.move_back_value;
-	info.first.rigidbody.data.linear_velocity = {0,0};
+	if(info.first.rigidbody.data.bounce) {
+		info.first.rigidbody.data.linear_velocity = -info.first.rigidbody.data.linear_velocity * info.first.rigidbody.data.bouncie_factor;
+	}
+	else {
+		info.first.rigidbody.data.linear_velocity = {0,0};
+	}
+	
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index a5cec83..b141d3d 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -49,8 +49,8 @@ int main(int argc, char * argv[]) {
 	LoopManager gameloop;
 	Color color(0, 0, 0, 0);
 
-	double screen_size_width = 1280;
-	double screen_size_height = 960;
+	double screen_size_width = 640;
+	double screen_size_height = 480;
 	double world_collider = 1000;
 	//define playable world 
 	GameObject World(0, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
@@ -72,15 +72,16 @@ int main(int argc, char * argv[]) {
 	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
-		.gravity_scale = 1,
+		.gravity_scale = 0.01,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {0,1},
+		.linear_velocity = {0,0},
 		.constraints = {0, 0, 0},
-		.use_gravity = false,
-		.bounce = false,
+		.use_gravity = true,
+		.bounce = true,
+		.bouncie_factor = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
+	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
@@ -88,7 +89,7 @@ int main(int argc, char * argv[]) {
 	game_object1.add_component<Camera>(Color::get_white());
 	
 
-	// GameObject game_object2(2, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2+100}, 0, 1);
+	// GameObject game_object2(2, "Name", "Tag", Vector2{20, 470}, 0, 1);
 	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
 	// 	.mass = 1,
 	// 	.gravity_scale = 1,
@@ -99,7 +100,7 @@ int main(int argc, char * argv[]) {
 	// 	.bounce = false,
 	// 	.offset = {0,0},
 	// });
-	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 40, 40);
+	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 0, 0);
 	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
 	// game_object2.add_component<Sprite>(
 	// make_shared<Texture>("/home/jaro/crepe/asset/texture/red_square.png"), color,
-- 
cgit v1.2.3


From ed04aa321fd390c45eff1fee03e73e6513c6b978 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sun, 17 Nov 2024 19:04:33 +0100
Subject: improved bounce

---
 src/crepe/system/CollisionSystem.cpp | 7 ++++++-
 src/example/collision.cpp            | 8 ++++----
 2 files changed, 10 insertions(+), 5 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 8377823..3c6f22e 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -153,7 +153,12 @@ void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
 	info.first.transform.position += info.move_back_value;
 	if(info.first.rigidbody.data.bounce) {
-		info.first.rigidbody.data.linear_velocity = -info.first.rigidbody.data.linear_velocity * info.first.rigidbody.data.bouncie_factor;
+		if(info.move_back_value.x != 0) {
+			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.bouncie_factor;
+		}
+		if(info.move_back_value.y != 0) {
+			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.bouncie_factor;
+		}
 	}
 	else {
 		info.first.rigidbody.data.linear_velocity = {0,0};
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index b141d3d..2c476ca 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -63,10 +63,10 @@ int main(int argc, char * argv[]) {
 		.bounce = false,
 		.offset = {0,0}
 	});
-	// World.add_component<BoxCollider>(Vector2{0, -740}, 1000, 1000);	// Top
+	World.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
 	World.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	// World.add_component<BoxCollider>(Vector2{-820, 0}, 1000, 1000); // Left
-	// World.add_component<BoxCollider>(Vector2{820, 0}, 1000, 1000); // right
+	World.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+	World.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
 
 
 	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
@@ -74,7 +74,7 @@ int main(int argc, char * argv[]) {
 		.mass = 1,
 		.gravity_scale = 0.01,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {0,0},
+		.linear_velocity = {1,0},
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = true,
-- 
cgit v1.2.3


From 92e83ded2b6afb26082d7661c28af1d9d4e950a2 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 18 Nov 2024 16:55:21 +0100
Subject: added mouse and key event triggering

---
 src/crepe/api/Event.h           |  16 ++++++
 src/crepe/api/LoopManager.h     |  13 ++---
 src/crepe/facade/SDLContext.cpp | 114 ++++++++++++++++++++++++++++++++--------
 src/crepe/facade/SDLContext.h   |   1 +
 src/example/events.cpp          |   4 +-
 src/example/gameloop.cpp        |  33 ++++++++++++
 6 files changed, 151 insertions(+), 30 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index d5ddf0a..ef6a791 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -87,6 +87,10 @@ public:
 
 	//! Y-coordinate of the mouse position at the time of the event.
 	int mouse_y = 0;
+	// Relative movement in x
+    int rel_x;
+	// Relative movement in y
+    int rel_y; 
 };
 
 /**
@@ -113,3 +117,15 @@ public:
 class ShutDownEvent : public Event {
 public:
 };
+
+class MouseScrollEvent : public Event {
+public:
+	//! X-coordinate of the mouse position at the time of the event.
+	int scroll_x = 0;
+
+	//! Y-coordinate of the mouse position at the time of the event.
+	int scroll_y = 0;
+	
+	int direction = 0;
+};
+
diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h
index f6904be..b18c9d1 100644
--- a/src/crepe/api/LoopManager.h
+++ b/src/crepe/api/LoopManager.h
@@ -10,6 +10,12 @@ namespace crepe {
 class LoopManager {
 public:
 	void start();
+	/**
+	 * \brief Set game running variable
+	 *
+	 * \param running running (false = game shutdown, true = game running)
+	 */
+	void set_running(bool running);
 	LoopManager();
 
 private:
@@ -53,12 +59,7 @@ private:
 	 * This function updates physics and game logic based on LoopTimer's fixed_delta_time.
 	 */
 	void fixed_update();
-	/**
-	 * \brief Set game running variable
-	 *
-	 * \param running running (false = game shutdown, true = game running)
-	 */
-	void set_running(bool running);
+	
 	/**
 	 * \brief Function for executing render-related systems.
 	 *
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index bd2d33b..8a02f4c 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -82,34 +82,84 @@ SDLContext::~SDLContext() {
 	SDL_Quit();
 }
 
-void SDLContext::handle_events(bool & running) {
-	EventManager& event_manager = EventManager::get_instance();
-	//TODO: wouter i need events
-	SDL_Event event;
-	SDL_PollEvent(&event);
-	switch (event.type) {
-		case SDL_QUIT:
-			running = false;
-			break;
-		case SDL_KEYDOWN:
-			event_manager.trigger_event(KeyPressEvent{
-				.key = this->sdl_to_keycode(event.key.keysym.sym),
-				.repeat = event.key.repeat
-				});
-			break;
-		case SDL_MOUSEBUTTONDOWN:
-			int x, y;
-			SDL_GetMouseState(&x, &y);
-			triggerEvent(MousePressedEvent(x, y));
-			break;
-	}
+void SDLContext::handle_events(bool &running) {
+    EventManager& event_manager = EventManager::get_instance();
+    SDL_Event event;
+
+    while (SDL_PollEvent(&event)) {
+        switch (event.type) {
+            case SDL_QUIT:
+                running = false;
+                event_manager.trigger_event(ShutDownEvent{});
+                break;
+
+            case SDL_KEYDOWN:
+                std::cout << "keyDown: " << event.key.keysym.sym << std::endl;
+                event_manager.trigger_event<KeyPressEvent>(KeyPressEvent{
+                    .repeat = event.key.repeat,
+                    .key = this->sdl_to_keycode(event.key.keysym.scancode)
+                });
+                break;
+
+            case SDL_KEYUP:
+                event_manager.trigger_event<KeyReleaseEvent>(KeyReleaseEvent{
+                    .key = this->sdl_to_keycode(event.key.keysym.scancode),
+                });
+                break;
+
+            case SDL_MOUSEBUTTONDOWN:
+                {
+                    int x, y;
+                    SDL_GetMouseState(&x, &y);
+                    event_manager.trigger_event<MousePressEvent>(MousePressEvent{
+                        .mouse_x = x,
+                        .mouse_y = y,
+                        .button = this->sdl_to_mousebutton(event.button.button)
+                    });
+                }
+                break;
+
+            case SDL_MOUSEBUTTONUP:
+                {
+                    int x, y;
+                    SDL_GetMouseState(&x, &y);
+                    event_manager.trigger_event<MouseReleaseEvent>(MouseReleaseEvent{
+                        .mouse_x = x,
+                        .mouse_y = y,
+                        .button = this->sdl_to_mousebutton(event.button.button)
+                    });
+                }
+                break;
+
+            case SDL_MOUSEMOTION:
+                event_manager.trigger_event<MouseMoveEvent>(MouseMoveEvent{
+                    .mouse_x = event.motion.x,
+                    .mouse_y = event.motion.y,
+                    .rel_x = event.motion.xrel,
+                    .rel_y = event.motion.yrel
+                });
+                break;
+
+            case SDL_MOUSEWHEEL:
+                event_manager.trigger_event<MouseScrollEvent>(MouseScrollEvent{
+                    .scroll_x = event.wheel.x,
+                    .scroll_y = event.wheel.y,
+                    .direction = (event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED ? -1 : 1)
+                });
+                break;
+
+            // Add more events as needed for your application.
+        }
+    }
 }
 
 
+
 Keycode SDLContext::sdl_to_keycode(SDL_Keycode sdl_key) {
     static const std::array<Keycode, SDL_NUM_SCANCODES> LOOKUP_TABLE = [] {
         std::array<Keycode, SDL_NUM_SCANCODES> table{};
-        table.fill(Keycode::NONE); // Default to NONE for unmapped keys
+		 // Default to NONE for unmapped keys
+        table.fill(Keycode::NONE);
 
         table[SDL_SCANCODE_SPACE] = Keycode::SPACE;
         table[SDL_SCANCODE_APOSTROPHE] = Keycode::APOSTROPHE;
@@ -219,7 +269,27 @@ Keycode SDLContext::sdl_to_keycode(SDL_Keycode sdl_key) {
 
     return LOOKUP_TABLE[sdl_key];
 }
+MouseButton SDLContext::sdl_to_mousebutton(Uint8 sdl_button) {
+    static const std::array<MouseButton, 8> MOUSE_BUTTON_LOOKUP_TABLE = [] {
+        std::array<MouseButton, 8> table{};
+        table.fill(MouseButton::NONE); // Default to NONE for unmapped buttons
+
+        table[SDL_BUTTON_LEFT] = MouseButton::LEFT_MOUSE;
+        table[SDL_BUTTON_RIGHT] = MouseButton::RIGHT_MOUSE;
+        table[SDL_BUTTON_MIDDLE] = MouseButton::MIDDLE_MOUSE;
+        table[SDL_BUTTON_X1] = MouseButton::X1_MOUSE;
+        table[SDL_BUTTON_X2] = MouseButton::X2_MOUSE;
+
+        return table;
+    }();
 
+    if (sdl_button >= MOUSE_BUTTON_LOOKUP_TABLE.size()) {
+		 // Return NONE for invalid or unmapped button
+        return MouseButton::NONE; 
+    }
+
+    return MOUSE_BUTTON_LOOKUP_TABLE[sdl_button];  // Return mapped button
+}
 void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); }
 void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
 
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index ef7161b..cce2fb6 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -55,6 +55,7 @@ private:
 	 */
 	void handle_events(bool & running);
 	Keycode sdl_to_keycode(SDL_Keycode sdlKey);
+	MouseButton sdl_to_mousebutton(Uint8 sdl_button);
 
 private:
 	//! Will only use get_ticks
diff --git a/src/example/events.cpp b/src/example/events.cpp
index 6431c67..1b9ea45 100644
--- a/src/example/events.cpp
+++ b/src/example/events.cpp
@@ -56,12 +56,12 @@ public:
 	bool on_key_pressed(const KeyPressEvent & event) override {
 		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
 				  << std::endl;
-		return true; // Return true if the listener should remain active
+		return false;
 	}
 	bool on_key_released(const KeyReleaseEvent & event) override {
 		std::cout << "TestKeyListener: Key Released - Code: " << static_cast<int>(event.key)
 				  << std::endl;
-		return true;
+		return false;
 	}
 };
 int main() {
diff --git a/src/example/gameloop.cpp b/src/example/gameloop.cpp
index a676f20..d45b3ce 100644
--- a/src/example/gameloop.cpp
+++ b/src/example/gameloop.cpp
@@ -1,7 +1,40 @@
+#include <iostream>
 #include "crepe/api/LoopManager.h"
+#include <crepe/api/EventManager.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/IKeyListener.h>
+#include <crepe/api/IMouseListener.h>
 using namespace crepe;
+class TestKeyListener : public IKeyListener {
+public:
+	bool on_key_pressed(const KeyPressEvent & event) override {
+		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
+				  << std::endl;
+		if(event.key == Keycode::ESCAPE){
+			
+		}
+		return false;
+	}
+	bool on_key_released(const KeyReleaseEvent & event) override {
+		std::cout << "TestKeyListener: Key Released - Code: " << static_cast<int>(event.key)
+				  << std::endl;
+		return false;
+	}
+};
+bool on_key_pressed(const KeyPressEvent & event){
+		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
+				  << std::endl;
+		if(event.key == Keycode::ESCAPE){
+			return true;
+		}
+		return false;
+	}
 int main() {
 	LoopManager gameloop;
+	TestKeyListener key_listener;
+	EventManager::get_instance().subscribe<KeyPressEvent>(on_key_pressed);
 	gameloop.start();
+	
+	
 	return 1;
 }
-- 
cgit v1.2.3


From 0a49b688a79c9cb59c1ed1bdbd1c15f9572deed9 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 19 Nov 2024 20:39:42 +0100
Subject: added doxygen

---
 src/crepe/api/Rigidbody.h            |   2 +-
 src/crepe/system/CollisionSystem.cpp | 250 +++++++++++++++++------------------
 src/crepe/system/CollisionSystem.h   | 157 ++++++++++++++++++++--
 src/example/collision.cpp            |   2 +-
 4 files changed, 268 insertions(+), 143 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b55297c..782de22 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -77,7 +77,7 @@ public:
 		//! if object bounces
 		bool bounce = false;
 		//! bounce factor of material
-		double bouncie_factor = 0.0;
+		double elastisity = 0.0;
 		//! offset of all colliders
 		Vector2 offset;
 	};
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 3c6f22e..df0ee41 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -4,179 +4,200 @@
 #include <utility>
 #include <variant>
 
+#include "api/Event.h"
+#include "api/EventManager.h"
+#include "api/BoxCollider.h"
+#include "api/CircleCollider.h"
+#include "api/Vector2.h"
+#include "api/Rigidbody.h"
+#include "api/Transform.h"
+
+#include "ComponentManager.h"
 #include "CollisionSystem.h"
-#include "../api/Event.h"
-#include "../api/EventManager.h"
-
-#include "../ComponentManager.h"
-#include "../api/BoxCollider.h"
-#include "../api/CircleCollider.h"
-#include "../api/Vector2.h"
-#include "../api/Rigidbody.h"
-#include "../api/Transform.h"
-
 #include "Collider.h"
-#include "iostream"
 
 using namespace crepe;
 
 CollisionSystem::CollisionSystem() {}
 
 void CollisionSystem::update() {
+	// Get collider components and keep them seperate
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+	
+	// Check between all colliders if there is a collision
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
-	// std::cout << "DEBUG INFO" << std::endl;
-	for (auto& collision_pair : collided) {
-		call_collision_handler(collision_pair.first,collision_pair.second); // First collider
-		call_collision_handler(collision_pair.second,collision_pair.first); // First collider
-	}
 
-	if(collided.empty()) {
-		std::cout << "No objects collided" << std::endl;
+	// For both objects call the collision handler 
+	for (auto& collision_pair : collided) {
+		collision_handler(collision_pair.first,collision_pair.second);
+		collision_handler(collision_pair.second,collision_pair.first);
 	}
 }
 
-void CollisionSystem::call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
+void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
+
+	// Data needed for collision handler info
 	const Collider* collider1 = nullptr;
 	const Collider* collider2 = nullptr;
-	double height1 = 0,width1 = 0;
-	double height2 = 0,width2 = 0;
-	Vector2 final_position1;
-	Vector2 final_position2;
-	Vector2 temp;
+	Vector2 move_back;
+
 	// Check collision type and get values for handler
-	game_object_id_t first = 0,second = 0;
 	if (std::holds_alternative<BoxCollider>(data1.collider)) {
 		if (std::holds_alternative<BoxCollider>(data2.collider)) {
+			
+			// Get colliders from variant to be used to determine collision handler info
 			const BoxCollider& box_collider1 = std::get<BoxCollider>(data1.collider);
 			const BoxCollider& box_collider2 = std::get<BoxCollider>(data2.collider);
 			collider1 = &box_collider1;
 			collider2 = &box_collider2;
-			first = box_collider1.game_object_id;
-			second = box_collider2.game_object_id;
-			height1 = box_collider1.height;
-			height2 = box_collider2.height;
-			width1 = box_collider1.width;
-			width2 = box_collider2.width;
-			final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
-			final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
-
-			Vector2 delta = final_position2 - final_position1;
-
-			double half_width1 = width1 / 2.0;
-			double half_height1 = height1 / 2.0;
-			double half_width2 = width2 / 2.0;
-			double half_height2 = height2 / 2.0;
-
-			// Compute overlap in X and Y directions
-			double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
-			double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
-
-			// Check if there is actually a collision
-			if (overlap_x > 0 && overlap_y > 0) {
-					// Resolve in the smallest overlap direction
-					if (overlap_x < overlap_y) {
-							// Resolve along X-axis
-							temp = {delta.x > 0 ? -overlap_x : overlap_x, 0};
-					} else {
-							// Resolve along Y-axis
-							temp = {0, delta.y > 0 ? -overlap_y : overlap_y};
-					}
-			}
-
 
+			// TODO: send with the collider info to this function because this is calculated previously
+			// Get the current position of the collider
+			Vector2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
+			Vector2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
 
+			// Determine move_back value for smallest overlap (x or y)
+			move_back = box_box_collision_move_back(box_collider1,box_collider2,final_position1,final_position2);
+			
 		}
 		else {
+			// TODO: calcualte Box - Circle collision info
 			const BoxCollider& box_collider = std::get<BoxCollider>(data1.collider);
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data2.collider);
 			collider1 = &box_collider;
 			collider2 = &circle_collider;
-			first = box_collider.game_object_id;
-			second = circle_collider.game_object_id;
-			height1 = box_collider.height;
-			height2 = circle_collider.radius + circle_collider.radius;
-			width1 = box_collider.width;
-			width2 = circle_collider.radius + circle_collider.radius;
 		}
 	}
 	else {
 		if (std::holds_alternative<CircleCollider>(data2.collider)) {
+			// TODO: calcualte Circle - Circle collision info
 			const CircleCollider& circle_collider1 = std::get<CircleCollider>(data1.collider);
 			const CircleCollider& circle_collider2 = std::get<CircleCollider>(data2.collider);
 			collider1 = &circle_collider1;
 			collider2 = &circle_collider2;
-			first = circle_collider1.game_object_id;
-			second = circle_collider2.game_object_id;
-			height1 = circle_collider1.radius + circle_collider1.radius;
-			height2 = circle_collider2.radius + circle_collider2.radius;
-			width1 = circle_collider1.radius + circle_collider1.radius;
-			width2 = circle_collider2.radius + circle_collider2.radius;
 		}
 		else {
+			// TODO: calcualte Circle - Box collision info
 			const CircleCollider& circle_collider = std::get<CircleCollider>(data1.collider);
 			const BoxCollider& box_collider = std::get<BoxCollider>(data2.collider);
 			collider1 = &circle_collider;
 			collider2 = &box_collider;
-			first = circle_collider.game_object_id;
-			second = box_collider.game_object_id;
-			height1 = circle_collider.radius + circle_collider.radius;
-			height2 = box_collider.height;
-			width1 = circle_collider.radius + circle_collider.radius;
-			width2 = box_collider.width;
 		}
 	}
+
+	// One vaue is calculated for moving back. Calculate the other value (x or y) relateive to the move_back value.
+	Direction move_back_direction = Direction::NONE;
+	if(move_back.x != 0 && move_back.y > 0) {
+		move_back_direction = Direction::BOTH;
+	} else if (move_back.x != 0) {
+		move_back_direction = Direction::X_DIRECTION;
+		move_back.y = data1.rigidbody.data.linear_velocity.y * (move_back.x/data1.rigidbody.data.linear_velocity.x);
+	} else if (move_back.y != 0) {
+		move_back_direction = Direction::Y_DIRECTION;
+		move_back.x = data1.rigidbody.data.linear_velocity.x * (move_back.y/data1.rigidbody.data.linear_velocity.y);
+	}
+
+	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
             .first={ *collider1, data1.transform, data1.rigidbody },
             .second={ *collider2, data2.transform, data2.rigidbody },
-						.move_back_value = temp,
+						.move_back_value = move_back,
+						.move_back_direction = move_back_direction,
         };
 
-	// check rigidbody type
-	if(data1.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
+	// Determine if static needs to be called
+	determine_collision_handler(collision_info);	
+}
+
+
+Vector2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 final_position1,Vector2 final_position2)
+{
+	Vector2 resolution; // Default resolution vector
+	Vector2 delta = final_position2 - final_position1;
+
+	// Compute half-dimensions of the boxes
+	double half_width1 = box_collider1.width / 2.0;
+	double half_height1 = box_collider1.height / 2.0;
+	double half_width2 = box_collider2.width / 2.0;
+	double half_height2 = box_collider2.height / 2.0;
+
+	// Calculate overlaps along X and Y axes
+	double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
+	double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
+
+	// Check if there is a collision
+	if (overlap_x > 0 && overlap_y > 0) {//should always be true check if this can be removed
+		// Determine the direction of resolution
+		if (overlap_x < overlap_y) {
+			// Resolve along the X-axis (smallest overlap)
+			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
+		} else if (overlap_y < overlap_x) {
+			// Resolve along the Y-axis (smallest overlap)
+			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
+		} else {
+			// Equal overlap, resolve both directions with preference
+			resolution.x = (delta.x > 0) ? -overlap_x : overlap_x;
+			resolution.y = (delta.y > 0) ? -overlap_y : overlap_y;
+		}
+	}
+
+	return resolution;
+}
+
+void CollisionSystem::determine_collision_handler(CollisionInfo& info){
+	// Check rigidbody type for static
+	if(info.first.rigidbody.data.body_type != Rigidbody::BodyType::STATIC)
 	{
-		// If second body is static move back
-		if(data2.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
-			//call static handler (is bounce true?)
-			static_collision_handler(collision_info);
+		// If second body is static perform the static collision handler in this system
+		if(info.second.rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+			static_collision_handler(info);
 		}; 
-		
-		
-		CollisionEvent data(collision_info);
-		EventManager::get_instance().trigger_event<CollisionEvent>(data, first);
+		// Call collision event for user
+		CollisionEvent data(info);
+		EventManager::get_instance().trigger_event<CollisionEvent>(data, info.first.collider.game_object_id);
 	}		
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
-	std::cout << "INFO: x:" << info.first.transform.position.x << "y:" << info.first.transform.position.y << std::endl;
+	// Move object back using calculate move back value 
 	info.first.transform.position += info.move_back_value;
+
+	// If bounce is enabled mirror velocity
 	if(info.first.rigidbody.data.bounce) {
-		if(info.move_back_value.x != 0) {
-			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.bouncie_factor;
+		if(info.move_back_direction == Direction::BOTH)
+		{
+			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.elastisity;
+			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.elastisity;
+		}
+		else if(info.move_back_direction == Direction::Y_DIRECTION) {
+			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.elastisity;
 		}
-		if(info.move_back_value.y != 0) {
-			info.first.rigidbody.data.linear_velocity.y = -info.first.rigidbody.data.linear_velocity.y * info.first.rigidbody.data.bouncie_factor;
+		else if(info.move_back_direction == Direction::X_DIRECTION){
+			info.first.rigidbody.data.linear_velocity.x = -info.first.rigidbody.data.linear_velocity.x * info.first.rigidbody.data.elastisity;
 		}
 	}
+	// Stop movement if bounce is disabled
 	else {
 		info.first.rigidbody.data.linear_velocity = {0,0};
 	}
-	
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
 	ComponentManager & mgr = ComponentManager::get_instance();
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
-	//if no colliders skip
-	//check if colliders has rigibocdy if not skip
 
-	//if amount is higer than lets say 16 for now use quadtree otwerwise skip
-	//quadtree code
-	//quadtree is placed over the input vector
+	// TODO:
+	// If no colliders skip
+	// Check if colliders has rigidbody if not skip
 
-	// Check collisions
+	// TODO:
+	// If amount is higer than lets say 16 for now use quadtree otwerwise skip
+	// Quadtree code
+	// Quadtree is placed over the input vector
+
+	// Check collisions for each collider
 	for (size_t i = 0; i < boxcolliders.size(); ++i) {
 		// Fetch components for the first box collider
 		if(!boxcolliders[i].get().active) continue;
@@ -270,32 +291,12 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 	Vector2 final_position1 = current_position(box1,transform1,rigidbody1);
 	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
 
-	 // Log final positions for debugging purposes
-	std::cout << "Final Position of Box 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	std::cout << "Final Position of Box 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
-	// Log rotation values for debugging
-	std::cout << "Rotation of Box 1: " << transform1.rotation << " degrees" << std::endl;
-	std::cout << "Rotation of Box 2: " << transform2.rotation << " degrees" << std::endl;
-
-
 	// Calculate half-extents (half width and half height)
 	double half_width1 = box1.width / 2.0;
 	double half_height1 = box1.height / 2.0;
 	double half_width2 = box2.width / 2.0;
 	double half_height2 = box2.height / 2.0;
 
-	std::cout << "half_width of Box 1: " << half_width1 << std::endl;
-	std::cout << "half_height of Box 2: " << half_height1 << std::endl;
-	std::cout << "half_width of Box 1: " << half_width2 << std::endl;
-	std::cout << "half_height of Box 2: " << half_height2 << std::endl;
-
-
-	std::cout << "final_position1.x + half_width1 < final_position2.x - half_width2 " << (final_position1.x + half_width1 < final_position2.x - half_width2) << std::endl;
-	std::cout << "final_position1.x - half_width1 > final_position2.x + half_width2 " << (final_position1.x - half_width1 > final_position2.x + half_width2) << std::endl;
-	std::cout << "final_position1.y + half_height1 < final_position2.y - half_height2 " << (final_position1.y + half_height1 < final_position2.y - half_height2) << std::endl;
-	std::cout << "final_position1.y - half_height1 > final_position2.y + half_height2 " << (final_position1.y - half_height1 > final_position2.y + half_height2) << std::endl;
-
 	// Check if the boxes overlap along the X and Y axes
 	return !(final_position1.x + half_width1 <= final_position2.x - half_width2 ||  // box1 is left of box2
 						final_position1.x - half_width1 >= final_position2.x + half_width2 ||  // box1 is right of box2
@@ -308,10 +309,6 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	Vector2 final_position1 = current_position(box1, transform1, rigidbody1);
 	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
-	// Log final positions for debugging purposes
-	// std::cout << "Final Position of Box: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	// std::cout << "Final Position of Circle: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
 	// Calculate box half-extents
 	double half_width = box1.width / 2.0;
 	double half_height = box1.height / 2.0;
@@ -320,7 +317,6 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 	double closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
 	double closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
 
-
 	// Calculate the distance squared between the circle's center and the closest point on the box
 	double distance_x = final_position2.x - closest_x;
 	double distance_y = final_position2.y - closest_y;
@@ -335,14 +331,6 @@ bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle
 	Vector2 final_position1 = current_position(circle1,transform1,rigidbody1);
 	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
-	// Log final positions for debugging purposes
-	// std::cout << "Final Position of Circle 1: (" << final_position1.x << ", " << final_position1.y << ")" << std::endl;
-	// std::cout << "Final Position of Circle 2: (" << final_position2.x << ", " << final_position2.y << ")" << std::endl;
-
-	// Log rotation values for debugging (circles do not rotate, so this might not be needed for circles)
-	// std::cout << "Rotation of Circle 1: " << transform1.rotation << " degrees" << std::endl;
-	// std::cout << "Rotation of Circle 2: " << transform2.rotation << " degrees" << std::endl;
-
 	double distance_x = final_position1.x - final_position2.x;
 	double distance_y = final_position1.y - final_position2.y;
 	double distance_squared = distance_x * distance_x + distance_y * distance_y;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index cfa599e..f3242b1 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -1,54 +1,191 @@
 #pragma once
 
-#include "Collider.h"
+#include <vector>
+#include <variant>
+
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Vector2.h"
-#include <tuple>
-#include <vector>
-#include <variant>
+
+#include "Collider.h"
 
 namespace crepe {
 
 
+//! A system responsible for detecting and handling collisions between colliders.
 class CollisionSystem {
 private:
+	
+	//! A variant type that can hold either a BoxCollider or a CircleCollider.
 	using collider_stor = std::variant<BoxCollider, CircleCollider>;
-private:
+
+	/**
+		* \brief A structure to store the collision data of a single collider.
+		* 
+		* This structure stores the collider type, its associated transform, and its rigidbody.
+		*/
 	struct CollidedInfoStor {
 		//! Store either BoxCollider or CircleCollider
 		collider_stor collider; 
 		Transform& transform;
-		Rigidbody& rigidbody;      // Rigidbody data
+		Rigidbody& rigidbody;
 	};
+	
+	//! Enum representing movement directions during collision resolution.
+	enum class Direction {
+    NONE,
+    X_DIRECTION,
+    Y_DIRECTION,
+    BOTH
+	};
+
 public:
+	/**
+		* \brief A structure representing the collision information between two colliders.
+		* 
+		* This structure contains both colliders, their associated transforms and rigidbodies,
+		* as well as the movement vector to resolve the collision.
+		*/
 	struct ColliderInfo {
 		const Collider& collider;
 		Transform& transform;
 		Rigidbody& rigidbody;
 	};
+	/**
+		* \brief A structure representing detailed collision information between two colliders.
+		* 
+		* This includes the movement data required to resolve the collision.
+		*/
 	struct CollisionInfo{
     ColliderInfo first;
     ColliderInfo second;
 		Vector2 move_back_value;
+		Direction move_back_direction = Direction::NONE;
 	};
+
 public:
+
 	CollisionSystem();
+
+	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update();
-private: //handling
-	void call_collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
+
+private:
+	/**
+		* \brief Handles a collision between two colliders.
+		* 
+		* This function calculates the necessary response to resolve the collision, including
+		* moving the objects back to prevent overlap and applying any velocity changes.
+		*
+		* \param data1 The collision data for the first collider.
+		* \param data2 The collision data for the second collider.
+		*/
+	void collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
+	
+	/**
+		* \brief Resolves the movement of two box colliders that are colliding.
+		* 
+		* This function calculates the smallest overlap (along the X or Y axis) and determines
+		* the move-back vector to prevent overlap.
+		*
+		* \param box_collider1 The first box collider.
+		* \param box_collider2 The second box collider.
+		* \param final_position1 The final position of the first box collider.
+		* \param final_position2 The final position of the second box collider.
+		* \return The move-back vector to resolve the collision.
+		*/
+	Vector2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 position1,Vector2 position2);
+
+	/**
+		* \brief Determines the appropriate collision handler based on the rigidbody types of the colliding objects.
+		* 
+		* This function checks if the second object is static, and if so, it calls the static collision handler.
+		* Otherwise, it triggers a collision event.
+		*
+		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
+		*/
+	void determine_collision_handler(CollisionInfo& info);
+
+	/**
+		* \brief Handles the collision with a static object.
+		* 
+		* This function resolves the collision by moving the object back and applying any bounce or stop behavior.
+		*
+		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
+		*/
 	void static_collision_handler(CollisionInfo& info);
 private: //detection
 	
+	/**
+		* \brief Checks for collisions between box colliders and circle colliders
+		* and returns the collision pairs that need to be resolved.
+		* 
+		* \param boxcolliders A vector of references to all box colliders.
+		* \param circlecolliders A vector of references to all circle colliders.
+		* \return A vector of pairs containing collision information for the detected collisions.
+		*/
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+	
+	/**
+		* \brief Checks for a collision between two box colliders.
+		* 
+		* This function checks if two box colliders overlap based on their positions and dimensions.
+		*
+		* \param box1 The first box collider.
+		* \param box2 The second box collider.
+		* \param transform1 The transform component of the first box collider.
+		* \param transform2 The transform component of the second box collider.
+		* \param rigidbody1 The rigidbody component of the first box collider.
+		* \param rigidbody2 The rigidbody component of the second box collider.
+		* \return True if the two box colliders overlap, otherwise false.
+		*/
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Checks for a collision between a box collider and a circle collider.
+		* 
+		* This function checks if a box collider overlaps with a circle collider based on their positions
+		* and dimensions.
+		*
+		* \param box1 The box collider.
+		* \param circle2 The circle collider.
+		* \param transform1 The transform component of the box collider.
+		* \param transform2 The transform component of the circle collider.
+		* \param rigidbody1 The rigidbody component of the box collider.
+		* \param rigidbody2 The rigidbody component of the circle collider.
+		* \return True if the box collider and circle collider overlap, otherwise false.
+		*/
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Checks for a collision between two circle colliders.
+		* 
+		* This function checks if two circle colliders overlap based on their positions and radii.
+		*
+		* \param circle1 The first circle collider.
+		* \param circle2 The second circle collider.
+		* \param transform1 The transform component of the first circle collider.
+		* \param transform2 The transform component of the second circle collider.
+		* \param rigidbody1 The rigidbody component of the first circle collider.
+		* \param rigidbody2 The rigidbody component of the second circle collider.
+		* \return True if the two circle colliders overlap, otherwise false.
+		*/
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
+	
+	/**
+		* \brief Gets the current position of a collider by combining its transform and rigidbody data.
+		* 
+		* This function calculates the current position of the collider by considering its transform and 
+		* rigidbody velocity.
+		*
+		* \param collider The collider whose position is being determined.
+		* \param transform The transform component associated with the collider.
+		* \param rigidbody The rigidbody component associated with the collider.
+		* \return The current position of the collider as a Vector2.
+		*/
 	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
-
-
 };
 
 } // namespace crepe
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
index 2c476ca..f51380e 100644
--- a/src/example/collision.cpp
+++ b/src/example/collision.cpp
@@ -78,7 +78,7 @@ int main(int argc, char * argv[]) {
 		.constraints = {0, 0, 0},
 		.use_gravity = true,
 		.bounce = true,
-		.bouncie_factor = 1,
+		.elastisity = 1,
 		.offset = {0,0},
 	});
 	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-- 
cgit v1.2.3


From 690471c7c4536c074a4dca5aab7cc618d47bfb5f Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 20 Nov 2024 10:43:32 +0100
Subject: merge with maser

---
 src/crepe/api/LoopManager.cpp        |   6 +-
 src/crepe/api/LoopManager.h          |   5 +-
 src/crepe/api/Script.h               |   9 ++-
 src/crepe/system/CollisionSystem.cpp |   6 +-
 src/crepe/system/CollisionSystem.h   |   2 -
 src/example/CMakeLists.txt           |   2 +-
 src/example/collision.cpp            | 123 -----------------------------------
 src/example/game.cpp                 |  89 +++++++++++++++++++++++++
 src/example/particles.cpp            |  43 ------------
 src/example/physics.cpp              |  24 -------
 src/example/rendering.cpp            |   4 +-
 src/test/CMakeLists.txt              |   2 -
 src/test/CollisionTest.cpp           | 121 ++++++++++++++++------------------
 13 files changed, 165 insertions(+), 271 deletions(-)
 delete mode 100644 src/example/collision.cpp
 create mode 100644 src/example/game.cpp
 delete mode 100644 src/example/particles.cpp
 delete mode 100644 src/example/physics.cpp

(limited to 'src/example')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index a4bc101..586919d 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -35,10 +35,8 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
-	PhysicsSystem phys;
-	phys.update();
-	CollisionSystem col;
-	col.update();
+	this->get_system<PhysicsSystem>().update();
+	this->get_system<CollisionSystem>().update();
 }
 
 void LoopManager::loop() {
diff --git a/src/crepe/api/LoopManager.h b/src/crepe/api/LoopManager.h
index f6904be..37f13ac 100644
--- a/src/crepe/api/LoopManager.h
+++ b/src/crepe/api/LoopManager.h
@@ -4,6 +4,7 @@
 
 #include "../ComponentManager.h"
 #include "../system/System.h"
+#include "api/SceneManager.h"
 
 namespace crepe {
 
@@ -71,7 +72,9 @@ private:
 private:
 	//! Component manager instance
 	ComponentManager component_manager{};
-
+public:
+	//! Scene manager instance
+	SceneManager scene_manager{component_manager};
 private:
 	/**
 	 * \brief Collection of System instances
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 2b70379..939d142 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -63,7 +63,14 @@ protected:
 	 */
 	template <typename T>
 	std::vector<std::reference_wrapper<T>> get_components() const;
-
+	
+	/**
+	 * \brief Gets game object id this script is attached to
+	 *
+	 * \returns game object id
+	 */
+	game_object_id_t get_game_object_id() const {return this->game_object_id;};
+	
 protected:
 	// NOTE: Script must have a constructor without arguments so the game programmer doesn't need
 	// to manually add `using Script::Script` to their concrete script class.
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index df0ee41..3e73b44 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -18,11 +18,9 @@
 
 using namespace crepe;
 
-CollisionSystem::CollisionSystem() {}
-
 void CollisionSystem::update() {
 	// Get collider components and keep them seperate
-	ComponentManager & mgr = ComponentManager::get_instance();
+	ComponentManager & mgr = this->component_manager;
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
 	
@@ -185,7 +183,7 @@ void CollisionSystem::static_collision_handler(CollisionInfo& info){
 }
 
 std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
-	ComponentManager & mgr = ComponentManager::get_instance();
+	ComponentManager & mgr = this->component_manager;
 	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
 
 	// TODO:
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 0518b34..d94f6bc 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -70,8 +70,6 @@ public:
 
 public:
 
-	CollisionSystem();
-
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
 
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index d2ea926..2facc4d 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -28,7 +28,7 @@ add_example(proxy)
 add_example(db)
 add_example(ecs)
 add_example(scene_manager)
-add_example(collision)
+add_example(game)
 add_example(events)
 add_example(particles)
 add_example(gameloop)
diff --git a/src/example/collision.cpp b/src/example/collision.cpp
deleted file mode 100644
index f51380e..0000000
--- a/src/example/collision.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-#include "api/BoxCollider.h"
-#include "system/CollisionSystem.h"
-#include <crepe/system/ScriptSystem.h>
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/BoxCollider.h>
-#include <crepe/api/Transform.h>
-#include <crepe/system/PhysicsSystem.h>
-#include <crepe/system/RenderSystem.h>
-#include <crepe/util/log.h>
-
-#include <crepe/api/Script.h>
-#include <crepe/api/AssetManager.h>
-#include <crepe/api/Color.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Transform.h>
-#include <crepe/api/Vector2.h>
-#include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
-#include <crepe/api/LoopManager.h>
-
-#include <chrono>
-#include <memory>
-
-using namespace crepe;
-using namespace std;
-
-class MyScript : public Script {
-	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
-		return true;
-	}
-	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->parent->game_object_id);
-	}
-	void update() {
-		// Retrieve component from the same GameObject this script is on
-		
-	}
-	
-	
-};
-
-int main(int argc, char * argv[]) {
-	//setup
-	LoopManager gameloop;
-	Color color(0, 0, 0, 0);
-
-	double screen_size_width = 640;
-	double screen_size_height = 480;
-	double world_collider = 1000;
-	//define playable world 
-	GameObject World(0, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	World.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 0,
-		.gravity_scale = 0,
-		.body_type = Rigidbody::BodyType::STATIC,
-		.constraints = {0, 0, 0},
-		.use_gravity = false,
-		.bounce = false,
-		.offset = {0,0}
-	});
-	World.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	World.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	World.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	World.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
-
-
-	GameObject game_object1(1, "Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,0},
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
-		.elastisity = 1,
-		.offset = {0,0},
-	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	game_object1.add_component<Sprite>(
-	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
-	FlipSettings{true, true});
-	game_object1.add_component<Camera>(Color::get_white());
-	
-
-	// GameObject game_object2(2, "Name", "Tag", Vector2{20, 470}, 0, 1);
-	// game_object2.add_component<Rigidbody>(Rigidbody::Data{
-	// 	.mass = 1,
-	// 	.gravity_scale = 1,
-	// 	.body_type = Rigidbody::BodyType::DYNAMIC,
-	// 	.linear_velocity = {0,0},
-	// 	.constraints = {0, 0, 0},
-	// 	.use_gravity = false,
-	// 	.bounce = false,
-	// 	.offset = {0,0},
-	// });
-	// game_object2.add_component<BoxCollider>(Vector2{0, 0}, 0, 0);
-	// game_object2.add_component<BehaviorScript>().set_script<MyScript>();
-	// game_object2.add_component<Sprite>(
-	// make_shared<Texture>("/home/jaro/crepe/asset/texture/red_square.png"), color,
-	// FlipSettings{true, true});
-	
-	
-	crepe::ScriptSystem sys;
-	// Update all scripts. This should result in MyScript::update being called
-	sys.update();
-	
-	gameloop.start();
-	// auto & render = crepe::RenderSystem::get_instance();
-	// auto start = std::chrono::steady_clock::now();
-	// while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-	//	 render.update();
-	// }
-
-
-	return 0;
-}
diff --git a/src/example/game.cpp b/src/example/game.cpp
new file mode 100644
index 0000000..a9f6103
--- /dev/null
+++ b/src/example/game.cpp
@@ -0,0 +1,89 @@
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/BoxCollider.h>
+#include <crepe/api/Camera.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Vector2.h>
+#include <crepe/api/Event.h>
+#include <crepe/api/EventManager.h>
+#include <crepe/api/LoopManager.h>
+
+using namespace crepe;
+
+using namespace std;
+
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
+};
+
+class ConcreteScene1 : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		ComponentManager & mgr = this->component_manager;
+		Color color(0, 0, 0, 0);
+
+	double screen_size_width = 640;
+	double screen_size_height = 480;
+	double world_collider = 1000;
+	//define playable world 
+	GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	world.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 0,
+		.gravity_scale = 0,
+		.body_type = Rigidbody::BodyType::STATIC,
+		.constraints = {0, 0, 0},
+		.use_gravity = false,
+		.bounce = false,
+		.offset = {0,0}
+	});
+	world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
+	world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+	world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+	world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
+
+
+	GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	game_object1.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 0.01,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.linear_velocity = {1,0},
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = true,
+		.elastisity = 1,
+		.offset = {0,0},
+	});
+	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+	game_object1.add_component<Sprite>(
+	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+	FlipSettings{true, true});
+	game_object1.add_component<Camera>(Color::get_white());
+	}
+};
+
+int main(int argc, char * argv[]) {
+
+	LoopManager gameloop;
+	gameloop.scene_manager.add_scene<ConcreteScene1>("scene1");
+	gameloop.scene_manager.load_next_scene();
+	gameloop.start();
+	return 0;
+}
diff --git a/src/example/particles.cpp b/src/example/particles.cpp
deleted file mode 100644
index 3d5f676..0000000
--- a/src/example/particles.cpp
+++ /dev/null
@@ -1,43 +0,0 @@
-#include <crepe/ComponentManager.h>
-#include <crepe/api/AssetManager.h>
-
-#include <crepe/Component.h>
-#include <crepe/api/Color.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>
-
-using namespace crepe;
-using namespace std;
-
-int main(int argc, char * argv[]) {
-	ComponentManager mgr{};
-	GameObject game_object = mgr.new_object("", "", Vector2{0, 0}, 0, 0);
-	Color color(0, 0, 0, 0);
-	Sprite test_sprite = game_object.add_component<Sprite>(
-		make_shared<Texture>("../asset/texture/img.png"), color, FlipSettings{true, true});
-	game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
-		.position = {0, 0},
-		.max_particles = 100,
-		.emission_rate = 0,
-		.min_speed = 0,
-		.max_speed = 0,
-		.min_angle = 0,
-		.max_angle = 0,
-		.begin_lifespan = 0,
-		.end_lifespan = 0,
-		.force_over_time = Vector2{0, 0},
-		.boundary{
-			.width = 0,
-			.height = 0,
-			.offset = Vector2{0, 0},
-			.reset_on_exit = false,
-		},
-		.sprite = test_sprite,
-	});
-
-	return 0;
-}
diff --git a/src/example/physics.cpp b/src/example/physics.cpp
deleted file mode 100644
index ad663a0..0000000
--- a/src/example/physics.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Transform.h>
-#include <crepe/system/PhysicsSystem.h>
-
-using namespace crepe;
-using namespace std;
-
-int main(int argc, char * argv[]) {
-	ComponentManager mgr{};
-
-	GameObject game_object = mgr.new_object("Name", "Tag", Vector2{0, 0}, 0, 0);
-	game_object.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 1,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = false,
-	});
-	return 0;
-}
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index c9e62f1..14ecaa9 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -30,13 +30,13 @@ int main() {
 	// Normal adding components
 	{
 		Color color(0, 0, 0, 0);
-		obj.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"), color,
+		obj.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 								  FlipSettings{false, false});
 		obj.add_component<Camera>(Color::get_red());
 	}
 	{
 		Color color(0, 0, 0, 0);
-		obj1.add_component<Sprite>(make_shared<Texture>("../asset/texture/second.png"), color,
+		obj1.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 								   FlipSettings{true, true});
 	}
 
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index a41d097..f830165 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,6 +1,4 @@
 target_sources(test_main PUBLIC
-	dummy.cpp
-	# audio.cpp
 	CollisionTest.cpp
 	main.cpp
 	PhysicsTest.cpp
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 3e43479..83564e1 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,83 +1,76 @@
-#include "api/BoxCollider.h"
-#include "api/CircleCollider.h"
-#include "api/Vector2.h"
 #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/system/CollisionSystem.h>
+#include <crepe/system/PhysicsSystem.h>
 #include <gtest/gtest.h>
 
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
 
-class CollisionTest : public ::testing::Test {
-protected:
-	GameObject * game_object1;
-	GameObject * game_object2;
-	CollisionSystem collision_system;
-	void SetUp() override {
-		ComponentManager & mgr = ComponentManager::get_instance();
-		mgr.delete_all_components();
-		std::vector<std::reference_wrapper<Transform>> transforms
-			= mgr.get_components_by_id<Transform>(0);
-
-		// ob 1
-		game_object1 = new GameObject(0, "", "", Vector2{0, 0}, 0, 0);
-		game_object1->add_component<Rigidbody>(Rigidbody::Data{
-			.mass = 1,
-			.gravity_scale = 1,
-			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.max_linear_velocity = Vector2{10, 10},
-			.max_angular_velocity = 10,
-			.constraints = {0, 0, 0},
-			.use_gravity = false,
-			.bounce = false,
-		});
-		
-		game_object1->add_component<BoxCollider>(Vector2{0,0},10,10);
+class MyScript : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
 		
+	}
+};
+
+class PhysicsTest : public ::testing::Test {
+public:
+	ComponentManager component_manager;
+	PhysicsSystem system{component_manager};
 
-		//ob 2
-		game_object2 = new GameObject(1, "", "", Vector2{50, 50}, 0, 0);
-		game_object2->add_component<Rigidbody>(Rigidbody::Data{
-			.mass = 1,
-			.gravity_scale = 1,
-			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.max_linear_velocity = Vector2{10, 10},
-			.max_angular_velocity = 10,
-			.constraints = {0, 0, 0},
-			.use_gravity = false,
-			.bounce = false,
-		});
-		game_object2->add_component<CircleCollider>(Vector2{0,0},5);
+	void SetUp() override {
+		ComponentManager & mgr = this->component_manager;
+		vector<reference_wrapper<Transform>> transforms
+			= mgr.get_components_by_id<Transform>(0);
+		if (transforms.empty()) {
+			auto entity = mgr.new_object("", "", Vector2{0, 0}, 0, 0);
+			entity.add_component<Rigidbody>(Rigidbody::Data{
+				.mass = 1,
+				.gravity_scale = 1,
+				.body_type = Rigidbody::BodyType::DYNAMIC,
+				.max_linear_velocity = Vector2{10, 10},
+				.max_angular_velocity = 10,
+				.constraints = {0, 0},
+				.use_gravity = true,
+				.bounce = false,
+			});
+		}
+		transforms = mgr.get_components_by_id<Transform>(0);
+		Transform & transform = transforms.front().get();
+		transform.position.x = 0.0;
+		transform.position.y = 0.0;
+		transform.rotation = 0.0;
+		vector<reference_wrapper<Rigidbody>> rigidbodies
+			= mgr.get_components_by_id<Rigidbody>(0);
+		Rigidbody & rigidbody = rigidbodies.front().get();
+		rigidbody.data.angular_velocity = 0;
+		rigidbody.data.linear_velocity.x = 0;
+		rigidbody.data.linear_velocity.y = 0;
 	}
 };
 
-TEST_F(CollisionTest, box_box_collision) {
+TEST_F(PhysicsTest, gravity) {
 	Config::get_instance().physics.gravity = 1;
-	ComponentManager & mgr = ComponentManager::get_instance();
-	std::vector<std::reference_wrapper<Transform>> transforms
-		= mgr.get_components_by_id<Transform>(0);
-	Transform & transform = transforms.front().get();
+	ComponentManager & mgr = this->component_manager;
+	vector<reference_wrapper<Transform>> transforms = mgr.get_components_by_id<Transform>(0);
+	const Transform & transform = transforms.front().get();
 	ASSERT_FALSE(transforms.empty());
-	transform.position = {39,50};
-	collision_system.update();
-	transform.position = {40,50};
-	collision_system.update();
-	transform.position = {50,39};
-	collision_system.update();
-	transform.position = {50,40};
-	collision_system.update();
-	transform.position = {50,60};
-	collision_system.update();
-	transform.position = {50,61};
-	collision_system.update();
-	transform.position = {60,50};
-	collision_system.update();
-	transform.position = {61,50};
-	collision_system.update();
-}
+	EXPECT_EQ(transform.position.y, 0);
+
+	system.update();
+	EXPECT_EQ(transform.position.y, 1);
 
+	system.update();
+	EXPECT_EQ(transform.position.y, 3);
+}
-- 
cgit v1.2.3


From 02cdbd367d701d8d858806f45bfe2f15b392bb59 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 20 Nov 2024 11:37:49 +0100
Subject: made test function and fixed static value

---
 src/example/game.cpp       |  5 ++--
 src/test/CollisionTest.cpp | 60 +++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 56 insertions(+), 9 deletions(-)

(limited to 'src/example')

diff --git a/src/example/game.cpp b/src/example/game.cpp
index a9f6103..b6a0c31 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -26,7 +26,6 @@ class MyScript : public Script {
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
-		
 	}
 };
 
@@ -35,8 +34,8 @@ public:
 	using Scene::Scene;
 
 	void load_scene() {
-		ComponentManager & mgr = this->component_manager;
-		Color color(0, 0, 0, 0);
+	ComponentManager & mgr = this->component_manager;
+	Color color(0, 0, 0, 0);
 
 	double screen_size_width = 640;
 	double screen_size_height = 480;
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 3c2ee6e..5da26cc 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,3 +1,4 @@
+#include <cstddef>
 #include <gtest/gtest.h>
 
 #include <crepe/api/Config.h>
@@ -9,7 +10,8 @@
 #include <crepe/api/Script.h>
 
 #include <crepe/ComponentManager.h>
-#include <crepe/system/PhysicsSystem.h>
+#include <crepe/system/CollisionSystem.h>
+#include <type_traits>
 
 
 using namespace std;
@@ -19,10 +21,10 @@ using namespace crepe;
 
 class MyScript : public Script {
 	public:
-		static crepe::CollisionSystem::CollisionInfo last_collision_info;
+		static const crepe::CollisionSystem::CollisionInfo* last_collision_info;
 	private:
 		static bool oncollision(const CollisionEvent& test) {
-			std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+			last_collision_info = &test.info;
 			return true;
 		}
 		void init() {
@@ -37,14 +39,60 @@ class MyScript : public Script {
 class CollisionTest : public ::testing::Test {
 public:
 	ComponentManager component_manager;
-	PhysicsSystem system{component_manager};
+	CollisionSystem system{component_manager};
 	
 	void SetUp() override {
+		MyScript::last_collision_info = nullptr;
 		ComponentManager & mgr = this->component_manager;
+		if(mgr.get_components_by_id<Transform>(0).empty())
+		{
+			create_test_world();
+			create_test_components();
+		}
+		reset_test_components();
+	}
+
+	void create_test_world() {
+		double screen_size_width = 640;
+		double screen_size_height = 480;
+		double world_collider = 1000;
+		ComponentManager & mgr = this->component_manager;
+		GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+		world.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 0,
+			.gravity_scale = 0,
+			.body_type = Rigidbody::BodyType::STATIC,
+			.constraints = {0, 0, 0},
+			.use_gravity = false,
+			.bounce = false,
+			.offset = {0,0}
+		});
+		world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
+		world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+		world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+		world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
+	}
+
+	void create_test_components()
+	{
+
+	}
+
+	void reset_test_components()
+	{
+
 	}
 };
 
 TEST_F(CollisionTest, collision) {
-//read static data
-const CollisionEvent& test = MyScript::last_collision_info;
+	// change object data before calling update
+
+	// call collision system update
+	system.update();
+	// should not be nullptr after update
+	ASSERT_NE(MyScript::last_collision_info, nullptr);
+
+	// check if values are correct
+	EXPECT_EQ(MyScript::last_collision_info->first.collider.game_object_id, 1);
+	EXPECT_EQ(MyScript::last_collision_info->second.collider.game_object_id, 2);
 }
-- 
cgit v1.2.3


From 37a38c8c9b1b78d214d8e26d45d5a85dc7bd89bd Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 20 Nov 2024 15:14:44 +0100
Subject: changed test

---
 src/crepe/system/CollisionSystem.cpp |   2 +-
 src/example/CMakeLists.txt           |   2 -
 src/test/CollisionTest.cpp           | 157 ++++++++++++++++++++++++++++-------
 3 files changed, 130 insertions(+), 31 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 3e73b44..2132b0d 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -205,7 +205,7 @@ std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::Collide
 		Rigidbody& rigidbody1 = mgr.get_components_by_id<Rigidbody>(game_object_id_1).front().get();
 		if(!rigidbody1.active) continue;
 		
-		// Check CircleCollider vs CircleCollider
+		// Check BoxCollider vs BoxCollider
 		for (size_t j = i + 1; j < boxcolliders.size(); ++j) {
 			if(!boxcolliders[j].get().active) continue;
 			// Skip self collision
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 2facc4d..c5cb63f 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -22,7 +22,6 @@ add_example(script)
 add_example(log)
 add_example(rendering)
 add_example(asset_manager)
-add_example(physics)
 add_example(savemgr)
 add_example(proxy)
 add_example(db)
@@ -30,6 +29,5 @@ add_example(ecs)
 add_example(scene_manager)
 add_example(game)
 add_example(events)
-add_example(particles)
 add_example(gameloop)
 
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 5da26cc..7aadfa6 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -1,4 +1,5 @@
-#include <cstddef>
+#include "system/ScriptSystem.h"
+#include "types.h"
 #include <gtest/gtest.h>
 
 #include <crepe/api/Config.h>
@@ -11,38 +12,52 @@
 
 #include <crepe/ComponentManager.h>
 #include <crepe/system/CollisionSystem.h>
-#include <type_traits>
-
+#include "iostream"
 
 using namespace std;
 using namespace std::chrono_literals;
 using namespace crepe;
 
+//scripts for object 1 collision test
+class UnitTestBoxBoxCollision1 : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "collision event 1" << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
+};
 
-class MyScript : public Script {
-	public:
-		static const crepe::CollisionSystem::CollisionInfo* last_collision_info;
-	private:
-		static bool oncollision(const CollisionEvent& test) {
-			last_collision_info = &test.info;
-			return true;
-		}
-		void init() {
-			EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
-		}
-		void update() {
-			// Retrieve component from the same GameObject this script is on
-			
-		}
+//scripts for object 1 collision test
+class UnitTestBoxBoxCollision2 : public Script {
+	static bool oncollision(const CollisionEvent& test) {
+		std::cout << "collision event 1" << std::endl;
+		return true;
+	}
+	void init() {
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+		
+	}
 };
 
 class CollisionTest : public ::testing::Test {
 public:
 	ComponentManager component_manager;
 	CollisionSystem system{component_manager};
+	ScriptSystem sr{component_manager};
+	const double screen_size_width = 640;
+	const double screen_size_height = 480;
+	const double world_collider = 1000;
 	
 	void SetUp() override {
-		MyScript::last_collision_info = nullptr;
 		ComponentManager & mgr = this->component_manager;
 		if(mgr.get_components_by_id<Transform>(0).empty())
 		{
@@ -50,12 +65,11 @@ public:
 			create_test_components();
 		}
 		reset_test_components();
+		sr.update();
 	}
 
 	void create_test_world() {
-		double screen_size_width = 640;
-		double screen_size_height = 480;
-		double world_collider = 1000;
+		
 		ComponentManager & mgr = this->component_manager;
 		GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
 		world.add_component<Rigidbody>(Rigidbody::Data{
@@ -75,24 +89,111 @@ public:
 
 	void create_test_components()
 	{
+		ComponentManager & mgr = this->component_manager;
+		GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+		game_object1.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 0.01,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.linear_velocity = {1,0},
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = true,
+		.elastisity = 1,
+		.offset = {0,0},
+		});
+		game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+		game_object1.add_component<BehaviorScript>().set_script<UnitTestBoxBoxCollision1>();
 
+		
+		GameObject game_object2 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2-100}, 0, 1);
+		game_object2.add_component<Rigidbody>(Rigidbody::Data{
+		.mass = 1,
+		.gravity_scale = 0.01,
+		.body_type = Rigidbody::BodyType::DYNAMIC,
+		.linear_velocity = {1,0},
+		.constraints = {0, 0, 0},
+		.use_gravity = true,
+		.bounce = true,
+		.elastisity = 1,
+		.offset = {0,0},
+		});
+		game_object2.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+		game_object2.add_component<BehaviorScript>().set_script<UnitTestBoxBoxCollision2>();
 	}
 
 	void reset_test_components()
 	{
+		ComponentManager & mgr = this->component_manager;
+		//game object 1
+		{
+			game_object_id_t id = 1;
+			Transform & tf = mgr.get_components_by_id<Transform>(id).front().get();
+			tf.position = Vector2{screen_size_width/2, screen_size_height/2};
+			tf.rotation = 0;
+			tf.scale = 1;
+			tf.active = 1;
+			Rigidbody & rg = mgr.get_components_by_id<Rigidbody>(id).front().get();
+			rg.data.angular_damping = 0;
+			rg.data.angular_velocity = 0;
+			rg.data.max_angular_velocity = 100;
+			rg.data.linear_velocity = {0,0};
+			rg.data.linear_damping = {0,0};
+			rg.data.max_linear_velocity = {100,100};
+			rg.data.bounce = false;
+			rg.data.elastisity = 0;
+			rg.data.offset = {0,0};
+			rg.data.constraints = {0,0,0};
+		}
 
+		{
+			game_object_id_t id = 2;
+			Transform & tf = mgr.get_components_by_id<Transform>(id).front().get();
+			tf.position = Vector2{screen_size_width/2, screen_size_height/2-100};
+			tf.rotation = 0;
+			tf.scale = 1;
+			tf.active = 1;
+			Rigidbody & rg = mgr.get_components_by_id<Rigidbody>(id).front().get();
+			rg.data.angular_damping = 0;
+			rg.data.angular_velocity = 0;
+			rg.data.max_angular_velocity = 100;
+			rg.data.linear_velocity = {0,0};
+			rg.data.linear_damping = {0,0};
+			rg.data.max_linear_velocity = {100,100};
+			rg.data.bounce = false;
+			rg.data.elastisity = 0;
+			rg.data.offset = {0,0};
+			rg.data.constraints = {0,0,0};
+		}
 	}
 };
 
-TEST_F(CollisionTest, collision) {
+TEST_F(CollisionTest, collision_example) {
 	// change object data before calling update
 
 	// call collision system update
 	system.update();
-	// should not be nullptr after update
-	ASSERT_NE(MyScript::last_collision_info, nullptr);
+	// should be nullptr after update with no collision
+	//ASSERT_EQ(MyScriptCollider1::last_collision_info_1, nullptr);
+	//ASSERT_EQ(MyScriptCollider2::last_collision_info_2, nullptr);
+	// check if values are correct (filled in data)
+	// EXPECT_EQ(MyScriptCollider1::last_collision_info->first.collider.game_object_id, 1);
+	// EXPECT_EQ(MyScriptCollider2::last_collision_info->second.collider.game_object_id, 2);
+	// check test data
+}
 
-	// check if values are correct
-	EXPECT_EQ(MyScript::last_collision_info->first.collider.game_object_id, 1);
-	EXPECT_EQ(MyScript::last_collision_info->second.collider.game_object_id, 2);
+TEST_F(CollisionTest, collision_box_box_dynamic) {
+	// change object data before calling update
+	ComponentManager & mgr = this->component_manager;
+	Transform & test = mgr.get_components_by_id<Transform>(2).front().get();
+	test.position = {screen_size_width/2,screen_size_height/2};
+	// call collision system update
+	system.update();
+	// should be nullptr after update with no collision
+	// ASSERT_NE(MyScriptCollider1::last_collision_info_1, nullptr);
+	// ASSERT_NE(MyScriptCollider2::last_collision_info_2, nullptr);
+	// // check if values are correct (filled in data)
+	// EXPECT_EQ(MyScriptCollider1::last_collision_info_1->first.collider.game_object_id, 1);
+	// EXPECT_EQ(MyScriptCollider2::last_collision_info_2->second.collider.game_object_id, 2);
+	// check test data
 }
-- 
cgit v1.2.3


From a67c52325bc8cbd264293b9dcc217fc07bfbaf57 Mon Sep 17 00:00:00 2001
From: Loek Le Blansch <loek@pipeframe.xyz>
Date: Wed, 20 Nov 2024 18:07:48 +0100
Subject: merge `master` into `loek/collision-system`

---
 Doxyfile                            |   1 +
 contributing.md                     |  23 +++-
 makefile                            |   3 +-
 src/crepe/api/Color.cpp             |  37 ++----
 src/crepe/api/Color.h               |  49 +++-----
 src/crepe/api/Sprite.h              |   3 +-
 src/crepe/facade/SDLContext.h       |   6 -
 src/crepe/system/RenderSystem.cpp   |  43 +++++--
 src/crepe/system/RenderSystem.h     |  32 +++--
 src/example/CMakeLists.txt          |   3 -
 src/example/components_internal.cpp |  51 --------
 src/example/ecs.cpp                 |  53 --------
 src/example/events.cpp              |  30 ++---
 src/example/game.cpp                |   2 +-
 src/example/rendering.cpp           |  10 +-
 src/example/scene_manager.cpp       |  79 ------------
 src/makefile                        |   7 +-
 src/test/CMakeLists.txt             |   2 +
 src/test/ECSTest.cpp                | 236 ++++++++++++++++++++++++++++++++++++
 src/test/RenderSystemTest.cpp       | 174 ++++++++++++++++++++++++++
 src/test/SceneManagerTest.cpp       | 122 +++++++++++++++++++
 21 files changed, 667 insertions(+), 299 deletions(-)
 delete mode 100644 src/example/components_internal.cpp
 delete mode 100644 src/example/ecs.cpp
 delete mode 100644 src/example/scene_manager.cpp
 create mode 100644 src/test/ECSTest.cpp
 create mode 100644 src/test/RenderSystemTest.cpp
 create mode 100644 src/test/SceneManagerTest.cpp

(limited to 'src/example')

diff --git a/Doxyfile b/Doxyfile
index 9328b24..e0a31df 100644
--- a/Doxyfile
+++ b/Doxyfile
@@ -24,6 +24,7 @@ USE_MDFILE_AS_MAINPAGE = ./readme.md
 REPEAT_BRIEF = NO
 
 INTERNAL_DOCS = YES
+EXTRACT_PRIVATE = YES
 EXTRACT_STATIC = YES
 HIDE_UNDOC_NAMESPACES = YES
 HIDE_UNDOC_CLASSES = YES
diff --git a/contributing.md b/contributing.md
index 5b0c79d..9c95851 100644
--- a/contributing.md
+++ b/contributing.md
@@ -20,7 +20,7 @@ that you can click on to open them.
 # Code style
 
 - Formatting nitty-gritty is handled by clang-format/clang-tidy (run `make
-  format` in the root folder of this repository to format all sources files)
+  format` or `make lint`)
 - <details><summary>
   ASCII only
   </summary><table><tr><th>Good</th><th>Bad</th></tr><tr><td>
@@ -798,6 +798,27 @@ that you can click on to open them.
   resolving merge conflicts when multiple sources were added by different
   people to the same CMakeLists.txt easier.
 
+## GoogleTest-specific
+
+- Unit tests are not *required* to follow all code standards
+- <details><summary>
+  Private/protected members may be accessed using preprocessor tricks
+  </summary>
+
+  ```cpp
+  // include unrelated headers before
+
+  #define private public
+  #define protected public
+
+  // headers included after *will* be affected
+  ```
+  </details>
+- Each test source file defines tests within a single test suite (first
+  parameter of `TEST()` / `TEST_F()` macro)
+- Test source files match their suite name (or test fixture name in the case of
+  tests that use a fixture)
+
 # Structure
 
 - Files are placed in the appropriate directory:
diff --git a/makefile b/makefile
index dd7c587..c46e8a5 100644
--- a/makefile
+++ b/makefile
@@ -6,5 +6,6 @@ doxygen: Doxyfile FORCE
 FMT += $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
 format: FORCE
 	clang-format -i $(FMT)
-	$(MAKE) -C src $@
 
+lint: FORCE
+	$(MAKE) -C src $@
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
index 9e5f187..29bd77a 100644
--- a/src/crepe/api/Color.cpp
+++ b/src/crepe/api/Color.cpp
@@ -2,32 +2,11 @@
 
 using namespace crepe;
 
-Color Color::white = Color(255, 255, 255, 0);
-Color Color::red = Color(255, 0, 0, 0);
-Color Color::green = Color(0, 255, 0, 0);
-Color Color::blue = Color(0, 0, 255, 0);
-Color Color::black = Color(0, 0, 0, 0);
-Color Color::cyan = Color(0, 255, 255, 0);
-Color Color::yellow = Color(255, 255, 0, 0);
-Color Color::magenta = Color(255, 0, 255, 0);
-
-Color::Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha) {
-	this->a = alpha;
-	this->r = red;
-	this->g = green;
-	this->b = blue;
-};
-
-const Color & Color::get_white() { return Color::white; };
-
-const Color & Color::get_red() { return Color::red; };
-const Color & Color::get_green() { return Color::green; };
-const Color & Color::get_blue() { return Color::blue; };
-
-const Color & Color::get_black() { return Color::black; };
-
-const Color & Color::get_cyan() { return Color::cyan; };
-
-const Color & Color::get_yellow() { return Color::yellow; };
-
-const Color & Color::get_magenta() { return Color::magenta; };
+const Color Color::WHITE{0xff, 0xff, 0xff};
+const Color Color::RED{0xff, 0x00, 0x00};
+const Color Color::GREEN{0x00, 0xff, 0x00};
+const Color Color::BLUE{0x00, 0x00, 0xff};
+const Color Color::BLACK{0x00, 0x00, 0x00};
+const Color Color::CYAN{0x00, 0xff, 0xff};
+const Color Color::YELLOW{0xff, 0xff, 0x00};
+const Color Color::MAGENTA{0xff, 0x00, 0xff};
diff --git a/src/crepe/api/Color.h b/src/crepe/api/Color.h
index aa47bf4..84edb5c 100644
--- a/src/crepe/api/Color.h
+++ b/src/crepe/api/Color.h
@@ -4,41 +4,20 @@
 
 namespace crepe {
 
-// TODO: make Color a struct w/o constructors/destructors
-class Color {
-
-	// FIXME: can't these colors be defined as a `static constexpr const Color`
-	// instead?
-
-public:
-	Color(uint8_t red, uint8_t green, uint8_t blue, uint8_t alpha);
-	static const Color & get_white();
-	static const Color & get_red();
-	static const Color & get_green();
-	static const Color & get_blue();
-	static const Color & get_cyan();
-	static const Color & get_magenta();
-	static const Color & get_yellow();
-	static const Color & get_black();
-
-private:
-	// TODO: why are these private!?
-	uint8_t r;
-	uint8_t g;
-	uint8_t b;
-	uint8_t a;
-
-	static Color white;
-	static Color red;
-	static Color green;
-	static Color blue;
-	static Color cyan;
-	static Color magenta;
-	static Color yellow;
-	static Color black;
-
-private:
-	friend class SDLContext;
+struct Color {
+	uint8_t r = 0x00;
+	uint8_t g = 0x00;
+	uint8_t b = 0x00;
+	uint8_t a = 0xff;
+
+	static const Color WHITE;
+	static const Color RED;
+	static const Color GREEN;
+	static const Color BLUE;
+	static const Color CYAN;
+	static const Color MAGENTA;
+	static const Color YELLOW;
+	static const Color BLACK;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 0192793..74a55d4 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -2,8 +2,9 @@
 
 #include <memory>
 
+#include "../Component.h"
+
 #include "Color.h"
-#include "Component.h"
 #include "Texture.h"
 
 namespace crepe {
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 007092b..652a83e 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -21,9 +21,6 @@ namespace crepe {
 // typedef is unusable when crepe is packaged. Wouter will fix this later.
 typedef SDL_Keycode CREPE_KEYCODES;
 
-class Texture;
-class LoopManager;
-
 /**
  * \class SDLContext
  * \brief Facade for the SDL library
@@ -91,9 +88,6 @@ private:
 	//! Will use the funtions: texture_from_path, get_width,get_height.
 	friend class Texture;
 
-	//! Will use the funtions: texture_from_path, get_width,get_height.
-	friend class Animator;
-
 	/**
 	 * \brief Loads a texture from a file path.
 	 * \param path Path to the image file.
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index fa3d0de..96c5f27 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -1,38 +1,59 @@
+#include <algorithm>
+#include <cassert>
 #include <functional>
+#include <stdexcept>
 #include <vector>
 
 #include "../ComponentManager.h"
 #include "../api/Sprite.h"
 #include "../api/Transform.h"
 #include "../facade/SDLContext.h"
-#include "../util/Log.h"
 
 #include "RenderSystem.h"
 
 using namespace crepe;
+using namespace std;
 
-void RenderSystem::clear_screen() const { SDLContext::get_instance().clear_screen(); }
+void RenderSystem::clear_screen() { this->context.clear_screen(); }
 
-void RenderSystem::present_screen() const { SDLContext::get_instance().present_screen(); }
+void RenderSystem::present_screen() { this->context.present_screen(); }
 void RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
 	std::vector<std::reference_wrapper<Camera>> cameras = mgr.get_components_by_type<Camera>();
 
+	if (cameras.size() == 0) throw std::runtime_error("No cameras in current scene");
+
 	for (Camera & cam : cameras) {
-		SDLContext::get_instance().camera(cam);
-		this->curr_cam = &cam;
+		this->context.camera(cam);
+		this->curr_cam_ref = &cam;
 	}
 }
-void RenderSystem::render_sprites() const {
-	ComponentManager & mgr = this->component_manager;
 
-	std::vector<std::reference_wrapper<Sprite>> sprites = mgr.get_components_by_type<Sprite>();
+bool sorting_comparison(const Sprite & a, const Sprite & b) {
+	if (a.sorting_in_layer < b.sorting_in_layer) return true;
+	if (a.sorting_in_layer == b.sorting_in_layer) return a.order_in_layer < b.order_in_layer;
+
+	return false;
+}
+
+std::vector<std::reference_wrapper<Sprite>>
+RenderSystem::sort(std::vector<std::reference_wrapper<Sprite>> & objs) {
+
+	std::vector<std::reference_wrapper<Sprite>> sorted_objs(objs);
+	std::sort(sorted_objs.begin(), sorted_objs.end(), sorting_comparison);
+
+	return sorted_objs;
+}
+
+void RenderSystem::render_sprites() {
+	ComponentManager & mgr = this->component_manager;
+	vector<reference_wrapper<Sprite>> sprites = mgr.get_components_by_type<Sprite>();
+	vector<reference_wrapper<Sprite>> sorted_sprites = this->sort(sprites);
 
-	SDLContext & render = SDLContext::get_instance();
-	for (const Sprite & sprite : sprites) {
+	for (const Sprite & sprite : sorted_sprites) {
 		auto transforms = mgr.get_components_by_id<Transform>(sprite.game_object_id);
-		render.draw(sprite, transforms[0], *curr_cam);
+		this->context.draw(sprite, transforms[0], *this->curr_cam_ref);
 	}
 }
 
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 87ec494..57b9c73 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -1,18 +1,23 @@
 #pragma once
 
-#include "api/Camera.h"
+#include <functional>
+#include <vector>
+
+#include "facade/SDLContext.h"
 
 #include "System.h"
 
 namespace crepe {
 
+class Camera;
+class Sprite;
+
 /**
  * \class RenderSystem
  * \brief Manages rendering operations for all game objects.
  *
- * RenderSystem is responsible for rendering sprites, clearing and presenting the screen, and
- * managing the active camera. It functions as a singleton, providing centralized rendering
- * services for the application.
+ * RenderSystem is responsible for rendering, clearing and presenting the screen, and
+ * managing the active camera. 
  */
 class RenderSystem : public System {
 public:
@@ -25,16 +30,25 @@ public:
 
 private:
 	//! Clears the screen in preparation for rendering.
-	void clear_screen() const;
+	void clear_screen();
 
 	//! Presents the rendered frame to the display.
-	void present_screen() const;
+	void present_screen();
 
 	//! Updates the active camera used for rendering.
 	void update_camera();
 
 	//! Renders all active sprites to the screen.
-	void render_sprites() const;
+	void render_sprites();
+
+	/**
+	 * \brief sort a vector sprite objects with
+	 *
+	 * \param objs the vector that will do a sorting algorithm on 
+	 * \return returns a sorted reference vector
+	 */
+	std::vector<std::reference_wrapper<Sprite>>
+	sort(std::vector<std::reference_wrapper<Sprite>> & objs);
 
 	/**
 	 * \todo Include color handling for sprites.
@@ -48,8 +62,10 @@ private:
 
 private:
 	//! Pointer to the current active camera for rendering
-	Camera * curr_cam = nullptr;
+	Camera * curr_cam_ref = nullptr;
 	// TODO: needs a better solution
+
+	SDLContext & context = SDLContext::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index c5cb63f..045f4d4 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -17,7 +17,6 @@ function(add_example target_name)
 endfunction()
 
 add_example(audio_internal)
-# add_example(components_internal)
 add_example(script)
 add_example(log)
 add_example(rendering)
@@ -25,8 +24,6 @@ add_example(asset_manager)
 add_example(savemgr)
 add_example(proxy)
 add_example(db)
-add_example(ecs)
-add_example(scene_manager)
 add_example(game)
 add_example(events)
 add_example(gameloop)
diff --git a/src/example/components_internal.cpp b/src/example/components_internal.cpp
deleted file mode 100644
index 2a232a9..0000000
--- a/src/example/components_internal.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/** \file
- * 
- * Standalone example for usage of the internal ECS
- */
-
-#include <cassert>
-#include <chrono>
-
-#include <crepe/Component.h>
-#include <crepe/ComponentManager.h>
-
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Rigidbody.h>
-#include <crepe/api/Sprite.h>
-
-#include <crepe/util/Log.h>
-
-using namespace crepe;
-using namespace std;
-
-#define OBJ_COUNT 100000
-
-int main() {
-	dbg_trace();
-
-	ComponentManager mgr{};
-
-	auto start_adding = chrono::high_resolution_clock::now();
-
-	for (int i = 0; i < OBJ_COUNT; ++i) {
-		GameObject obj = mgr.new_object("Name", "Tag");
-		obj.add_component<Sprite>("test");
-		obj.add_component<Rigidbody>(0, 0, i);
-	}
-
-	auto stop_adding = chrono::high_resolution_clock::now();
-
-	auto sprites = mgr.get_components_by_type<Sprite>();
-	for (auto sprite : sprites) {
-		assert(true);
-	}
-
-	auto stop_looping = chrono::high_resolution_clock::now();
-
-	auto add_time = chrono::duration_cast<chrono::microseconds>(stop_adding - start_adding);
-	auto loop_time = chrono::duration_cast<chrono::microseconds>(stop_looping - stop_adding);
-	printf("add time:  %ldus\n", add_time.count());
-	printf("loop time: %ldus\n", loop_time.count());
-
-	return 0;
-}
diff --git a/src/example/ecs.cpp b/src/example/ecs.cpp
deleted file mode 100644
index d5ba51b..0000000
--- a/src/example/ecs.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include <iostream>
-
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Metadata.h>
-#include <crepe/api/Transform.h>
-
-using namespace crepe;
-using namespace std;
-
-int main() {
-	ComponentManager mgr{};
-
-	// Create a few GameObjects
-	try {
-		GameObject body = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
-		GameObject right_leg = mgr.new_object("rightLeg", "person", Vector2{1, 1}, 0, 1);
-		GameObject left_leg = mgr.new_object("leftLeg", "person", Vector2{1, 1}, 0, 1);
-		GameObject right_foot = mgr.new_object("rightFoot", "person", Vector2{2, 2}, 0, 1);
-		GameObject left_foot = mgr.new_object("leftFoot", "person", Vector2{2, 2}, 0, 1);
-
-		// Set the parent of each GameObject
-		right_foot.set_parent(right_leg);
-		left_foot.set_parent(left_leg);
-		right_leg.set_parent(body);
-		left_leg.set_parent(body);
-
-		// Adding a second Transform component is not allowed and will invoke an exception
-		body.add_component<Transform>(Vector2{10, 10}, 0, 1);
-	} catch (const exception & e) {
-		cerr << e.what() << endl;
-	}
-
-	// Get the Metadata and Transform components of each GameObject
-	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
-	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
-
-	// Print the Metadata and Transform components
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << " Parent: " << m.get().parent << " Children: ";
-		for (auto & c : m.get().children) {
-			cout << c << " ";
-		}
-		cout << endl;
-	}
-	for (auto & t : transform) {
-		cout << "Id: " << t.get().game_object_id << " Position: [" << t.get().position.x
-			 << ", " << t.get().position.y << "]" << endl;
-	}
-
-	return 0;
-}
diff --git a/src/example/events.cpp b/src/example/events.cpp
index ed519ff..e6d91aa 100644
--- a/src/example/events.cpp
+++ b/src/example/events.cpp
@@ -2,7 +2,7 @@
 
 #include <crepe/ComponentManager.h>
 #include <crepe/system/ScriptSystem.h>
-#include <crepe/util/log.h>
+#include <crepe/util/Log.h>
 
 #include <crepe/api/BehaviorScript.h>
 #include <crepe/api/Config.h>
@@ -65,6 +65,10 @@ public:
 	}
 };
 int main() {
+	EventManager & evmgr = EventManager::get_instance();
+	ComponentManager mgr{};
+	ScriptSystem sys{mgr};
+
 	// two events to trigger
 	KeyPressEvent key_press;
 	key_press.key = Keycode::A;
@@ -74,22 +78,19 @@ int main() {
 	click_event.mouse_x = 100;
 	click_event.mouse_y = 200;
 	// queue events to test queue
-	EventManager::get_instance().queue_event<KeyPressEvent>(
-		std::move(key_press), 0);
-	EventManager::get_instance().queue_event<MouseClickEvent>(
-		std::move(click_event), 0);
+	evmgr.queue_event<KeyPressEvent>(std::move(key_press), 0);
+	evmgr.queue_event<MouseClickEvent>(std::move(click_event), 0);
 	{
 		TestKeyListener test_listener;
 		test_listener.set_channel(1);
-		auto obj = GameObject(0, "name", "tag", Vector2{1.2, 3.4}, 0, 1);
+		auto obj = mgr.new_object("name", "tag", Vector2{1.2, 3.4}, 0, 1);
 		obj.add_component<BehaviorScript>().set_script<MyScript>();
 
-		ScriptSystem sys;
 		sys.update();
 
 		// Trigger the events while `testListener` is in scope
-		EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 1);
-		EventManager::get_instance().trigger_event(MouseClickEvent{
+		evmgr.trigger_event<KeyPressEvent>(key_press, 1);
+		evmgr.trigger_event(MouseClickEvent{
     		.mouse_x = 100,
     		.mouse_y = 100,
     		.button = MouseButton::LEFT_MOUSE,
@@ -100,14 +101,13 @@ int main() {
 		std::cout << "lambda test" << std::endl;
 		return false;
 	};
-	EventManager::get_instance().subscribe<KeyPressEvent>(
-		std::move(event_handler), 0);
+	evmgr.subscribe<KeyPressEvent>(std::move(event_handler), 0);
 	// testing trigger with testListener not in scope (unsubscribed)
-	EventManager::get_instance().trigger_event<KeyPressEvent>(key_press, 0);
-	EventManager::get_instance().trigger_event<MouseClickEvent>(click_event, 0);
+	evmgr.trigger_event<KeyPressEvent>(key_press, 0);
+	evmgr.trigger_event<MouseClickEvent>(click_event, 0);
 	// dispatching queued events
-	EventManager::get_instance().dispatch_events();
+	evmgr.dispatch_events();
 
-	EventManager::get_instance().unsubscribe<KeyPressEvent>(event_handler, 0);
+	evmgr.unsubscribe<KeyPressEvent>(event_handler, 0);
 	return EXIT_SUCCESS;
 }
diff --git a/src/example/game.cpp b/src/example/game.cpp
index b6a0c31..a557be7 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -74,7 +74,7 @@ public:
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 	FlipSettings{true, true});
-	game_object1.add_component<Camera>(Color::get_white());
+	game_object1.add_component<Camera>(Color::WHITE);
 	}
 };
 
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
index 14ecaa9..9e3c8cc 100644
--- a/src/example/rendering.cpp
+++ b/src/example/rendering.cpp
@@ -30,13 +30,13 @@ int main() {
 	// Normal adding components
 	{
 		Color color(0, 0, 0, 0);
-		obj.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+		obj.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
 								  FlipSettings{false, false});
-		obj.add_component<Camera>(Color::get_red());
+		obj.add_component<Camera>(Color::RED);
 	}
 	{
 		Color color(0, 0, 0, 0);
-		obj1.add_component<Sprite>(make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
+		obj1.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
 								   FlipSettings{true, true});
 	}
 
@@ -48,8 +48,12 @@ int main() {
 	}
 	*/
 
+	sys.update();
+	/*
+
 	auto start = std::chrono::steady_clock::now();
 	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
 		sys.update();
 	}
+	*/
 }
diff --git a/src/example/scene_manager.cpp b/src/example/scene_manager.cpp
deleted file mode 100644
index accec7d..0000000
--- a/src/example/scene_manager.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-#include <iostream>
-
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Metadata.h>
-#include <crepe/api/Scene.h>
-#include <crepe/api/SceneManager.h>
-#include <crepe/api/Vector2.h>
-
-using namespace crepe;
-using namespace std;
-
-class ConcreteScene1 : public Scene {
-public:
-	using Scene::Scene;
-
-	void load_scene() {
-		auto & mgr = this->component_manager;
-		GameObject object1 = mgr.new_object("scene_1", "tag_scene_1", Vector2{0, 0}, 0, 1);
-		GameObject object2 = mgr.new_object("scene_1", "tag_scene_1", Vector2{1, 0}, 0, 1);
-		GameObject object3 = mgr.new_object("scene_1", "tag_scene_1", Vector2{2, 0}, 0, 1);
-	}
-};
-
-class ConcreteScene2 : public Scene {
-public:
-	using Scene::Scene;
-
-	void load_scene() {
-		auto & mgr = this->component_manager;
-		GameObject object1 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 0}, 0, 1);
-		GameObject object2 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 1}, 0, 1);
-		GameObject object3 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 2}, 0, 1);
-		GameObject object4 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 3}, 0, 1);
-	}
-};
-
-int main() {
-	ComponentManager component_mgr{};
-	SceneManager scene_mgr{component_mgr};
-
-	// Add the scenes to the scene manager
-	scene_mgr.add_scene<ConcreteScene1>("scene1");
-	scene_mgr.add_scene<ConcreteScene2>("scene2");
-
-	// There is no need to call set_next_scene() at the beginnen, because the first scene will be
-	// automatically set as the next scene
-
-	// Load scene1 (the first scene added)
-	scene_mgr.load_next_scene();
-
-	// Get the Metadata components of each GameObject of Scene1
-	vector<reference_wrapper<Metadata>> metadata
-		= component_mgr.get_components_by_type<Metadata>();
-
-	cout << "Metadata components of Scene1:" << endl;
-	// Print the Metadata
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << endl;
-	}
-
-	// Set scene2 as the next scene
-	scene_mgr.set_next_scene("scene2");
-	// Load scene2
-	scene_mgr.load_next_scene();
-
-	// Get the Metadata components of each GameObject of Scene2
-	metadata = component_mgr.get_components_by_type<Metadata>();
-
-	cout << "Metadata components of Scene2:" << endl;
-	// Print the Metadata
-	for (auto & m : metadata) {
-		cout << "Id: " << m.get().game_object_id << " Name: " << m.get().name
-			 << " Tag: " << m.get().tag << endl;
-	}
-
-	return 0;
-}
diff --git a/src/makefile b/src/makefile
index 5f80204..a0e8f02 100644
--- a/src/makefile
+++ b/src/makefile
@@ -1,6 +1,9 @@
 .PHONY: FORCE
 
-FMT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
 format: FORCE
-	clang-tidy -p build/compile_commands.json --fix-errors $(FMT)
+	$(MAKE) -C .. $@
+
+LINT := $(shell git ls-files '*.c' '*.cpp' '*.h' '*.hpp')
+lint: FORCE
+	clang-tidy -p build/compile_commands.json --fix-errors $(LINT)
 
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index f830165..14c5123 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -4,5 +4,7 @@ target_sources(test_main PUBLIC
 	PhysicsTest.cpp
 	ScriptTest.cpp
 	ParticleTest.cpp
+	ECSTest.cpp
+	SceneManagerTest.cpp
 )
 
diff --git a/src/test/ECSTest.cpp b/src/test/ECSTest.cpp
new file mode 100644
index 0000000..d5a5826
--- /dev/null
+++ b/src/test/ECSTest.cpp
@@ -0,0 +1,236 @@
+#include <gtest/gtest.h>
+
+#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>
+
+using namespace std;
+using namespace crepe;
+
+class ECSTest : public ::testing::Test {
+public:
+	ComponentManager mgr{};
+};
+
+TEST_F(ECSTest, createGameObject) {
+	GameObject obj = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+TEST_F(ECSTest, deleteAllGameObjects) {
+	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+
+	mgr.delete_all_components();
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 0);
+	EXPECT_EQ(transform.size(), 0);
+
+	GameObject obj2 = mgr.new_object("body2", "person2", Vector2{1, 0}, 5, 1);
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "body2");
+	EXPECT_EQ(metadata[0].get().tag, "person2");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 0);
+	EXPECT_EQ(transform[0].get().position.x, 1);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 5);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+TEST_F(ECSTest, deleteGameObject) {
+	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+
+	mgr.delete_all_components_of_id(0);
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 1);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 1);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+TEST_F(ECSTest, manyGameObjects) {
+	for (int i = 0; i < 5000; i++) {
+		GameObject obj = mgr.new_object("body", "person", Vector2{0, 0}, 0, i);
+	}
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 5000);
+	EXPECT_EQ(transform.size(), 5000);
+	for (int i = 0; i < 5000; i++) {
+		EXPECT_EQ(metadata[i].get().game_object_id, i);
+		EXPECT_EQ(metadata[i].get().name, "body");
+		EXPECT_EQ(metadata[i].get().tag, "person");
+		EXPECT_EQ(metadata[i].get().parent, -1);
+		EXPECT_EQ(metadata[i].get().children.size(), 0);
+
+		EXPECT_EQ(transform[i].get().game_object_id, i);
+		EXPECT_EQ(transform[i].get().position.x, 0);
+		EXPECT_EQ(transform[i].get().position.y, 0);
+		EXPECT_EQ(transform[i].get().rotation, 0);
+		EXPECT_EQ(transform[i].get().scale, i);
+	}
+
+	mgr.delete_components<Metadata>();
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 0);
+	EXPECT_EQ(transform.size(), 5000);
+
+	for (int i = 0; i < 10000 - 5000; i++) {
+		string tag = "person" + to_string(i);
+		GameObject obj = mgr.new_object("body", tag, Vector2{0, 0}, i, 0);
+	}
+
+	metadata = mgr.get_components_by_type<Metadata>();
+	transform = mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 10000 - 5000);
+	EXPECT_EQ(transform.size(), 10000);
+}
+
+TEST_F(ECSTest, getComponentsByID) {
+	GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+	GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_id<Metadata>(0);
+	vector<reference_wrapper<Transform>> transform = mgr.get_components_by_id<Transform>(1);
+
+	EXPECT_EQ(metadata.size(), 1);
+	EXPECT_EQ(transform.size(), 1);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[0].get().tag, "person");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+
+	EXPECT_EQ(transform[0].get().game_object_id, 1);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+	EXPECT_EQ(transform[0].get().rotation, 0);
+	EXPECT_EQ(transform[0].get().scale, 1);
+}
+
+TEST_F(ECSTest, tooMuchComponents) {
+	try {
+		GameObject obj0 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+		obj0.add_component<Transform>(Vector2{10, 10}, 0, 1);
+	} catch (const exception & e) {
+		EXPECT_EQ(e.what(),
+				  string("Exceeded maximum number of instances for this component type"));
+	}
+
+	try {
+		GameObject obj1 = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+		obj1.add_component<Metadata>("body", "person");
+	} catch (const exception & e) {
+		EXPECT_EQ(e.what(),
+				  string("Exceeded maximum number of instances for this component type"));
+	}
+
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+
+	EXPECT_EQ(metadata.size(), 2);
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[1].get().name, "body");
+}
+
+TEST_F(ECSTest, partentChild) {
+	{
+		GameObject body = mgr.new_object("body", "person", Vector2{0, 0}, 0, 1);
+		GameObject right_leg = mgr.new_object("rightLeg", "person", Vector2{1, 1}, 0, 1);
+		GameObject left_leg = mgr.new_object("leftLeg", "person", Vector2{1, 1}, 0, 1);
+		GameObject right_foot = mgr.new_object("rightFoot", "person", Vector2{2, 2}, 0, 1);
+		GameObject left_foot = mgr.new_object("leftFoot", "person", Vector2{2, 2}, 0, 1);
+
+		// Set the parent of each GameObject
+		right_foot.set_parent(right_leg);
+		left_foot.set_parent(left_leg);
+		right_leg.set_parent(body);
+		left_leg.set_parent(body);
+	}
+
+	// Get the Metadata and Transform components of each GameObject
+	vector<reference_wrapper<Metadata>> metadata = mgr.get_components_by_type<Metadata>();
+
+	// Check IDs
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[3].get().game_object_id, 3);
+	EXPECT_EQ(metadata[4].get().game_object_id, 4);
+
+	// Check the parent-child relationships
+	EXPECT_EQ(metadata[0].get().name, "body");
+	EXPECT_EQ(metadata[1].get().name, "rightLeg");
+	EXPECT_EQ(metadata[2].get().name, "leftLeg");
+	EXPECT_EQ(metadata[3].get().name, "rightFoot");
+	EXPECT_EQ(metadata[4].get().name, "leftFoot");
+
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().parent, 0);
+	EXPECT_EQ(metadata[2].get().parent, 0);
+	EXPECT_EQ(metadata[3].get().parent, 1);
+	EXPECT_EQ(metadata[4].get().parent, 2);
+
+	EXPECT_EQ(metadata[0].get().children.size(), 2);
+	EXPECT_EQ(metadata[1].get().children.size(), 1);
+	EXPECT_EQ(metadata[2].get().children.size(), 1);
+	EXPECT_EQ(metadata[3].get().children.size(), 0);
+	EXPECT_EQ(metadata[4].get().children.size(), 0);
+
+	EXPECT_EQ(metadata[0].get().children[0], 1);
+	EXPECT_EQ(metadata[0].get().children[1], 2);
+	EXPECT_EQ(metadata[1].get().children[0], 3);
+	EXPECT_EQ(metadata[2].get().children[0], 4);
+}
diff --git a/src/test/RenderSystemTest.cpp b/src/test/RenderSystemTest.cpp
new file mode 100644
index 0000000..ac479d3
--- /dev/null
+++ b/src/test/RenderSystemTest.cpp
@@ -0,0 +1,174 @@
+#include "api/Camera.h"
+#include <functional>
+#include <gtest/gtest.h>
+#include <memory>
+#include <vector>
+
+#define private public
+#define protected public
+
+#include <crepe/ComponentManager.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+
+#include <crepe/system/RenderSystem.h>
+
+using namespace std;
+using namespace crepe;
+using namespace testing;
+
+class RenderSystemTest : public Test {
+public:
+	ComponentManager mgr{};
+	RenderSystem sys{mgr};
+	GameObject entity1 = this->mgr.new_object("name");
+	GameObject entity2 = this->mgr.new_object("name");
+	GameObject entity3 = this->mgr.new_object("name");
+	GameObject entity4 = this->mgr.new_object("name");
+
+	void SetUp() override {
+		auto & sprite1
+			= entity1.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite1.sprite_image.get(), nullptr);
+		sprite1.order_in_layer = 5;
+		sprite1.sorting_in_layer = 5;
+		EXPECT_EQ(sprite1.order_in_layer, 5);
+		EXPECT_EQ(sprite1.sorting_in_layer, 5);
+		auto & sprite2
+			= entity2.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite2.sprite_image.get(), nullptr);
+		sprite2.sorting_in_layer = 2;
+		sprite2.order_in_layer = 1;
+
+		EXPECT_EQ(sprite2.sorting_in_layer, 2);
+		EXPECT_EQ(sprite2.order_in_layer, 1);
+
+		auto & sprite3
+			= entity3.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite3.sprite_image.get(), nullptr);
+		sprite3.sorting_in_layer = 1;
+		sprite3.order_in_layer = 2;
+
+		EXPECT_EQ(sprite3.sorting_in_layer, 1);
+		EXPECT_EQ(sprite3.order_in_layer, 2);
+
+		auto & sprite4
+			= entity4.add_component<Sprite>(make_shared<Texture>("../asset/texture/img.png"),
+											Color(0, 0, 0, 0), FlipSettings{false, false});
+		ASSERT_NE(sprite4.sprite_image.get(), nullptr);
+		sprite4.sorting_in_layer = 1;
+		sprite4.order_in_layer = 1;
+		EXPECT_EQ(sprite4.sorting_in_layer, 1);
+		EXPECT_EQ(sprite4.order_in_layer, 1);
+	}
+};
+
+TEST_F(RenderSystemTest, expected_throws) {
+	GameObject entity1 = this->mgr.new_object("NAME");
+
+	// no texture img
+	EXPECT_ANY_THROW({
+		entity1.add_component<Sprite>(make_shared<Texture>("NO_IMAGE"), Color(0, 0, 0, 0),
+									  FlipSettings{false, false});
+	});
+
+	// No camera
+	EXPECT_ANY_THROW({ this->sys.update(); });
+}
+
+TEST_F(RenderSystemTest, make_sprites) {}
+
+TEST_F(RenderSystemTest, sorting_sprites) {
+	vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+	ASSERT_EQ(sprites.size(), 4);
+
+	vector<reference_wrapper<Sprite>> sorted_sprites = this->sys.sort(sprites);
+	ASSERT_EQ(sorted_sprites.size(), 4);
+
+	// Expected order after sorting:
+	// 1. sorting_in_layer: 1, order_in_layer: 1 (entity4)
+	// 2. sorting_in_layer: 1, order_in_layer: 2 (entity3)
+	// 3. sorting_in_layer: 2, order_in_layer: 1 (entity2)
+	// 4. sorting_in_layer: 5, order_in_layer: 5 (entity1)
+
+	EXPECT_EQ(sorted_sprites[0].get().sorting_in_layer, 1);
+	EXPECT_EQ(sorted_sprites[0].get().order_in_layer, 1);
+
+	EXPECT_EQ(sorted_sprites[1].get().sorting_in_layer, 1);
+	EXPECT_EQ(sorted_sprites[1].get().order_in_layer, 2);
+
+	EXPECT_EQ(sorted_sprites[2].get().sorting_in_layer, 2);
+	EXPECT_EQ(sorted_sprites[2].get().order_in_layer, 1);
+
+	EXPECT_EQ(sorted_sprites[3].get().sorting_in_layer, 5);
+	EXPECT_EQ(sorted_sprites[3].get().order_in_layer, 5);
+
+	for (size_t i = 1; i < sorted_sprites.size(); ++i) {
+		const Sprite & prev = sorted_sprites[i - 1].get();
+		const Sprite & curr = sorted_sprites[i].get();
+
+		if (prev.sorting_in_layer == curr.sorting_in_layer) {
+			EXPECT_LE(prev.order_in_layer, curr.order_in_layer);
+		} else {
+			EXPECT_LE(prev.sorting_in_layer, curr.sorting_in_layer);
+		}
+	}
+}
+
+TEST_F(RenderSystemTest, Update) {
+	entity1.add_component<Camera>(Color::WHITE);
+	{
+		vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+		ASSERT_EQ(sprites.size(), 4);
+
+		EXPECT_EQ(sprites[0].get().game_object_id, 0);
+		EXPECT_EQ(sprites[1].get().game_object_id, 1);
+		EXPECT_EQ(sprites[2].get().game_object_id, 2);
+		EXPECT_EQ(sprites[3].get().game_object_id, 3);
+	}
+	this->sys.update();
+	{
+		vector<reference_wrapper<Sprite>> sprites = this->mgr.get_components_by_type<Sprite>();
+		ASSERT_EQ(sprites.size(), 4);
+
+		EXPECT_EQ(sprites[0].get().game_object_id, 0);
+		EXPECT_EQ(sprites[1].get().game_object_id, 1);
+		EXPECT_EQ(sprites[2].get().game_object_id, 2);
+		EXPECT_EQ(sprites[3].get().game_object_id, 3);
+	}
+}
+
+TEST_F(RenderSystemTest, Camera) {
+	{
+		auto cameras = this->mgr.get_components_by_type<Camera>();
+		EXPECT_NE(cameras.size(), 1);
+	}
+	{
+		entity1.add_component<Camera>(Color::WHITE);
+		auto cameras = this->mgr.get_components_by_type<Camera>();
+		EXPECT_EQ(cameras.size(), 1);
+	}
+
+	//TODO improve with newer version
+}
+TEST_F(RenderSystemTest, Color) {
+	entity1.add_component<Camera>(Color::WHITE);
+	auto & sprite = this->mgr.get_components_by_id<Sprite>(entity1.id).front().get();
+	ASSERT_NE(sprite.sprite_image.get(), nullptr);
+
+	sprite.color = Color::GREEN;
+	EXPECT_EQ(sprite.color.r, Color::GREEN.r);
+	EXPECT_EQ(sprite.color.g, Color::GREEN.g);
+	EXPECT_EQ(sprite.color.b, Color::GREEN.b);
+	EXPECT_EQ(sprite.color.a, Color::GREEN.a);
+	this->sys.update();
+	EXPECT_EQ(sprite.color.r, Color::GREEN.r);
+	EXPECT_EQ(sprite.color.g, Color::GREEN.g);
+	EXPECT_EQ(sprite.color.b, Color::GREEN.b);
+	EXPECT_EQ(sprite.color.a, Color::GREEN.a);
+}
diff --git a/src/test/SceneManagerTest.cpp b/src/test/SceneManagerTest.cpp
new file mode 100644
index 0000000..69e1171
--- /dev/null
+++ b/src/test/SceneManagerTest.cpp
@@ -0,0 +1,122 @@
+#include <crepe/ComponentManager.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>
+
+using namespace std;
+using namespace crepe;
+
+class ConcreteScene1 : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		auto & mgr = this->component_manager;
+		GameObject object1 = mgr.new_object("scene_1", "tag_scene_1", Vector2{0, 0}, 0, 1);
+		GameObject object2 = mgr.new_object("scene_1", "tag_scene_1", Vector2{1, 0}, 0, 1);
+		GameObject object3 = mgr.new_object("scene_1", "tag_scene_1", Vector2{2, 0}, 0, 1);
+	}
+};
+
+class ConcreteScene2 : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		auto & mgr = this->component_manager;
+		GameObject object1 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 0}, 0, 1);
+		GameObject object2 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 1}, 0, 1);
+		GameObject object3 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 2}, 0, 1);
+		GameObject object4 = mgr.new_object("scene_2", "tag_scene_2", Vector2{0, 3}, 0, 1);
+	}
+};
+
+class SceneManagerTest : public ::testing::Test {
+public:
+	ComponentManager component_mgr{};
+	SceneManager scene_mgr{component_mgr};
+};
+
+TEST_F(SceneManagerTest, loadScene) {
+	scene_mgr.add_scene<ConcreteScene1>("scene1");
+	scene_mgr.add_scene<ConcreteScene2>("scene2");
+
+	scene_mgr.load_next_scene();
+
+	vector<reference_wrapper<Metadata>> metadata
+		= component_mgr.get_components_by_type<Metadata>();
+	vector<reference_wrapper<Transform>> transform
+		= component_mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 3);
+	EXPECT_EQ(transform.size(), 3);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "scene_1");
+	EXPECT_EQ(metadata[0].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[1].get().name, "scene_1");
+	EXPECT_EQ(metadata[1].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[1].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().children.size(), 0);
+	EXPECT_EQ(transform[1].get().position.x, 1);
+	EXPECT_EQ(transform[1].get().position.y, 0);
+
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[2].get().name, "scene_1");
+	EXPECT_EQ(metadata[2].get().tag, "tag_scene_1");
+	EXPECT_EQ(metadata[2].get().parent, -1);
+	EXPECT_EQ(metadata[2].get().children.size(), 0);
+	EXPECT_EQ(transform[2].get().position.x, 2);
+	EXPECT_EQ(transform[2].get().position.y, 0);
+
+	scene_mgr.set_next_scene("scene2");
+	scene_mgr.load_next_scene();
+
+	metadata = component_mgr.get_components_by_type<Metadata>();
+	transform = component_mgr.get_components_by_type<Transform>();
+
+	EXPECT_EQ(metadata.size(), 4);
+	EXPECT_EQ(transform.size(), 4);
+
+	EXPECT_EQ(metadata[0].get().game_object_id, 0);
+	EXPECT_EQ(metadata[0].get().name, "scene_2");
+	EXPECT_EQ(metadata[0].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[0].get().parent, -1);
+	EXPECT_EQ(metadata[0].get().children.size(), 0);
+	EXPECT_EQ(transform[0].get().position.x, 0);
+	EXPECT_EQ(transform[0].get().position.y, 0);
+
+	EXPECT_EQ(metadata[1].get().game_object_id, 1);
+	EXPECT_EQ(metadata[1].get().name, "scene_2");
+	EXPECT_EQ(metadata[1].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[1].get().parent, -1);
+	EXPECT_EQ(metadata[1].get().children.size(), 0);
+	EXPECT_EQ(transform[1].get().position.x, 0);
+	EXPECT_EQ(transform[1].get().position.y, 1);
+
+	EXPECT_EQ(metadata[2].get().game_object_id, 2);
+	EXPECT_EQ(metadata[2].get().name, "scene_2");
+	EXPECT_EQ(metadata[2].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[2].get().parent, -1);
+	EXPECT_EQ(metadata[2].get().children.size(), 0);
+	EXPECT_EQ(transform[2].get().position.x, 0);
+	EXPECT_EQ(transform[2].get().position.y, 2);
+
+	EXPECT_EQ(metadata[3].get().game_object_id, 3);
+	EXPECT_EQ(metadata[3].get().name, "scene_2");
+	EXPECT_EQ(metadata[3].get().tag, "tag_scene_2");
+	EXPECT_EQ(metadata[3].get().parent, -1);
+	EXPECT_EQ(metadata[3].get().children.size(), 0);
+	EXPECT_EQ(transform[3].get().position.x, 0);
+	EXPECT_EQ(transform[3].get().position.y, 3);
+}
-- 
cgit v1.2.3


From 3f63143b4005936da446fb2cdbbd1072b47fc8c1 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 15:36:14 +0100
Subject: merge with master

---
 src/crepe/Collider.cpp               |  2 +-
 src/crepe/Collider.h                 |  5 ++-
 src/crepe/api/BoxCollider.cpp        |  2 +-
 src/crepe/api/BoxCollider.h          |  2 +-
 src/crepe/api/CircleCollider.cpp     |  2 +-
 src/crepe/api/CircleCollider.h       |  2 +-
 src/crepe/api/LoopManager.cpp        |  1 +
 src/crepe/api/Rigidbody.h            |  2 +-
 src/crepe/system/CollisionSystem.cpp | 79 ++++++++++++++++++------------------
 src/crepe/system/CollisionSystem.h   |  8 ++--
 src/example/CMakeLists.txt           |  1 +
 src/example/game.cpp                 | 30 +++++++-------
 12 files changed, 71 insertions(+), 65 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 0706371..80a944d 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(game_object_id_t id, Vector2 offset) : Component(id), offset(offset) {}
+Collider::Collider(game_object_id_t id, vec2 offset) : Component(id), offset(offset) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 0157324..5b26af5 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -3,16 +3,17 @@
 #include "api/Vector2.h"
 
 #include "Component.h"
+#include "types.h"
 
 namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(game_object_id_t id, Vector2 offset);
+	Collider(game_object_id_t id, vec2 offset);
 
 public:
 	//! Offset of the collider relative to rigidbody position 
-	Vector2 offset;
+	vec2 offset;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index eafbdb2..83fb632 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 using namespace crepe;
 
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height) : Collider(game_object_id,offset), width(width), height(height) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 7f51cba..6135954 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -12,7 +12,7 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,Vector2 offset, double width, double height);
+	BoxCollider(game_object_id_t game_object_id,vec2 offset, double width, double height);
 
 	//! Width of box collider 
 	double width;
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 04a4995..43de991 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -3,4 +3,4 @@
 using namespace crepe;
 
 
-CircleCollider::CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius) : Collider(game_object_id,offset), radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 4e04fa4..843547f 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -14,7 +14,7 @@ namespace crepe {
 class CircleCollider : public Collider {
 public:
 
-	CircleCollider(game_object_id_t game_object_id,Vector2 offset, int radius);
+	CircleCollider(game_object_id_t game_object_id,vec2 offset, int radius);
 
 	//! Radius of the circle collider.
 	double radius;
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 586919d..10b59c8 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -63,6 +63,7 @@ void LoopManager::setup() {
 	this->game_running = true;
 	LoopTimer::get_instance().start();
 	LoopTimer::get_instance().set_fps(60);
+	this->scene_manager.load_next_scene();
 }
 
 void LoopManager::render() {
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index b96b463..7939563 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -78,7 +78,7 @@ public:
 		//! bounce factor of material
 		double elastisity = 0.0;
 		//! offset of all colliders relative to transform position
-		Vector2 offset;
+		vec2 offset;
 	};
 
 public:
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 9ca8b3a..8d9b356 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -15,6 +15,7 @@
 #include "ComponentManager.h"
 #include "CollisionSystem.h"
 #include "Collider.h"
+#include "types.h"
 
 using namespace crepe;
 
@@ -39,7 +40,7 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 	// Data needed for collision handler info
 	const Collider* collider1 = nullptr;
 	const Collider* collider2 = nullptr;
-	Vector2 move_back;
+	vec2 move_back;
 
 	// Check collision type and get values for handler
 	if (std::holds_alternative<std::reference_wrapper<BoxCollider>>(data1.collider)) {
@@ -53,8 +54,8 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 
 			// TODO: send with the collider info to this function because this is calculated previously
 			// Get the current position of the collider
-			Vector2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
-			Vector2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
+			vec2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
+			vec2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
 
 			// Determine move_back value for smallest overlap (x or y)
 			move_back = box_box_collision_move_back(box_collider1,box_collider2,final_position1,final_position2);
@@ -112,20 +113,20 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 }
 
 
-Vector2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 final_position1,Vector2 final_position2)
+vec2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 final_position1,vec2 final_position2)
 {
-	Vector2 resolution; // Default resolution vector
-	Vector2 delta = final_position2 - final_position1;
+	vec2 resolution; // Default resolution vector
+	vec2 delta = final_position2 - final_position1;
 
 	// Compute half-dimensions of the boxes
-	double half_width1 = box_collider1.width / 2.0;
-	double half_height1 = box_collider1.height / 2.0;
-	double half_width2 = box_collider2.width / 2.0;
-	double half_height2 = box_collider2.height / 2.0;
+	float half_width1 = box_collider1.width / 2.0;
+	float half_height1 = box_collider1.height / 2.0;
+	float half_width2 = box_collider2.width / 2.0;
+	float half_height2 = box_collider2.height / 2.0;
 
 	// Calculate overlaps along X and Y axes
-	double overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
-	double overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
+	float overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
+	float overlap_y = (half_height1 + half_height2) - std::abs(delta.y);
 
 	// Check if there is a collision
 	if (overlap_x > 0 && overlap_y > 0) {//should always be true check if this can be removed
@@ -288,14 +289,14 @@ std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::Collide
 bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2)
 {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(box1,transform1,rigidbody1);
-	Vector2 final_position2 = current_position(box2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(box1,transform1,rigidbody1);
+	vec2 final_position2 = current_position(box2,transform2,rigidbody2);
 
 	// Calculate half-extents (half width and half height)
-	double half_width1 = box1.width / 2.0;
-	double half_height1 = box1.height / 2.0;
-	double half_width2 = box2.width / 2.0;
-	double half_height2 = box2.height / 2.0;
+	float half_width1 = box1.width / 2.0;
+	float half_height1 = box1.height / 2.0;
+	float half_width2 = box2.width / 2.0;
+	float half_height2 = box2.height / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
 	return !(final_position1.x + half_width1 <= final_position2.x - half_width2 ||  // box1 is left of box2
@@ -306,21 +307,21 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 
 bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(box1, transform1, rigidbody1);
-	Vector2 final_position2 = current_position(circle2, transform2, rigidbody2);
+	vec2 final_position1 = current_position(box1, transform1, rigidbody1);
+	vec2 final_position2 = current_position(circle2, transform2, rigidbody2);
 
 	// Calculate box half-extents
-	double half_width = box1.width / 2.0;
-	double half_height = box1.height / 2.0;
+	float half_width = box1.width / 2.0;
+	float half_height = box1.height / 2.0;
 
 	// Find the closest point on the box to the circle's center
-	double closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
-	double closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
+	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
+	float closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
 
 	// Calculate the distance squared between the circle's center and the closest point on the box
-	double distance_x = final_position2.x - closest_x;
-	double distance_y = final_position2.y - closest_y;
-	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+	float distance_x = final_position2.x - closest_x;
+	float distance_y = final_position2.y - closest_y;
+	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Compare distance squared with the square of the circle's radius
 	return distance_squared <= circle2.radius * circle2.radius;
@@ -328,32 +329,32 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 
 bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	Vector2 final_position1 = current_position(circle1,transform1,rigidbody1);
-	Vector2 final_position2 = current_position(circle2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(circle1,transform1,rigidbody1);
+	vec2 final_position2 = current_position(circle2,transform2,rigidbody2);
 
-	double distance_x = final_position1.x - final_position2.x;
-	double distance_y = final_position1.y - final_position2.y;
-	double distance_squared = distance_x * distance_x + distance_y * distance_y;
+	float distance_x = final_position1.x - final_position2.x;
+	float distance_y = final_position1.y - final_position2.y;
+	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Calculate the sum of the radii
-	double radius_sum = circle1.radius + circle2.radius;
+	float radius_sum = circle1.radius + circle2.radius;
 
 	// Check if the distance between the centers is less than or equal to the sum of the radii
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-Vector2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
+vec2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
 	// Get the rotation in radians
-	double radians1 = transform.rotation * (M_PI / 180.0);
+	float radians1 = transform.rotation * (M_PI / 180.0);
 
 	// Calculate total offset with scale
-	Vector2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
+	vec2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
 
 	// Rotate
-	double rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
-	double rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
+	float rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
+	float rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
 
 	// Final positions considering scaling and rotation
-	return(transform.position + Vector2(rotated_total_offset_x1, rotated_total_offset_y1));
+	return(transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 
 }
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 69d1d23..44fff4e 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -65,7 +65,7 @@ public:
 	struct CollisionInfo{
     ColliderInfo first;
     ColliderInfo second;
-		Vector2 move_back_value;
+		vec2 move_back_value;
 		Direction move_back_direction = Direction::NONE;
 	};
 
@@ -98,7 +98,7 @@ private:
 		* \param final_position2 The final position of the second box collider.
 		* \return The move-back vector to resolve the collision.
 		*/
-	Vector2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,Vector2 position1,Vector2 position2);
+	vec2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2);
 
 	/**
 		* \brief Determines the appropriate collision handler based on the rigidbody types of the colliding objects.
@@ -185,9 +185,9 @@ private: //detection
 		* \param collider The collider whose position is being determined.
 		* \param transform The transform component associated with the collider.
 		* \param rigidbody The rigidbody component associated with the collider.
-		* \return The current position of the collider as a Vector2.
+		* \return The current position of the collider as a vec2.
 		*/
-	Vector2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
+	vec2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
 };
 
 } // namespace crepe
diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 560e2bc..3ec5e43 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -20,4 +20,5 @@ add_example(asset_manager)
 add_example(savemgr)
 add_example(rendering_particle)
 add_example(gameloop)
+add_example(game)
 
diff --git a/src/example/game.cpp b/src/example/game.cpp
index a557be7..f6b580a 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -18,17 +18,18 @@ using namespace std;
 
 class MyScript : public Script {
 	static bool oncollision(const CollisionEvent& test) {
-		std::cout << "test collision: " << test.info.first.collider.game_object_id << std::endl;
+		Log::logf("Box {} script on_collision()", test.info.first.collider.game_object_id);
 		return true;
 	}
 	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, this->get_game_object_id());
+		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, 0);
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
 };
 
+
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
@@ -37,11 +38,11 @@ public:
 	ComponentManager & mgr = this->component_manager;
 	Color color(0, 0, 0, 0);
 
-	double screen_size_width = 640;
-	double screen_size_height = 480;
-	double world_collider = 1000;
+	float screen_size_width = 640;
+	float screen_size_height = 480;
+	float world_collider = 1000;
 	//define playable world 
-	GameObject world = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	GameObject world = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	world.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 0,
 		.gravity_scale = 0,
@@ -51,13 +52,13 @@ public:
 		.bounce = false,
 		.offset = {0,0}
 	});
-	world.add_component<BoxCollider>(Vector2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	world.add_component<BoxCollider>(Vector2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	world.add_component<BoxCollider>(Vector2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	world.add_component<BoxCollider>(Vector2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
+	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
+	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
+	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
+	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
 
 
-	GameObject game_object1 = mgr.new_object("Name", "Tag", Vector2{screen_size_width/2, screen_size_height/2}, 0, 1);
+	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
 		.mass = 1,
 		.gravity_scale = 0.01,
@@ -69,20 +70,21 @@ public:
 		.elastisity = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(Vector2{0, 0}, 20, 20);
+	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	game_object1.add_component<Sprite>(
 	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
 	FlipSettings{true, true});
 	game_object1.add_component<Camera>(Color::WHITE);
 	}
+
+	string get_name() const { return "scene1"; }
 };
 
 int main(int argc, char * argv[]) {
 
 	LoopManager gameloop;
-	gameloop.scene_manager.add_scene<ConcreteScene1>("scene1");
-	gameloop.scene_manager.load_next_scene();
+	gameloop.add_scene<ConcreteScene1>();
 	gameloop.start();
 	return 0;
 }
-- 
cgit v1.2.3


From bcf57e81f68913049f84cabb66871931c8f47b2b Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 16:11:39 +0100
Subject: script fix

---
 src/crepe/api/Config.h        | 2 +-
 src/crepe/api/LoopManager.cpp | 1 +
 src/example/game.cpp          | 6 ++++--
 src/test/CollisionTest.cpp    | 7 +++----
 4 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 13eabd1..b6c2ccf 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -33,7 +33,7 @@ public:
 		 *
 		 * Only messages with equal or higher priority than this value will be logged.
 		 */
-		Log::Level level = Log::Level::INFO;
+		Log::Level level = Log::Level::DEBUG;
 		/**
 		 * \brief Colored log output
 		 *
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 10b59c8..ff8b90e 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -35,6 +35,7 @@ void LoopManager::start() {
 void LoopManager::set_running(bool running) { this->game_running = running; }
 
 void LoopManager::fixed_update() {
+	this->get_system<ScriptSystem>().update();
 	this->get_system<PhysicsSystem>().update();
 	this->get_system<CollisionSystem>().update();
 }
diff --git a/src/example/game.cpp b/src/example/game.cpp
index f6b580a..991d2ec 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -17,12 +17,14 @@ using namespace crepe;
 using namespace std;
 
 class MyScript : public Script {
-	static bool oncollision(const CollisionEvent& test) {
+	bool oncollision(const CollisionEvent& test) {
 		Log::logf("Box {} script on_collision()", test.info.first.collider.game_object_id);
 		return true;
 	}
 	void init() {
-		EventManager::get_instance().subscribe<CollisionEvent>(oncollision, 0);
+		subscribe<CollisionEvent>([this](const CollisionEvent& ev) -> bool {
+			return this->oncollision(ev);
+		});
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index c175eb4..bbf6348 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -25,7 +25,6 @@ using namespace testing;
 class CollisionHandler : public Script {
 public:
 	int box_id;
-	EventManager & evmgr = EventManager::get_instance();
 	function<void(const CollisionEvent& ev)> test_fn = [](const CollisionEvent & ev) { };
 
 	CollisionHandler(int box_id) {
@@ -42,9 +41,9 @@ public:
 		//Log::logf("Box {} script init()", box_id);
 
 		// TODO: this should be built into script
-		evmgr.subscribe<CollisionEvent>([this](const CollisionEvent & ev) {
-			return this->on_collision(ev);
-		}, this->get_game_object_id());
+		subscribe<CollisionEvent>([](const CollisionEvent&) -> bool {
+			return true;
+		});	
 	}
 };
 
-- 
cgit v1.2.3


From 2a37965c797e1ef03ec10ea8bf503d7605465f11 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 21:17:30 +0100
Subject: refactored collision system

---
 src/crepe/system/CollisionSystem.cpp | 317 ++++++++++++++++++-----------------
 src/crepe/system/CollisionSystem.h   | 133 ++++-----------
 src/example/game.cpp                 |   4 +-
 3 files changed, 198 insertions(+), 256 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 8d9b356..f61a1dd 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,8 +1,11 @@
 #include <cmath>
 #include <algorithm>
 #include <cstddef>
+#include <functional>
 #include <utility>
 #include <variant>
+#include <optional>
+#include <tuple>
 
 #include "api/Event.h"
 #include "api/EventManager.h"
@@ -16,6 +19,7 @@
 #include "CollisionSystem.h"
 #include "Collider.h"
 #include "types.h"
+#include "util/OptionalRef.h"
 
 using namespace crepe;
 
@@ -24,69 +28,88 @@ void CollisionSystem::update() {
 	ComponentManager & mgr = this->component_manager;
 	std::vector<std::reference_wrapper<BoxCollider>> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
 	std::vector<std::reference_wrapper<CircleCollider>> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+
+	std::vector<collider_stor> all_colliders;
+	// Add BoxCollider references
+	for (auto& box : boxcolliders) {
+			all_colliders.push_back(collider_stor{box});
+	}
+
+	// Add CircleCollider references
+	for (auto& circle : circlecolliders) {
+			all_colliders.push_back(collider_stor{circle});
+	}
 	
 	// Check between all colliders if there is a collision
-	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(boxcolliders,circlecolliders);
+	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collided = check_collisions(all_colliders);
 
 	// For both objects call the collision handler 
 	for (auto& collision_pair : collided) {
-		collision_handler(collision_pair.first,collision_pair.second);
-		collision_handler(collision_pair.second,collision_pair.first);
+		collision_handler_request(collision_pair.first,collision_pair.second);
+		collision_handler_request(collision_pair.second,collision_pair.first);
 	}
 }
 
-void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2){
+void CollisionSystem::collision_handler_request(CollidedInfoStor& data1,CollidedInfoStor& data2){
 
-	// Data needed for collision handler info
-	const Collider* collider1 = nullptr;
-	const Collider* collider2 = nullptr;
-	vec2 move_back;
+	ColliderStorType type = check_collider_type(data1.collider,data2.collider);
+	std::pair<vec2,CollisionSystem::Direction> move_back_data = collision_handler(data1,data2,type);
 
-	// Check collision type and get values for handler
-	if (std::holds_alternative<std::reference_wrapper<BoxCollider>>(data1.collider)) {
-		if (std::holds_alternative<std::reference_wrapper<BoxCollider>>(data2.collider)) {
-			
-			// Get colliders from variant to be used to determine collision handler info
-			const BoxCollider& box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider).get();
-			const BoxCollider& box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider).get();
-			collider1 = &box_collider1;
-			collider2 = &box_collider2;
-
-			// TODO: send with the collider info to this function because this is calculated previously
-			// Get the current position of the collider
-			vec2 final_position1 = current_position(box_collider1,data1.transform,data1.rigidbody);
-			vec2 final_position2 = current_position(box_collider2,data2.transform,data2.rigidbody);
-
-			// Determine move_back value for smallest overlap (x or y)
-			move_back = box_box_collision_move_back(box_collider1,box_collider2,final_position1,final_position2);
-			
+	OptionalRef<Collider> collider1;
+	OptionalRef<Collider> collider2;
+	switch (type) {
+		case ColliderStorType::BOX_BOX:{
+			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
 		}
-		else {
-			// TODO: calcualte Box - Circle collision info
-			const BoxCollider& box_collider = std::get<std::reference_wrapper<BoxCollider>>(data1.collider).get();
-			const CircleCollider& circle_collider = std::get<std::reference_wrapper<CircleCollider>>(data2.collider).get();
-			collider1 = &box_collider;
-			collider2 = &circle_collider;
+		case ColliderStorType::BOX_CIRCLE:{
+			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+		}
+		case ColliderStorType::CIRCLE_BOX:{
+			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+		}
+		case ColliderStorType::CIRCLE_CIRCLE:{
+			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
 		}
 	}
-	else {
-		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(data2.collider)) {
-			// TODO: calcualte Circle - Circle collision info
-			const CircleCollider& circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider).get();
-			const CircleCollider& circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider).get();
-			collider1 = &circle_collider1;
-			collider2 = &circle_collider2;
+	
+	// collision info
+	crepe::CollisionSystem::CollisionInfo collision_info{
+            .first={ collider1, data1.transform, data1.rigidbody },
+            .second={ collider2, data2.transform, data2.rigidbody },
+						.move_back_value = move_back_data.first,
+						.move_back_direction = move_back_data.second,
+        };
+
+	// Determine if static needs to be called
+	determine_collision_handler(collision_info);	
+}
+
+
+std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2,ColliderStorType type) {
+	vec2 move_back;
+	switch (type) {
+		case ColliderStorType::BOX_BOX:	{
+			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			vec2 collider_pos1 = current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = current_position(collider2.offset, data2.transform, data2.rigidbody);
+			move_back = box_box_move_back(collider1,collider2,collider_pos1,collider_pos2);
 		}
-		else {
-			// TODO: calcualte Circle - Box collision info
-			const CircleCollider& circle_collider = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			const BoxCollider& box_collider = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			collider1 = &circle_collider;
-			collider2 = &box_collider;
+		case ColliderStorType::BOX_CIRCLE: {
+		
+		}
+		case ColliderStorType::CIRCLE_CIRCLE:	{
+		
+		}
+		case ColliderStorType::CIRCLE_BOX:	{
+		
 		}
 	}
 
-	// One vaue is calculated for moving back. Calculate the other value (x or y) relateive to the move_back value.
 	Direction move_back_direction = Direction::NONE;
 	if(move_back.x != 0 && move_back.y > 0) {
 		move_back_direction = Direction::BOTH;
@@ -100,20 +123,10 @@ void CollisionSystem::collision_handler(CollidedInfoStor& data1,CollidedInfoStor
 		move_back.x = data1.rigidbody.data.linear_velocity.x * (move_back.y/data1.rigidbody.data.linear_velocity.y);
 	}
 
-	// collision info
-	crepe::CollisionSystem::CollisionInfo collision_info{
-            .first={ *collider1, data1.transform, data1.rigidbody },
-            .second={ *collider2, data2.transform, data2.rigidbody },
-						.move_back_value = move_back,
-						.move_back_direction = move_back_direction,
-        };
-
-	// Determine if static needs to be called
-	determine_collision_handler(collision_info);	
+	return {move_back,move_back_direction};
 }
 
-
-vec2 CollisionSystem::box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 final_position1,vec2 final_position2)
+vec2 CollisionSystem::box_box_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 final_position1,vec2 final_position2)
 {
 	vec2 resolution; // Default resolution vector
 	vec2 delta = final_position2 - final_position1;
@@ -185,10 +198,9 @@ void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	}
 }
 
-std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders) {
-	ComponentManager & mgr = this->component_manager;
-	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
-
+std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::CollidedInfoStor>> CollisionSystem::check_collisions(std::vector<collider_stor> & colliders) {
+	
+	
 	// TODO:
 	// If no colliders skip
 	// Check if colliders has rigidbody if not skip
@@ -198,99 +210,104 @@ std::vector<std::pair<CollisionSystem::CollidedInfoStor,CollisionSystem::Collide
 	// Quadtree code
 	// Quadtree is placed over the input vector
 
-	// Check collisions for each collider
-	for (size_t i = 0; i < boxcolliders.size(); ++i) {
-		// Fetch components for the first box collider
-		if(!boxcolliders[i].get().active) continue;
-		int game_object_id_1 = boxcolliders[i].get().game_object_id;
-		Transform& transform1 = mgr.get_components_by_id<Transform>(game_object_id_1).front().get();
-		if(!transform1.active) continue;
-		Rigidbody& rigidbody1 = mgr.get_components_by_id<Rigidbody>(game_object_id_1).front().get();
-		if(!rigidbody1.active) continue;
-		
-		// Check BoxCollider vs BoxCollider
-		for (size_t j = i + 1; j < boxcolliders.size(); ++j) {
-			if(!boxcolliders[j].get().active) continue;
-			// Skip self collision
-			int game_object_id_2 = boxcolliders[j].get().game_object_id;
-			if (game_object_id_1 == game_object_id_2) continue;
-
-			// Fetch components for the second box collider
-			Transform & transform2 = mgr.get_components_by_id<Transform>(boxcolliders[j].get().game_object_id).front().get();
-			if(!transform2.active) continue;
-			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(boxcolliders[j].get().game_object_id).front().get();
-			if(!rigidbody2.active) continue;
-			// Check collision
-			if (check_box_box_collision(boxcolliders[i], boxcolliders[j], transform1, transform2, rigidbody1, rigidbody2)) {
-				collisions_ret.emplace_back(std::make_pair(
-				CollidedInfoStor{boxcolliders[i].get(), transform1, rigidbody1}, 
-				CollidedInfoStor{boxcolliders[j].get(), transform2, rigidbody2}
-				));
-			}
-		}
+	// Function to retrieve active transform and rigidbody components for a given game_object_id
+	auto get_active_transform_and_rigidbody = [&](game_object_id_t game_object_id) 
+	-> std::optional<std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>>> {
+		RefVector<Transform> transforms = this->component_manager.get_components_by_id<Transform>(game_object_id);
+		if (transforms.empty()) return std::nullopt;
+
+		RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_id<Rigidbody>(game_object_id);
+		if (rigidbodies.empty()) return std::nullopt;
+
+		Transform& transform = transforms.front().get();
+		if (!transform.active) return std::nullopt;
+
+		Rigidbody& rigidbody = rigidbodies.front().get();
+		if (!rigidbody.active) return std::nullopt;
 
-		// Check BoxCollider vs CircleCollider
-		for (size_t j = 0; j < circlecolliders.size(); ++j) {
-			if(!circlecolliders[j].get().active) continue;
-			// Skip self collision
-			int game_object_id_2 = circlecolliders[j].get().game_object_id;
-			if (game_object_id_1 == game_object_id_2) continue;
-
-			// Fetch components for the second collider (circle)
-			Transform & transform2 = mgr.get_components_by_id<Transform>(circlecolliders[j].get().game_object_id).front().get();
-			if(!transform2.active) continue;
-			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(circlecolliders[j].get().game_object_id).front().get();
-			if(!rigidbody2.active) continue;
-
-			// Check collision
-			if (check_box_circle_collision(boxcolliders[i], circlecolliders[j], transform1, transform2, rigidbody1, rigidbody2)) {
-				
-				collisions_ret.emplace_back(std::make_pair(
-				CollidedInfoStor{boxcolliders[i].get(), transform1, rigidbody1}, 
-				CollidedInfoStor{circlecolliders[j].get(), transform2, rigidbody2}
-				));
+		// Return the active components
+		return std::make_pair(std::ref(transform), std::ref(rigidbody));
+    };
+	
+
+	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> collisions_ret;
+	for (size_t i = 0; i < colliders.size(); ++i) {
+    std::visit([&](auto& inner_collider_ref) {
+			if (inner_collider_ref.get().active) return;
+			auto inner_components = get_active_transform_and_rigidbody(inner_collider_ref.get().game_object_id);
+			if (inner_components) return;
+			for (size_t j = i + 1; j < colliders.size(); ++j) {
+				std::visit([&](auto& outer_collider_ref) { 
+					if (outer_collider_ref.get().active) return;
+					if (inner_collider_ref.get().game_object_id == outer_collider_ref.get().game_object_id) return;
+					auto outer_components = get_active_transform_and_rigidbody(inner_collider_ref.get().game_object_id);
+					if (outer_components) return;
+					ColliderStorType type = check_collider_type(colliders[i],colliders[j]);
+					check_collision(colliders[i],*inner_components,colliders[j],*outer_components,type);
+					collisions_ret.emplace_back(
+                        CollidedInfoStor{colliders[i], inner_components->first.get(), inner_components->second.get()},
+                        CollidedInfoStor{colliders[j], outer_components->first.get(), outer_components->second.get()}
+                    );
+				}, colliders[j]);
 			}
+    }, colliders[i]);
+	}
+	
+	return collisions_ret;
+}
+
+CollisionSystem::ColliderStorType CollisionSystem::check_collider_type(const collider_stor& collider1,const collider_stor& collider2){
+	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
+		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
+		{
+			return ColliderStorType::CIRCLE_CIRCLE;
+		}
+		else {
+			return ColliderStorType::CIRCLE_BOX;
 		}
 	}
-	// Check CircleCollider vs CircleCollider
-	for (size_t i = 0; i < circlecolliders.size(); ++i) {
-		if(!circlecolliders[i].get().active) continue;
-		// Fetch components for the first circle collider
-		int game_object_id_1 = circlecolliders[i].get().game_object_id;
-		Transform & transform1 = mgr.get_components_by_id<Transform>(circlecolliders[i].get().game_object_id).front().get();
-		if(!transform1.active) continue;
-		Rigidbody & rigidbody1 = mgr.get_components_by_id<Rigidbody>(circlecolliders[i].get().game_object_id).front().get();
-		if(!rigidbody1.active) continue;
-
-		for (size_t j = i + 1; j < circlecolliders.size(); ++j) {
-			if(!circlecolliders[j].get().active) continue;
-			// Skip self collision
-			int game_object_id_2 = circlecolliders[j].get().game_object_id;
-			if (game_object_id_1 == game_object_id_2) continue;
-
-			// Fetch components for the second circle collider
-			Transform & transform2 = mgr.get_components_by_id<Transform>(circlecolliders[j].get().game_object_id).front().get();
-			if(!transform2.active) continue;
-			Rigidbody & rigidbody2 = mgr.get_components_by_id<Rigidbody>(circlecolliders[j].get().game_object_id).front().get();
-			if(!rigidbody2.active) continue;
-
-			// Check collision
-			if (check_circle_circle_collision(circlecolliders[i], circlecolliders[j], transform1, transform2, rigidbody1, rigidbody2)) {
-				collisions_ret.emplace_back(std::make_pair(
-				CollidedInfoStor{circlecolliders[i].get(), transform1, rigidbody1}, 
-				CollidedInfoStor{circlecolliders[j].get(), transform2, rigidbody2}
-				));
-			}
+	else {
+		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
+		{
+			return ColliderStorType::BOX_CIRCLE;
+		}
+		else {
+			return ColliderStorType::BOX_BOX;
 		}
 	}
-	return collisions_ret;
 }
 
+bool CollisionSystem::check_collision(const collider_stor& collider1,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components1,const collider_stor& collider2,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components2, ColliderStorType type){
+	switch (type) {
+		case ColliderStorType::BOX_BOX:	{
+			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(collider1);
+			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(collider2);
+			return check_box_box_collision(box_collider1,box_collider2,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+		}
+		case ColliderStorType::BOX_CIRCLE: {
+			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(collider1);
+			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(collider2);
+			return check_box_circle_collision(box_collider,circle_collider,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+		}
+		case ColliderStorType::CIRCLE_CIRCLE:	{
+			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(collider1);
+			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(collider2);
+			return check_circle_circle_collision(circle_collider1,circle_collider2,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+		}
+		case ColliderStorType::CIRCLE_BOX:	{
+			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(collider1);
+			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(collider2);
+			return check_box_circle_collision(box_collider,circle_collider,components1.first.get(),components2.first.get(),components1.second.get(),components2.second.get());
+		}
+	}
+}
+
+
 bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2)
 {
 	// Get current positions of colliders
-	vec2 final_position1 = current_position(box1,transform1,rigidbody1);
-	vec2 final_position2 = current_position(box2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(box1.offset,transform1,rigidbody1);
+	vec2 final_position2 = current_position(box2.offset,transform2,rigidbody2);
 
 	// Calculate half-extents (half width and half height)
 	float half_width1 = box1.width / 2.0;
@@ -307,8 +324,8 @@ bool CollisionSystem::check_box_box_collision(const BoxCollider& box1, const Box
 
 bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	vec2 final_position1 = current_position(box1, transform1, rigidbody1);
-	vec2 final_position2 = current_position(circle2, transform2, rigidbody2);
+	vec2 final_position1 = current_position(box1.offset, transform1, rigidbody1);
+	vec2 final_position2 = current_position(circle2.offset, transform2, rigidbody2);
 
 	// Calculate box half-extents
 	float half_width = box1.width / 2.0;
@@ -329,8 +346,8 @@ bool CollisionSystem::check_box_circle_collision(const BoxCollider& box1, const
 
 bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) {
 	// Get current positions of colliders
-	vec2 final_position1 = current_position(circle1,transform1,rigidbody1);
-	vec2 final_position2 = current_position(circle2,transform2,rigidbody2);
+	vec2 final_position1 = current_position(circle1.offset,transform1,rigidbody1);
+	vec2 final_position2 = current_position(circle2.offset,transform2,rigidbody2);
 
 	float distance_x = final_position1.x - final_position2.x;
 	float distance_y = final_position1.y - final_position2.y;
@@ -343,12 +360,12 @@ bool CollisionSystem::check_circle_circle_collision(const CircleCollider& circle
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-vec2 CollisionSystem::current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody) {
+vec2 CollisionSystem::current_position(vec2 collider_offset, const Transform& transform, const Rigidbody& rigidbody) {
 	// Get the rotation in radians
 	float radians1 = transform.rotation * (M_PI / 180.0);
 
 	// Calculate total offset with scale
-	vec2 total_offset = (rigidbody.data.offset + collider.offset) * transform.scale;
+	vec2 total_offset = (rigidbody.data.offset + collider_offset) * transform.scale;
 
 	// Rotate
 	float rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 44fff4e..80f8818 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -25,6 +25,15 @@ private:
 	// using collider_stor = std::variant<BoxCollider, CircleCollider>;
 	using collider_stor = std::variant<std::reference_wrapper<BoxCollider>, std::reference_wrapper<CircleCollider>>;
 
+	//! A enum that is used to tell the pair of the collider stor in a std::pair.
+	enum class ColliderStorType {
+    BOX_BOX,
+    CIRCLE_CIRCLE,
+    BOX_CIRCLE,
+    CIRCLE_BOX,
+	};
+
+
 	/**
 		* \brief A structure to store the collision data of a single collider.
 		* 
@@ -32,7 +41,7 @@ private:
 		*/
 	struct CollidedInfoStor {
 		//! Store either BoxCollider or CircleCollider
-		collider_stor collider; 
+		collider_stor& collider; 
 		Transform& transform;
 		Rigidbody& rigidbody;
 	};
@@ -45,6 +54,8 @@ private:
     BOTH
 	};
 
+
+
 public:
 	/**
 		* \brief A structure representing the collision information between two colliders.
@@ -73,121 +84,35 @@ public:
 
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
+private: //generic
+	ColliderStorType check_collider_type(const collider_stor& collider1,const collider_stor& collider2);
+
+	vec2 current_position(vec2 collider_offset, const Transform& transform, const Rigidbody& rigidbody);
+
+private:// handeling
+
+	void collision_handler_request(CollidedInfoStor& data1,CollidedInfoStor& data2);
+
+	std::pair<vec2,Direction> collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2 ,ColliderStorType type);
+
 
-private:
-	/**
-		* \brief Handles a collision between two colliders.
-		* 
-		* This function calculates the necessary response to resolve the collision, including
-		* moving the objects back to prevent overlap and applying any velocity changes.
-		*
-		* \param data1 The collision data for the first collider.
-		* \param data2 The collision data for the second collider.
-		*/
-	void collision_handler(CollidedInfoStor& data1,CollidedInfoStor& data2);
 	
-	/**
-		* \brief Resolves the movement of two box colliders that are colliding.
-		* 
-		* This function calculates the smallest overlap (along the X or Y axis) and determines
-		* the move-back vector to prevent overlap.
-		*
-		* \param box_collider1 The first box collider.
-		* \param box_collider2 The second box collider.
-		* \param final_position1 The final position of the first box collider.
-		* \param final_position2 The final position of the second box collider.
-		* \return The move-back vector to resolve the collision.
-		*/
-	vec2 box_box_collision_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2);
+	vec2 box_box_move_back(const BoxCollider& box_collider1,const BoxCollider& box_collider2,vec2 position1,vec2 position2);
 
-	/**
-		* \brief Determines the appropriate collision handler based on the rigidbody types of the colliding objects.
-		* 
-		* This function checks if the second object is static, and if so, it calls the static collision handler.
-		* Otherwise, it triggers a collision event.
-		*
-		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
-		*/
 	void determine_collision_handler(CollisionInfo& info);
 
-	/**
-		* \brief Handles the collision with a static object.
-		* 
-		* This function resolves the collision by moving the object back and applying any bounce or stop behavior.
-		*
-		* \param info The collision information containing the colliders, transforms, rigidbodies, and move-back data.
-		*/
 	void static_collision_handler(CollisionInfo& info);
-private: //detection
+private: // detection
 	
-	/**
-		* \brief Checks for collisions between box colliders and circle colliders
-		* and returns the collision pairs that need to be resolved.
-		* 
-		* \param boxcolliders A vector of references to all box colliders.
-		* \param circlecolliders A vector of references to all circle colliders.
-		* \return A vector of pairs containing collision information for the detected collisions.
-		*/
-	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(const std::vector<std::reference_wrapper<BoxCollider>>& boxcolliders, const std::vector<std::reference_wrapper<CircleCollider>>& circlecolliders);
+	std::vector<std::pair<CollidedInfoStor,CollidedInfoStor>> check_collisions(std::vector<collider_stor> & colliders);
+
+	bool check_collision(const collider_stor& collider1,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components1,const collider_stor& collider2,std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>> components2,CollisionSystem::ColliderStorType type);
 	
-	/**
-		* \brief Checks for a collision between two box colliders.
-		* 
-		* This function checks if two box colliders overlap based on their positions and dimensions.
-		*
-		* \param box1 The first box collider.
-		* \param box2 The second box collider.
-		* \param transform1 The transform component of the first box collider.
-		* \param transform2 The transform component of the second box collider.
-		* \param rigidbody1 The rigidbody component of the first box collider.
-		* \param rigidbody2 The rigidbody component of the second box collider.
-		* \return True if the two box colliders overlap, otherwise false.
-		*/
 	bool check_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
 	
-	/**
-		* \brief Checks for a collision between a box collider and a circle collider.
-		* 
-		* This function checks if a box collider overlaps with a circle collider based on their positions
-		* and dimensions.
-		*
-		* \param box1 The box collider.
-		* \param circle2 The circle collider.
-		* \param transform1 The transform component of the box collider.
-		* \param transform2 The transform component of the circle collider.
-		* \param rigidbody1 The rigidbody component of the box collider.
-		* \param rigidbody2 The rigidbody component of the circle collider.
-		* \return True if the box collider and circle collider overlap, otherwise false.
-		*/
 	bool check_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	
-	/**
-		* \brief Checks for a collision between two circle colliders.
-		* 
-		* This function checks if two circle colliders overlap based on their positions and radii.
-		*
-		* \param circle1 The first circle collider.
-		* \param circle2 The second circle collider.
-		* \param transform1 The transform component of the first circle collider.
-		* \param transform2 The transform component of the second circle collider.
-		* \param rigidbody1 The rigidbody component of the first circle collider.
-		* \param rigidbody2 The rigidbody component of the second circle collider.
-		* \return True if the two circle colliders overlap, otherwise false.
-		*/
+
 	bool check_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2);
-	
-	/**
-		* \brief Gets the current position of a collider by combining its transform and rigidbody data.
-		* 
-		* This function calculates the current position of the collider by considering its transform and 
-		* rigidbody velocity.
-		*
-		* \param collider The collider whose position is being determined.
-		* \param transform The transform component associated with the collider.
-		* \param rigidbody The rigidbody component associated with the collider.
-		* \return The current position of the collider as a vec2.
-		*/
-	vec2 current_position(const Collider& collider, const Transform& transform, const Rigidbody& rigidbody);
 };
 
 } // namespace crepe
diff --git a/src/example/game.cpp b/src/example/game.cpp
index 991d2ec..afa8c10 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -65,9 +65,9 @@ public:
 		.mass = 1,
 		.gravity_scale = 0.01,
 		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,0},
+		.linear_velocity = {1,1},
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
+		.use_gravity = false,
 		.bounce = true,
 		.elastisity = 1,
 		.offset = {0,0},
-- 
cgit v1.2.3


From b6d255762de0bfd5dd096f7eae295a6b1b357bbb Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 22 Nov 2024 22:01:18 +0100
Subject: added gravity to object

---
 src/example/game.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/example')

diff --git a/src/example/game.cpp b/src/example/game.cpp
index afa8c10..e851526 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -67,7 +67,7 @@ public:
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.linear_velocity = {1,1},
 		.constraints = {0, 0, 0},
-		.use_gravity = false,
+		.use_gravity = true,
 		.bounce = true,
 		.elastisity = 1,
 		.offset = {0,0},
-- 
cgit v1.2.3


From 444ec7306c8ef43d36f7c6d6e767571b30d10484 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Sat, 23 Nov 2024 19:50:01 +0100
Subject: Fixing PR

---
 src/example/events.cpp    | 113 ----------------------------------------------
 src/example/rendering.cpp |  59 ------------------------
 2 files changed, 172 deletions(-)
 delete mode 100644 src/example/events.cpp
 delete mode 100644 src/example/rendering.cpp

(limited to 'src/example')

diff --git a/src/example/events.cpp b/src/example/events.cpp
deleted file mode 100644
index e6d91aa..0000000
--- a/src/example/events.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <iostream>
-
-#include <crepe/ComponentManager.h>
-#include <crepe/system/ScriptSystem.h>
-#include <crepe/util/Log.h>
-
-#include <crepe/api/BehaviorScript.h>
-#include <crepe/api/Config.h>
-#include <crepe/api/Event.h>
-#include <crepe/api/EventManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/IKeyListener.h>
-#include <crepe/api/IMouseListener.h>
-#include <crepe/api/KeyCodes.h>
-#include <crepe/api/Script.h>
-#include <crepe/api/Transform.h>
-
-using namespace crepe;
-using namespace std;
-
-class MyScript : public Script, public IKeyListener, public IMouseListener {
-	void update() {
-		// Retrieve component from the same GameObject this script is on
-		Transform & test = get_component<Transform>();
-		dbg_logf("Transform(%.2f, %.2f)", test.position.x, test.position.y);
-	}
-
-	bool on_key_pressed(const KeyPressEvent & event) override {
-		std::cout << "KeyPressed function" << std::endl;
-		this->deactivate_keys();
-		return false;
-	}
-	bool on_key_released(const KeyReleaseEvent & event) override {
-		std::cout << "KeyRelease function" << std::endl;
-		return false;
-	}
-	bool on_mouse_clicked(const MouseClickEvent & event) override {
-		std::cout << "MouseClick function" << std::endl;
-		return false;
-	}
-	bool on_mouse_pressed(const MousePressEvent & event) override {
-		std::cout << "MousePress function" << std::endl;
-		return false;
-	}
-	bool on_mouse_released(const MouseReleaseEvent & event) override {
-		std::cout << "MouseRelease function" << std::endl;
-		return false;
-	}
-	bool on_mouse_moved(const MouseMoveEvent & event) override {
-		std::cout << "MouseMove function" << std::endl;
-		return false;
-	}
-};
-class TestKeyListener : public IKeyListener {
-public:
-	bool on_key_pressed(const KeyPressEvent & event) override {
-		std::cout << "TestKeyListener: Key Pressed - Code: "
-				  << static_cast<int>(event.key) << std::endl;
-		return true; // Return true if the listener should remain active
-	}
-	bool on_key_released(const KeyReleaseEvent & event) override {
-		std::cout << "TestKeyListener: Key Released - Code: "
-				  << static_cast<int>(event.key) << std::endl;
-		return true;
-	}
-};
-int main() {
-	EventManager & evmgr = EventManager::get_instance();
-	ComponentManager mgr{};
-	ScriptSystem sys{mgr};
-
-	// two events to trigger
-	KeyPressEvent key_press;
-	key_press.key = Keycode::A;
-	key_press.repeat = 0;
-	MouseClickEvent click_event;
-	click_event.button = MouseButton::LEFT_MOUSE;
-	click_event.mouse_x = 100;
-	click_event.mouse_y = 200;
-	// queue events to test queue
-	evmgr.queue_event<KeyPressEvent>(std::move(key_press), 0);
-	evmgr.queue_event<MouseClickEvent>(std::move(click_event), 0);
-	{
-		TestKeyListener test_listener;
-		test_listener.set_channel(1);
-		auto obj = mgr.new_object("name", "tag", Vector2{1.2, 3.4}, 0, 1);
-		obj.add_component<BehaviorScript>().set_script<MyScript>();
-
-		sys.update();
-
-		// Trigger the events while `testListener` is in scope
-		evmgr.trigger_event<KeyPressEvent>(key_press, 1);
-		evmgr.trigger_event(MouseClickEvent{
-    		.mouse_x = 100,
-    		.mouse_y = 100,
-    		.button = MouseButton::LEFT_MOUSE,
-			},1);
-	}
-	// custom lambda event handler
-	EventHandler<KeyPressEvent> event_handler = [](const KeyPressEvent & e) {
-		std::cout << "lambda test" << std::endl;
-		return false;
-	};
-	evmgr.subscribe<KeyPressEvent>(std::move(event_handler), 0);
-	// testing trigger with testListener not in scope (unsubscribed)
-	evmgr.trigger_event<KeyPressEvent>(key_press, 0);
-	evmgr.trigger_event<MouseClickEvent>(click_event, 0);
-	// dispatching queued events
-	evmgr.dispatch_events();
-
-	evmgr.unsubscribe<KeyPressEvent>(event_handler, 0);
-	return EXIT_SUCCESS;
-}
diff --git a/src/example/rendering.cpp b/src/example/rendering.cpp
deleted file mode 100644
index 9e3c8cc..0000000
--- a/src/example/rendering.cpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#include "api/Camera.h"
-#include <crepe/ComponentManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/system/RenderSystem.h>
-#include <crepe/util/Log.h>
-
-#include <crepe/api/AssetManager.h>
-#include <crepe/api/Color.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Transform.h>
-#include <crepe/api/Vector2.h>
-
-#include <chrono>
-#include <memory>
-
-using namespace std;
-using namespace crepe;
-
-int main() {
-	dbg_trace();
-
-	ComponentManager mgr{};
-	RenderSystem sys{mgr};
-
-	GameObject obj = mgr.new_object("name", "tag", Vector2{0, 0}, 1, 1);
-	GameObject obj1 = mgr.new_object("name", "tag", Vector2{500, 0}, 1, 0.1);
-	GameObject obj2 = mgr.new_object("name", "tag", Vector2{800, 0}, 1, 0.1);
-
-	// Normal adding components
-	{
-		Color color(0, 0, 0, 0);
-		obj.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
-								  FlipSettings{false, false});
-		obj.add_component<Camera>(Color::RED);
-	}
-	{
-		Color color(0, 0, 0, 0);
-		obj1.add_component<Sprite>(make_shared<Texture>("../asset/texture/green_square.png"), color,
-								   FlipSettings{true, true});
-	}
-
-	/*
-	{
-		Color color(0, 0, 0, 0);
-		auto img = mgr.cache<Texture>("../asset/texture/second.png");
-		obj2.add_component<Sprite>(img, color, FlipSettings{true, true});
-	}
-	*/
-
-	sys.update();
-	/*
-
-	auto start = std::chrono::steady_clock::now();
-	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-		sys.update();
-	}
-	*/
-}
-- 
cgit v1.2.3


From 48015cd425b26eb68eb07f4e4b1adf71e81e11b1 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 25 Nov 2024 11:48:39 +0100
Subject: make format

---
 mwe/events/include/event.h       |   2 +-
 src/crepe/api/Button.cpp         |   2 +-
 src/crepe/api/Button.h           |  28 +--
 src/crepe/api/Event.h            |   6 +-
 src/crepe/api/KeyCodes.h         | 284 +++++++++++++++----------------
 src/crepe/api/LoopManager.cpp    |   6 +-
 src/crepe/api/UiObject.h         |  16 +-
 src/crepe/facade/SDLContext.cpp  | 357 +++++++++++++++++++--------------------
 src/crepe/facade/SDLContext.h    |  16 +-
 src/crepe/system/InputSystem.cpp | 259 ++++++++++++++--------------
 src/crepe/system/InputSystem.h   |  43 ++---
 src/example/gameloop.cpp         |  22 ++-
 src/test/EventTest.cpp           |  74 ++++----
 src/test/inputTest.cpp           | 307 +++++++++++++++++----------------
 src/test/loopTimerTest.cpp       |  25 ++-
 15 files changed, 714 insertions(+), 733 deletions(-)

(limited to 'src/example')

diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index ee1bf52..e1b220b 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -148,7 +148,7 @@ private:
 };
 class ShutDownEvent : public Event {
 public:
-	ShutDownEvent() : Event("ShutDownEvent") {};
+	ShutDownEvent() : Event("ShutDownEvent"){};
 
 	REGISTER_EVENT_TYPE(ShutDownEvent)
 
diff --git a/src/crepe/api/Button.cpp b/src/crepe/api/Button.cpp
index 70f749d..547c0fc 100644
--- a/src/crepe/api/Button.cpp
+++ b/src/crepe/api/Button.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Button::Button(game_object_id_t id) : UiObject(id){}
+Button::Button(game_object_id_t id) : UiObject(id) {}
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
index f769d58..0056238 100644
--- a/src/crepe/api/Button.h
+++ b/src/crepe/api/Button.h
@@ -12,33 +12,33 @@ namespace crepe {
  */
 class Button : public UiObject {
 public:
-    /**
+	/**
      * \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);
+	Button(game_object_id_t id);
 
-    //! Indicates if the button is interactable (can be clicked).
-    bool interactable = true;
+	//! 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 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 button is currently pressed.
+	bool is_pressed = false;
 
-    //! Indicates whether the mouse is currently hovering over the button.
-    bool hover = 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;
+	//! The callback function to be executed when the button is clicked.
+	std::function<void()> on_click;
 
 public:
-    /**
+	/**
      * \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; }
+	virtual int get_instances_max() const override { return 1; }
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 46dd86b..2018d52 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -89,9 +89,9 @@ public:
 	//! Y-coordinate of the mouse position at the time of the event.
 	int mouse_y = 0;
 	// Relative movement in x
-    int rel_x;
+	int rel_x;
 	// Relative movement in y
-    int rel_y; 
+	int rel_y;
 };
 
 /**
@@ -127,4 +127,4 @@ class ShutDownEvent : public Event {
 public:
 };
 
-}
+} // namespace crepe
diff --git a/src/crepe/api/KeyCodes.h b/src/crepe/api/KeyCodes.h
index 4b026c5..fcfc080 100644
--- a/src/crepe/api/KeyCodes.h
+++ b/src/crepe/api/KeyCodes.h
@@ -1,154 +1,154 @@
 #pragma once
 namespace crepe {
-	//! Enumeration for mouse button inputs, including standard and extended buttons.
-	enum class MouseButton {
-		NONE = 0, //!< No mouse button input.
-		LEFT_MOUSE = 1, //!< Left mouse button.
-		RIGHT_MOUSE = 2, //!< Right mouse button.
-		MIDDLE_MOUSE = 3, //!< Middle mouse button (scroll wheel press).
-		X1_MOUSE = 4, //!< First extended mouse button.
-		X2_MOUSE = 5, //!< Second extended mouse button.
-		SCROLL_UP = 6, //!< Scroll wheel upward movement.
-		SCROLL_DOWN = 7, //!< Scroll wheel downward movement.
-	};
+//! Enumeration for mouse button inputs, including standard and extended buttons.
+enum class MouseButton {
+	NONE = 0, //!< No mouse button input.
+	LEFT_MOUSE = 1, //!< Left mouse button.
+	RIGHT_MOUSE = 2, //!< Right mouse button.
+	MIDDLE_MOUSE = 3, //!< Middle mouse button (scroll wheel press).
+	X1_MOUSE = 4, //!< First extended mouse button.
+	X2_MOUSE = 5, //!< Second extended mouse button.
+	SCROLL_UP = 6, //!< Scroll wheel upward movement.
+	SCROLL_DOWN = 7, //!< Scroll wheel downward movement.
+};
 
-	//! Enumeration for keyboard key inputs, including printable characters, function keys, and keypad keys.
-	enum class Keycode {
-		NONE = 0, //!< No key input.
-		SPACE = 32, //!< Spacebar.
-		APOSTROPHE = 39, //!< Apostrophe (').
-		COMMA = 44, //!< Comma (,).
-		MINUS = 45, //!< Minus (-).
-		PERIOD = 46, //!< Period (.).
-		SLASH = 47, //!< Slash (/).
-		D0 = 48, //!< Digit 0.
-		D1 = 49, //!< Digit 1.
-		D2 = 50, //!< Digit 2.
-		D3 = 51, //!< Digit 3.
-		D4 = 52, //!< Digit 4.
-		D5 = 53, //!< Digit 5.
-		D6 = 54, //!< Digit 6.
-		D7 = 55, //!< Digit 7.
-		D8 = 56, //!< Digit 8.
-		D9 = 57, //!< Digit 9.
-		SEMICOLON = 59, //!< Semicolon (;).
-		EQUAL = 61, //!< Equal sign (=).
-		A = 65, //!< Key 'A'.
-		B = 66, //!< Key 'B'.
-		C = 67, //!< Key 'C'.
-		D = 68, //!< Key 'D'.
-		E = 69, //!< Key 'E'.
-		F = 70, //!< Key 'F'.
-		G = 71, //!< Key 'G'.
-		H = 72, //!< Key 'H'.
-		I = 73, //!< Key 'I'.
-		J = 74, //!< Key 'J'.
-		K = 75, //!< Key 'K'.
-		L = 76, //!< Key 'L'.
-		M = 77, //!< Key 'M'.
-		N = 78, //!< Key 'N'.
-		O = 79, //!< Key 'O'.
-		P = 80, //!< Key 'P'.
-		Q = 81, //!< Key 'Q'.
-		R = 82, //!< Key 'R'.
-		S = 83, //!< Key 'S'.
-		T = 84, //!< Key 'T'.
-		U = 85, //!< Key 'U'.
-		V = 86, //!< Key 'V'.
-		W = 87, //!< Key 'W'.
-		X = 88, //!< Key 'X'.
-		Y = 89, //!< Key 'Y'.
-		Z = 90, //!< Key 'Z'.
-		LEFT_BRACKET = 91, //!< Left bracket ([).
-		BACKSLASH = 92, //!< Backslash (\).
-		RIGHT_BRACKET = 93, //!< Right bracket (]).
-		GRAVE_ACCENT = 96, //!< Grave accent (`).
-		WORLD1 = 161, //!< Non-US key #1.
-		WORLD2 = 162, //!< Non-US key #2.
-		ESCAPE = 256, //!< Escape key.
-		ENTER = 257, //!< Enter key.
-		TAB = 258, //!< Tab key.
-		BACKSPACE = 259, //!< Backspace key.
-		INSERT = 260, //!< Insert key.
-		DELETE = 261, //!< Delete key.
-		RIGHT = 262, //!< Right arrow key.
-		LEFT = 263, //!< Left arrow key.
-		DOWN = 264, //!< Down arrow key.
-		UP = 265, //!< Up arrow key.
-		PAGE_UP = 266, //!< Page Up key.
-		PAGE_DOWN = 267, //!< Page Down key.
-		HOME = 268, //!< Home key.
-		END = 269, //!< End key.
-		CAPS_LOCK = 280, //!< Caps Lock key.
-		SCROLL_LOCK = 281, //!< Scroll Lock key.
-		NUM_LOCK = 282, //!< Num Lock key.
-		PRINT_SCREEN = 283, //!< Print Screen key.
-		PAUSE = 284, //!< Pause key.
-		/**
+//! Enumeration for keyboard key inputs, including printable characters, function keys, and keypad keys.
+enum class Keycode {
+	NONE = 0, //!< No key input.
+	SPACE = 32, //!< Spacebar.
+	APOSTROPHE = 39, //!< Apostrophe (').
+	COMMA = 44, //!< Comma (,).
+	MINUS = 45, //!< Minus (-).
+	PERIOD = 46, //!< Period (.).
+	SLASH = 47, //!< Slash (/).
+	D0 = 48, //!< Digit 0.
+	D1 = 49, //!< Digit 1.
+	D2 = 50, //!< Digit 2.
+	D3 = 51, //!< Digit 3.
+	D4 = 52, //!< Digit 4.
+	D5 = 53, //!< Digit 5.
+	D6 = 54, //!< Digit 6.
+	D7 = 55, //!< Digit 7.
+	D8 = 56, //!< Digit 8.
+	D9 = 57, //!< Digit 9.
+	SEMICOLON = 59, //!< Semicolon (;).
+	EQUAL = 61, //!< Equal sign (=).
+	A = 65, //!< Key 'A'.
+	B = 66, //!< Key 'B'.
+	C = 67, //!< Key 'C'.
+	D = 68, //!< Key 'D'.
+	E = 69, //!< Key 'E'.
+	F = 70, //!< Key 'F'.
+	G = 71, //!< Key 'G'.
+	H = 72, //!< Key 'H'.
+	I = 73, //!< Key 'I'.
+	J = 74, //!< Key 'J'.
+	K = 75, //!< Key 'K'.
+	L = 76, //!< Key 'L'.
+	M = 77, //!< Key 'M'.
+	N = 78, //!< Key 'N'.
+	O = 79, //!< Key 'O'.
+	P = 80, //!< Key 'P'.
+	Q = 81, //!< Key 'Q'.
+	R = 82, //!< Key 'R'.
+	S = 83, //!< Key 'S'.
+	T = 84, //!< Key 'T'.
+	U = 85, //!< Key 'U'.
+	V = 86, //!< Key 'V'.
+	W = 87, //!< Key 'W'.
+	X = 88, //!< Key 'X'.
+	Y = 89, //!< Key 'Y'.
+	Z = 90, //!< Key 'Z'.
+	LEFT_BRACKET = 91, //!< Left bracket ([).
+	BACKSLASH = 92, //!< Backslash (\).
+	RIGHT_BRACKET = 93, //!< Right bracket (]).
+	GRAVE_ACCENT = 96, //!< Grave accent (`).
+	WORLD1 = 161, //!< Non-US key #1.
+	WORLD2 = 162, //!< Non-US key #2.
+	ESCAPE = 256, //!< Escape key.
+	ENTER = 257, //!< Enter key.
+	TAB = 258, //!< Tab key.
+	BACKSPACE = 259, //!< Backspace key.
+	INSERT = 260, //!< Insert key.
+	DELETE = 261, //!< Delete key.
+	RIGHT = 262, //!< Right arrow key.
+	LEFT = 263, //!< Left arrow key.
+	DOWN = 264, //!< Down arrow key.
+	UP = 265, //!< Up arrow key.
+	PAGE_UP = 266, //!< Page Up key.
+	PAGE_DOWN = 267, //!< Page Down key.
+	HOME = 268, //!< Home key.
+	END = 269, //!< End key.
+	CAPS_LOCK = 280, //!< Caps Lock key.
+	SCROLL_LOCK = 281, //!< Scroll Lock key.
+	NUM_LOCK = 282, //!< Num Lock key.
+	PRINT_SCREEN = 283, //!< Print Screen key.
+	PAUSE = 284, //!< Pause key.
+	/**
 		 * \name Function keys (F1-F25).
 		 * \{
 		 */
-		F1 = 290,
-		F2 = 291,
-		F3 = 292,
-		F4 = 293,
-		F5 = 294,
-		F6 = 295,
-		F7 = 296,
-		F8 = 297,
-		F9 = 298,
-		F10 = 299,
-		F11 = 300,
-		F12 = 301,
-		F13 = 302,
-		F14 = 303,
-		F15 = 304,
-		F16 = 305,
-		F17 = 306,
-		F18 = 307,
-		F19 = 308,
-		F20 = 309,
-		F21 = 310,
-		F22 = 311,
-		F23 = 312,
-		F24 = 313,
-		F25 = 314,
-		/// \}
-		/**
+	F1 = 290,
+	F2 = 291,
+	F3 = 292,
+	F4 = 293,
+	F5 = 294,
+	F6 = 295,
+	F7 = 296,
+	F8 = 297,
+	F9 = 298,
+	F10 = 299,
+	F11 = 300,
+	F12 = 301,
+	F13 = 302,
+	F14 = 303,
+	F15 = 304,
+	F16 = 305,
+	F17 = 306,
+	F18 = 307,
+	F19 = 308,
+	F20 = 309,
+	F21 = 310,
+	F22 = 311,
+	F23 = 312,
+	F24 = 313,
+	F25 = 314,
+	/// \}
+	/**
 		 * \name Keypad digits and operators.
 		 * \{
 		 */
-		KP0 = 320,
-		KP1 = 321,
-		KP2 = 322,
-		KP3 = 323,
-		KP4 = 324,
-		KP5 = 325,
-		KP6 = 326,
-		KP7 = 327,
-		KP8 = 328,
-		KP9 = 329,
-		KP_DECIMAL = 330,
-		KP_DIVIDE = 331,
-		KP_MULTIPLY = 332,
-		KP_SUBTRACT = 333,
-		KP_ADD = 334,
-		KP_ENTER = 335,
-		KP_EQUAL = 336,
-		/// \}
-		/**
+	KP0 = 320,
+	KP1 = 321,
+	KP2 = 322,
+	KP3 = 323,
+	KP4 = 324,
+	KP5 = 325,
+	KP6 = 326,
+	KP7 = 327,
+	KP8 = 328,
+	KP9 = 329,
+	KP_DECIMAL = 330,
+	KP_DIVIDE = 331,
+	KP_MULTIPLY = 332,
+	KP_SUBTRACT = 333,
+	KP_ADD = 334,
+	KP_ENTER = 335,
+	KP_EQUAL = 336,
+	/// \}
+	/**
 		 * \name Modifier keys.
 		 * \{
 		 */
-		LEFT_SHIFT = 340,
-		LEFT_CONTROL = 341,
-		LEFT_ALT = 342,
-		LEFT_SUPER = 343,
-		RIGHT_SHIFT = 344,
-		RIGHT_CONTROL = 345,
-		RIGHT_ALT = 346,
-		RIGHT_SUPER = 347,
-		/// \}
-		MENU = 348, //!< Menu key.
-	};
-}
+	LEFT_SHIFT = 340,
+	LEFT_CONTROL = 341,
+	LEFT_ALT = 342,
+	LEFT_SUPER = 343,
+	RIGHT_SHIFT = 344,
+	RIGHT_CONTROL = 345,
+	RIGHT_ALT = 346,
+	RIGHT_SUPER = 347,
+	/// \}
+	MENU = 348, //!< Menu key.
+};
+} // namespace crepe
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 9599943..b343250 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -2,11 +2,11 @@
 
 #include "../system/AnimatorSystem.h"
 #include "../system/CollisionSystem.h"
+#include "../system/InputSystem.h"
 #include "../system/ParticleSystem.h"
 #include "../system/PhysicsSystem.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
-#include "../system/InputSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
@@ -24,9 +24,7 @@ LoopManager::LoopManager() {
 	this->load_system<InputSystem>();
 }
 
-void LoopManager::process_input() {
-	this->get_system<InputSystem>().update();
-}
+void LoopManager::process_input() { this->get_system<InputSystem>().update(); }
 
 void LoopManager::start() {
 	this->setup();
diff --git a/src/crepe/api/UiObject.h b/src/crepe/api/UiObject.h
index ae2e744..7bd1c2e 100644
--- a/src/crepe/api/UiObject.h
+++ b/src/crepe/api/UiObject.h
@@ -10,24 +10,24 @@ namespace crepe {
  */
 class UiObject : public Component {
 public:
-    /**
+	/**
      * \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);
+	UiObject(game_object_id_t id);
 
-    //! The width of the UI object.
-    int width = 0;
+	//! The width of the UI object.
+	int width = 0;
 
-    //! The height of the UI object.
-    int height = 0;
+	//! The height of the UI object.
+	int height = 0;
 
 public:
-    /**
+	/**
      * \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; }
+	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 a37392f..8ed3654 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -5,23 +5,22 @@
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_surface.h>
 #include <SDL2/SDL_video.h>
+#include <array>
 #include <cmath>
 #include <cstddef>
 #include <functional>
 #include <memory>
 #include <stdexcept>
 #include <string>
-#include <array>
 
 #include "../api/Camera.h"
+#include "../api/EventManager.h"
 #include "../api/Sprite.h"
 #include "../api/Texture.h"
 #include "../api/Transform.h"
-#include "../api/EventManager.h"
 #include "../api/Vector2.h"
 #include "../util/Log.h"
 
-
 #include "SDLContext.h"
 
 using namespace crepe;
@@ -77,138 +76,138 @@ SDLContext::~SDLContext() {
 }
 
 Keycode SDLContext::sdl_to_keycode(SDL_Keycode sdl_key) {
-    static const std::array<Keycode, SDL_NUM_SCANCODES> LOOKUP_TABLE = [] {
-        std::array<Keycode, SDL_NUM_SCANCODES> table{};
-        table.fill(Keycode::NONE);
-
-        table[SDL_SCANCODE_SPACE] = Keycode::SPACE;
-        table[SDL_SCANCODE_APOSTROPHE] = Keycode::APOSTROPHE;
-        table[SDL_SCANCODE_COMMA] = Keycode::COMMA;
-        table[SDL_SCANCODE_MINUS] = Keycode::MINUS;
-        table[SDL_SCANCODE_PERIOD] = Keycode::PERIOD;
-        table[SDL_SCANCODE_SLASH] = Keycode::SLASH;
-        table[SDL_SCANCODE_0] = Keycode::D0;
-        table[SDL_SCANCODE_1] = Keycode::D1;
-        table[SDL_SCANCODE_2] = Keycode::D2;
-        table[SDL_SCANCODE_3] = Keycode::D3;
-        table[SDL_SCANCODE_4] = Keycode::D4;
-        table[SDL_SCANCODE_5] = Keycode::D5;
-        table[SDL_SCANCODE_6] = Keycode::D6;
-        table[SDL_SCANCODE_7] = Keycode::D7;
-        table[SDL_SCANCODE_8] = Keycode::D8;
-        table[SDL_SCANCODE_9] = Keycode::D9;
-        table[SDL_SCANCODE_SEMICOLON] = Keycode::SEMICOLON;
-        table[SDL_SCANCODE_EQUALS] = Keycode::EQUAL;
-        table[SDL_SCANCODE_A] = Keycode::A;
-        table[SDL_SCANCODE_B] = Keycode::B;
-        table[SDL_SCANCODE_C] = Keycode::C;
-        table[SDL_SCANCODE_D] = Keycode::D;
-        table[SDL_SCANCODE_E] = Keycode::E;
-        table[SDL_SCANCODE_F] = Keycode::F;
-        table[SDL_SCANCODE_G] = Keycode::G;
-        table[SDL_SCANCODE_H] = Keycode::H;
-        table[SDL_SCANCODE_I] = Keycode::I;
-        table[SDL_SCANCODE_J] = Keycode::J;
-        table[SDL_SCANCODE_K] = Keycode::K;
-        table[SDL_SCANCODE_L] = Keycode::L;
-        table[SDL_SCANCODE_M] = Keycode::M;
-        table[SDL_SCANCODE_N] = Keycode::N;
-        table[SDL_SCANCODE_O] = Keycode::O;
-        table[SDL_SCANCODE_P] = Keycode::P;
-        table[SDL_SCANCODE_Q] = Keycode::Q;
-        table[SDL_SCANCODE_R] = Keycode::R;
-        table[SDL_SCANCODE_S] = Keycode::S;
-        table[SDL_SCANCODE_T] = Keycode::T;
-        table[SDL_SCANCODE_U] = Keycode::U;
-        table[SDL_SCANCODE_V] = Keycode::V;
-        table[SDL_SCANCODE_W] = Keycode::W;
-        table[SDL_SCANCODE_X] = Keycode::X;
-        table[SDL_SCANCODE_Y] = Keycode::Y;
-        table[SDL_SCANCODE_Z] = Keycode::Z;
-        table[SDL_SCANCODE_LEFTBRACKET] = Keycode::LEFT_BRACKET;
-        table[SDL_SCANCODE_BACKSLASH] = Keycode::BACKSLASH;
-        table[SDL_SCANCODE_RIGHTBRACKET] = Keycode::RIGHT_BRACKET;
-        table[SDL_SCANCODE_GRAVE] = Keycode::GRAVE_ACCENT;
-        table[SDL_SCANCODE_ESCAPE] = Keycode::ESCAPE;
-        table[SDL_SCANCODE_RETURN] = Keycode::ENTER;
-        table[SDL_SCANCODE_TAB] = Keycode::TAB;
-        table[SDL_SCANCODE_BACKSPACE] = Keycode::BACKSPACE;
-        table[SDL_SCANCODE_INSERT] = Keycode::INSERT;
-        table[SDL_SCANCODE_DELETE] = Keycode::DELETE;
-        table[SDL_SCANCODE_RIGHT] = Keycode::RIGHT;
-        table[SDL_SCANCODE_LEFT] = Keycode::LEFT;
-        table[SDL_SCANCODE_DOWN] = Keycode::DOWN;
-        table[SDL_SCANCODE_UP] = Keycode::UP;
-        table[SDL_SCANCODE_PAGEUP] = Keycode::PAGE_UP;
-        table[SDL_SCANCODE_PAGEDOWN] = Keycode::PAGE_DOWN;
-        table[SDL_SCANCODE_HOME] = Keycode::HOME;
-        table[SDL_SCANCODE_END] = Keycode::END;
-        table[SDL_SCANCODE_CAPSLOCK] = Keycode::CAPS_LOCK;
-        table[SDL_SCANCODE_SCROLLLOCK] = Keycode::SCROLL_LOCK;
-        table[SDL_SCANCODE_NUMLOCKCLEAR] = Keycode::NUM_LOCK;
-        table[SDL_SCANCODE_PRINTSCREEN] = Keycode::PRINT_SCREEN;
-        table[SDL_SCANCODE_PAUSE] = Keycode::PAUSE;
-        table[SDL_SCANCODE_F1] = Keycode::F1;
-        table[SDL_SCANCODE_F2] = Keycode::F2;
-        table[SDL_SCANCODE_F3] = Keycode::F3;
-        table[SDL_SCANCODE_F4] = Keycode::F4;
-        table[SDL_SCANCODE_F5] = Keycode::F5;
-        table[SDL_SCANCODE_F6] = Keycode::F6;
-        table[SDL_SCANCODE_F7] = Keycode::F7;
-        table[SDL_SCANCODE_F8] = Keycode::F8;
-        table[SDL_SCANCODE_F9] = Keycode::F9;
-        table[SDL_SCANCODE_F10] = Keycode::F10;
-        table[SDL_SCANCODE_F11] = Keycode::F11;
-        table[SDL_SCANCODE_F12] = Keycode::F12;
-        table[SDL_SCANCODE_KP_0] = Keycode::KP0;
-        table[SDL_SCANCODE_KP_1] = Keycode::KP1;
-        table[SDL_SCANCODE_KP_2] = Keycode::KP2;
-        table[SDL_SCANCODE_KP_3] = Keycode::KP3;
-        table[SDL_SCANCODE_KP_4] = Keycode::KP4;
-        table[SDL_SCANCODE_KP_5] = Keycode::KP5;
-        table[SDL_SCANCODE_KP_6] = Keycode::KP6;
-        table[SDL_SCANCODE_KP_7] = Keycode::KP7;
-        table[SDL_SCANCODE_KP_8] = Keycode::KP8;
-        table[SDL_SCANCODE_KP_9] = Keycode::KP9;
-        table[SDL_SCANCODE_LSHIFT] = Keycode::LEFT_SHIFT;
-        table[SDL_SCANCODE_LCTRL] = Keycode::LEFT_CONTROL;
-        table[SDL_SCANCODE_LALT] = Keycode::LEFT_ALT;
-        table[SDL_SCANCODE_LGUI] = Keycode::LEFT_SUPER;
-        table[SDL_SCANCODE_RSHIFT] = Keycode::RIGHT_SHIFT;
-        table[SDL_SCANCODE_RCTRL] = Keycode::RIGHT_CONTROL;
-        table[SDL_SCANCODE_RALT] = Keycode::RIGHT_ALT;
-        table[SDL_SCANCODE_RGUI] = Keycode::RIGHT_SUPER;
-        table[SDL_SCANCODE_MENU] = Keycode::MENU;
-
-        return table;
-    }();
-
-    if (sdl_key < 0 || sdl_key >= SDL_NUM_SCANCODES) {
-        return Keycode::NONE;
-    }
-
-    return LOOKUP_TABLE[sdl_key];
+	static const std::array<Keycode, SDL_NUM_SCANCODES> LOOKUP_TABLE = [] {
+		std::array<Keycode, SDL_NUM_SCANCODES> table{};
+		table.fill(Keycode::NONE);
+
+		table[SDL_SCANCODE_SPACE] = Keycode::SPACE;
+		table[SDL_SCANCODE_APOSTROPHE] = Keycode::APOSTROPHE;
+		table[SDL_SCANCODE_COMMA] = Keycode::COMMA;
+		table[SDL_SCANCODE_MINUS] = Keycode::MINUS;
+		table[SDL_SCANCODE_PERIOD] = Keycode::PERIOD;
+		table[SDL_SCANCODE_SLASH] = Keycode::SLASH;
+		table[SDL_SCANCODE_0] = Keycode::D0;
+		table[SDL_SCANCODE_1] = Keycode::D1;
+		table[SDL_SCANCODE_2] = Keycode::D2;
+		table[SDL_SCANCODE_3] = Keycode::D3;
+		table[SDL_SCANCODE_4] = Keycode::D4;
+		table[SDL_SCANCODE_5] = Keycode::D5;
+		table[SDL_SCANCODE_6] = Keycode::D6;
+		table[SDL_SCANCODE_7] = Keycode::D7;
+		table[SDL_SCANCODE_8] = Keycode::D8;
+		table[SDL_SCANCODE_9] = Keycode::D9;
+		table[SDL_SCANCODE_SEMICOLON] = Keycode::SEMICOLON;
+		table[SDL_SCANCODE_EQUALS] = Keycode::EQUAL;
+		table[SDL_SCANCODE_A] = Keycode::A;
+		table[SDL_SCANCODE_B] = Keycode::B;
+		table[SDL_SCANCODE_C] = Keycode::C;
+		table[SDL_SCANCODE_D] = Keycode::D;
+		table[SDL_SCANCODE_E] = Keycode::E;
+		table[SDL_SCANCODE_F] = Keycode::F;
+		table[SDL_SCANCODE_G] = Keycode::G;
+		table[SDL_SCANCODE_H] = Keycode::H;
+		table[SDL_SCANCODE_I] = Keycode::I;
+		table[SDL_SCANCODE_J] = Keycode::J;
+		table[SDL_SCANCODE_K] = Keycode::K;
+		table[SDL_SCANCODE_L] = Keycode::L;
+		table[SDL_SCANCODE_M] = Keycode::M;
+		table[SDL_SCANCODE_N] = Keycode::N;
+		table[SDL_SCANCODE_O] = Keycode::O;
+		table[SDL_SCANCODE_P] = Keycode::P;
+		table[SDL_SCANCODE_Q] = Keycode::Q;
+		table[SDL_SCANCODE_R] = Keycode::R;
+		table[SDL_SCANCODE_S] = Keycode::S;
+		table[SDL_SCANCODE_T] = Keycode::T;
+		table[SDL_SCANCODE_U] = Keycode::U;
+		table[SDL_SCANCODE_V] = Keycode::V;
+		table[SDL_SCANCODE_W] = Keycode::W;
+		table[SDL_SCANCODE_X] = Keycode::X;
+		table[SDL_SCANCODE_Y] = Keycode::Y;
+		table[SDL_SCANCODE_Z] = Keycode::Z;
+		table[SDL_SCANCODE_LEFTBRACKET] = Keycode::LEFT_BRACKET;
+		table[SDL_SCANCODE_BACKSLASH] = Keycode::BACKSLASH;
+		table[SDL_SCANCODE_RIGHTBRACKET] = Keycode::RIGHT_BRACKET;
+		table[SDL_SCANCODE_GRAVE] = Keycode::GRAVE_ACCENT;
+		table[SDL_SCANCODE_ESCAPE] = Keycode::ESCAPE;
+		table[SDL_SCANCODE_RETURN] = Keycode::ENTER;
+		table[SDL_SCANCODE_TAB] = Keycode::TAB;
+		table[SDL_SCANCODE_BACKSPACE] = Keycode::BACKSPACE;
+		table[SDL_SCANCODE_INSERT] = Keycode::INSERT;
+		table[SDL_SCANCODE_DELETE] = Keycode::DELETE;
+		table[SDL_SCANCODE_RIGHT] = Keycode::RIGHT;
+		table[SDL_SCANCODE_LEFT] = Keycode::LEFT;
+		table[SDL_SCANCODE_DOWN] = Keycode::DOWN;
+		table[SDL_SCANCODE_UP] = Keycode::UP;
+		table[SDL_SCANCODE_PAGEUP] = Keycode::PAGE_UP;
+		table[SDL_SCANCODE_PAGEDOWN] = Keycode::PAGE_DOWN;
+		table[SDL_SCANCODE_HOME] = Keycode::HOME;
+		table[SDL_SCANCODE_END] = Keycode::END;
+		table[SDL_SCANCODE_CAPSLOCK] = Keycode::CAPS_LOCK;
+		table[SDL_SCANCODE_SCROLLLOCK] = Keycode::SCROLL_LOCK;
+		table[SDL_SCANCODE_NUMLOCKCLEAR] = Keycode::NUM_LOCK;
+		table[SDL_SCANCODE_PRINTSCREEN] = Keycode::PRINT_SCREEN;
+		table[SDL_SCANCODE_PAUSE] = Keycode::PAUSE;
+		table[SDL_SCANCODE_F1] = Keycode::F1;
+		table[SDL_SCANCODE_F2] = Keycode::F2;
+		table[SDL_SCANCODE_F3] = Keycode::F3;
+		table[SDL_SCANCODE_F4] = Keycode::F4;
+		table[SDL_SCANCODE_F5] = Keycode::F5;
+		table[SDL_SCANCODE_F6] = Keycode::F6;
+		table[SDL_SCANCODE_F7] = Keycode::F7;
+		table[SDL_SCANCODE_F8] = Keycode::F8;
+		table[SDL_SCANCODE_F9] = Keycode::F9;
+		table[SDL_SCANCODE_F10] = Keycode::F10;
+		table[SDL_SCANCODE_F11] = Keycode::F11;
+		table[SDL_SCANCODE_F12] = Keycode::F12;
+		table[SDL_SCANCODE_KP_0] = Keycode::KP0;
+		table[SDL_SCANCODE_KP_1] = Keycode::KP1;
+		table[SDL_SCANCODE_KP_2] = Keycode::KP2;
+		table[SDL_SCANCODE_KP_3] = Keycode::KP3;
+		table[SDL_SCANCODE_KP_4] = Keycode::KP4;
+		table[SDL_SCANCODE_KP_5] = Keycode::KP5;
+		table[SDL_SCANCODE_KP_6] = Keycode::KP6;
+		table[SDL_SCANCODE_KP_7] = Keycode::KP7;
+		table[SDL_SCANCODE_KP_8] = Keycode::KP8;
+		table[SDL_SCANCODE_KP_9] = Keycode::KP9;
+		table[SDL_SCANCODE_LSHIFT] = Keycode::LEFT_SHIFT;
+		table[SDL_SCANCODE_LCTRL] = Keycode::LEFT_CONTROL;
+		table[SDL_SCANCODE_LALT] = Keycode::LEFT_ALT;
+		table[SDL_SCANCODE_LGUI] = Keycode::LEFT_SUPER;
+		table[SDL_SCANCODE_RSHIFT] = Keycode::RIGHT_SHIFT;
+		table[SDL_SCANCODE_RCTRL] = Keycode::RIGHT_CONTROL;
+		table[SDL_SCANCODE_RALT] = Keycode::RIGHT_ALT;
+		table[SDL_SCANCODE_RGUI] = Keycode::RIGHT_SUPER;
+		table[SDL_SCANCODE_MENU] = Keycode::MENU;
+
+		return table;
+	}();
+
+	if (sdl_key < 0 || sdl_key >= SDL_NUM_SCANCODES) {
+		return Keycode::NONE;
+	}
+
+	return LOOKUP_TABLE[sdl_key];
 }
 MouseButton SDLContext::sdl_to_mousebutton(Uint8 sdl_button) {
-    static const std::array<MouseButton, 5> MOUSE_BUTTON_LOOKUP_TABLE = [] {
-        std::array<MouseButton, 5> table{};
-        table.fill(MouseButton::NONE);
-
-        table[SDL_BUTTON_LEFT] = MouseButton::LEFT_MOUSE;
-        table[SDL_BUTTON_RIGHT] = MouseButton::RIGHT_MOUSE;
-        table[SDL_BUTTON_MIDDLE] = MouseButton::MIDDLE_MOUSE;
-        table[SDL_BUTTON_X1] = MouseButton::X1_MOUSE;
-        table[SDL_BUTTON_X2] = MouseButton::X2_MOUSE;
-
-        return table;
-    }();
-
-    if (sdl_button >= MOUSE_BUTTON_LOOKUP_TABLE.size()) {
-		 // Return NONE for invalid or unmapped button
-        return MouseButton::NONE; 
-    }
+	static const std::array<MouseButton, 5> MOUSE_BUTTON_LOOKUP_TABLE = [] {
+		std::array<MouseButton, 5> table{};
+		table.fill(MouseButton::NONE);
+
+		table[SDL_BUTTON_LEFT] = MouseButton::LEFT_MOUSE;
+		table[SDL_BUTTON_RIGHT] = MouseButton::RIGHT_MOUSE;
+		table[SDL_BUTTON_MIDDLE] = MouseButton::MIDDLE_MOUSE;
+		table[SDL_BUTTON_X1] = MouseButton::X1_MOUSE;
+		table[SDL_BUTTON_X2] = MouseButton::X2_MOUSE;
+
+		return table;
+	}();
+
+	if (sdl_button >= MOUSE_BUTTON_LOOKUP_TABLE.size()) {
+		// Return NONE for invalid or unmapped button
+		return MouseButton::NONE;
+	}
 
-    return MOUSE_BUTTON_LOOKUP_TABLE[sdl_button];
+	return MOUSE_BUTTON_LOOKUP_TABLE[sdl_button];
 }
 void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); }
 void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
@@ -310,73 +309,63 @@ int SDLContext::get_height(const Texture & ctx) const {
 }
 void SDLContext::delay(int ms) const { SDL_Delay(ms); }
 
-std::vector<SDLContext::EventData> SDLContext::get_events(){
+std::vector<SDLContext::EventData> SDLContext::get_events() {
 	std::vector<SDLContext::EventData> event_list;
 	SDL_Event event;
 	while (SDL_PollEvent(&event)) {
-        switch (event.type) {
-            case SDL_QUIT:
-                event_list.push_back(EventData{
+		switch (event.type) {
+			case SDL_QUIT:
+				event_list.push_back(EventData{
 					.event_type = SDLContext::Event::SHUTDOWN,
 				});
 				break;
-            case SDL_KEYDOWN:
+			case SDL_KEYDOWN:
 				event_list.push_back(EventData{
 					.event_type = SDLContext::Event::KEYDOWN,
 					.key = sdl_to_keycode(event.key.keysym.scancode),
 					.key_repeat = (event.key.repeat != 0),
 				});
 				break;
-            case SDL_KEYUP:
+			case SDL_KEYUP:
 				event_list.push_back(EventData{
 					.event_type = SDLContext::Event::KEYUP,
 					.key = sdl_to_keycode(event.key.keysym.scancode),
 				});
-                break;
-            case SDL_MOUSEBUTTONDOWN:
-				{
-					int x,y;
-					SDL_GetMouseState(&x, &y);
-					event_list.push_back(EventData{
-						.event_type = SDLContext::Event::MOUSEDOWN,
-						.mouse_button = sdl_to_mousebutton(event.button.button),
-						.mouse_position = {event.button.x,event.button.y},
-					});
-				}
-                break;
-            case SDL_MOUSEBUTTONUP:
-                {
-					int x,y;
-					SDL_GetMouseState(&x, &y);
-					event_list.push_back(EventData{
-						.event_type = SDLContext::Event::MOUSEUP,
-						.mouse_button = sdl_to_mousebutton(event.button.button),
-						.mouse_position = {event.button.x,event.button.y},
-					});
-				}
-                break;
-
-            case SDL_MOUSEMOTION:
-                {
-					event_list.push_back(EventData{
-						.event_type = SDLContext::Event::MOUSEMOVE,
-						.mouse_position = {event.motion.x,event.motion.y},
-						.rel_mouse_move =  {event.motion.xrel,event.motion.yrel}
-					});
-				}
-                break;
-
-            case SDL_MOUSEWHEEL:
-                {
-					event_list.push_back(EventData{
-						.event_type = SDLContext::Event::MOUSEWHEEL,
-						.mouse_position = {event.motion.x,event.motion.y},
-						.wheel_delta = event.wheel.y,
-					});
-				}
-                break;
-        }
-    }
+				break;
+			case SDL_MOUSEBUTTONDOWN: {
+				int x, y;
+				SDL_GetMouseState(&x, &y);
+				event_list.push_back(EventData{
+					.event_type = SDLContext::Event::MOUSEDOWN,
+					.mouse_button = sdl_to_mousebutton(event.button.button),
+					.mouse_position = {event.button.x, event.button.y},
+				});
+			} break;
+			case SDL_MOUSEBUTTONUP: {
+				int x, y;
+				SDL_GetMouseState(&x, &y);
+				event_list.push_back(EventData{
+					.event_type = SDLContext::Event::MOUSEUP,
+					.mouse_button = sdl_to_mousebutton(event.button.button),
+					.mouse_position = {event.button.x, event.button.y},
+				});
+			} break;
+
+			case SDL_MOUSEMOTION: {
+				event_list.push_back(
+					EventData{.event_type = SDLContext::Event::MOUSEMOVE,
+							  .mouse_position = {event.motion.x, event.motion.y},
+							  .rel_mouse_move = {event.motion.xrel, event.motion.yrel}});
+			} break;
+
+			case SDL_MOUSEWHEEL: {
+				event_list.push_back(EventData{
+					.event_type = SDLContext::Event::MOUSEWHEEL,
+					.mouse_position = {event.motion.x, event.motion.y},
+					.wheel_delta = event.wheel.y,
+				});
+			} break;
+		}
+	}
 	return event_list;
 }
-
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 1b881d1..7ec11fd 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -6,15 +6,15 @@
 #include <SDL2/SDL_video.h>
 #include <cmath>
 #include <functional>
-#include <utility>
 #include <memory>
 #include <string>
+#include <utility>
 
-#include "../api/Sprite.h"
+#include "../api/Event.h"
 #include "../api/KeyCodes.h"
+#include "../api/Sprite.h"
 #include "../api/Transform.h"
 #include "../api/Vector2.h"
-#include "../api/Event.h"
 #include "api/Camera.h"
 
 #include "types.h"
@@ -36,7 +36,7 @@ class InputSystem;
 class SDLContext {
 
 public:
-	enum Event{
+	enum Event {
 		NONE = 0,
 		MOUSEDOWN,
 		MOUSEUP,
@@ -52,9 +52,9 @@ public:
 		Keycode key = Keycode::NONE;
 		bool key_repeat = false;
 		MouseButton mouse_button = MouseButton::NONE;
-		std::pair<int,int> mouse_position = {-1,-1};
+		std::pair<int, int> mouse_position = {-1, -1};
 		int wheel_delta = -1;
-		std::pair<int,int> rel_mouse_move = {-1,-1};
+		std::pair<int, int> rel_mouse_move = {-1, -1};
 	};
 	/**
 	 * \brief Gets the singleton instance of SDLContext.
@@ -75,11 +75,12 @@ private:
 	 * \param running Reference to a boolean flag that controls the main loop.
 	 */
 	std::vector<SDLContext::EventData> get_events();
-	
+
 	Keycode get_key();
 	Keycode get_mouse();
 	Keycode sdl_to_keycode(SDL_Keycode sdlKey);
 	MouseButton sdl_to_mousebutton(Uint8 sdl_button);
+
 private:
 	//! Will only use get_ticks
 	friend class AnimatorSystem;
@@ -197,5 +198,4 @@ private:
 	SDL_Rect viewport = {0, 0, 640, 480};
 };
 
-
 } // namespace crepe
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 1b455cd..7f7f9ec 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -1,154 +1,155 @@
 
-#include "ComponentManager.h"
-#include "../api/EventManager.h"
 #include "../api/Event.h"
-
+#include "../api/EventManager.h"
+#include "ComponentManager.h"
 
 #include "system/InputSystem.h"
 
 using namespace crepe;
 
 void InputSystem::update() {
-    EventManager &event_mgr = EventManager::get_instance();
-    std::vector<SDLContext::EventData> event_list = SDLContext::get_instance().get_events();
-
-    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,
-                    .key = event.key,
-                });
-                break;
-            }
-            case SDLContext::Event::KEYUP: {
-                event_mgr.queue_event<KeyReleaseEvent>(KeyReleaseEvent{
-                    .key = event.key,
-                });
-                break;
-            }
-            case SDLContext::Event::MOUSEDOWN: {
-                event_mgr.queue_event<MousePressEvent>(MousePressEvent{
-                    .mouse_x = event.mouse_position.first,
-                    .mouse_y = event.mouse_position.second,
-                    .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::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_y = event.rel_mouse_move.second,
-                });
-                handle_move(event);
-                break;
-            }
-            case SDLContext::Event::MOUSEWHEEL: {
-                event_mgr.queue_event<MouseScrollEvent>(MouseScrollEvent{
-                    .scroll_x = event.wheel_delta,
-                    .scroll_y = 0,
-                    .direction = event.wheel_delta,
-                });
-                break;
-            }
-            case SDLContext::Event::SHUTDOWN: {
-                event_mgr.queue_event<ShutDownEvent>(ShutDownEvent{});
-                break;
-            }
-            default:
-                break;
-        }
-    }
+	EventManager & event_mgr = EventManager::get_instance();
+	std::vector<SDLContext::EventData> event_list = SDLContext::get_instance().get_events();
+
+	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,
+					.key = event.key,
+				});
+				break;
+			}
+			case SDLContext::Event::KEYUP: {
+				event_mgr.queue_event<KeyReleaseEvent>(KeyReleaseEvent{
+					.key = event.key,
+				});
+				break;
+			}
+			case SDLContext::Event::MOUSEDOWN: {
+				event_mgr.queue_event<MousePressEvent>(MousePressEvent{
+					.mouse_x = event.mouse_position.first,
+					.mouse_y = event.mouse_position.second,
+					.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::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_y = event.rel_mouse_move.second,
+				});
+				handle_move(event);
+				break;
+			}
+			case SDLContext::Event::MOUSEWHEEL: {
+				event_mgr.queue_event<MouseScrollEvent>(MouseScrollEvent{
+					.scroll_x = event.wheel_delta,
+					.scroll_y = 0,
+					.direction = event.wheel_delta,
+				});
+				break;
+			}
+			case SDLContext::Event::SHUTDOWN: {
+				event_mgr.queue_event<ShutDownEvent>(ShutDownEvent{});
+				break;
+			}
+			default:
+				break;
+		}
+	}
 }
 
-void InputSystem::handle_move(const SDLContext::EventData &event_data) {
-    ComponentManager &mgr = this->component_manager;
+void InputSystem::handle_move(const SDLContext::EventData & event_data) {
+	ComponentManager & mgr = this->component_manager;
 
-    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>();
+	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;
+	for (Button & button : buttons) {
+		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;
-        }
-    }
+		if (button.interactable && is_mouse_inside_button(event_data, button, *transform)) {
+			button.hover = true;
+		} else {
+			button.hover = false;
+		}
+	}
 }
 
-void InputSystem::handle_click(const SDLContext::EventData &event_data) {
-    ComponentManager &mgr = this->component_manager;
+void InputSystem::handle_click(const SDLContext::EventData & event_data) {
+	ComponentManager & mgr = this->component_manager;
 
-    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>();
+	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;
+	for (Button & button : buttons) {
+		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);
-        }
-    }
+		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) {
-    for (Transform &transform : transforms) {
-        if (button.game_object_id == transform.game_object_id) {
-            return &transform;
-        }
-    }
-    return nullptr;
+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;
+		}
+	}
+	return nullptr;
 }
 
-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;
+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) {
-    if (button.is_toggle) {
-        if (!button.is_pressed && button.on_click) {
-            button.on_click();
-        }
-        button.is_pressed = !button.is_pressed;
-    } else if (button.on_click) {
-        button.on_click();
-    }
+void InputSystem::handle_button_press(Button & button) {
+	if (button.is_toggle) {
+		if (!button.is_pressed && button.on_click) {
+			button.on_click();
+		}
+		button.is_pressed = !button.is_pressed;
+	} else if (button.on_click) {
+		button.on_click();
+	}
 }
diff --git a/src/crepe/system/InputSystem.h b/src/crepe/system/InputSystem.h
index 672f225..5f94446 100644
--- a/src/crepe/system/InputSystem.h
+++ b/src/crepe/system/InputSystem.h
@@ -2,8 +2,8 @@
 
 #include "System.h"
 
-#include "../api/Event.h"
 #include "../api/Button.h"
+#include "../api/Event.h"
 #include "../api/Transform.h"
 #include "../facade/SDLContext.h"
 
@@ -19,64 +19,67 @@ namespace crepe {
  */
 class InputSystem : public System {
 public:
-    using System::System;
+	using System::System;
 
-    /**
+	/**
      * \brief Updates the system, processing all input events.
      * This method processes all events and triggers corresponding actions.
      */
-    void update() override;
+	void update() override;
 
 private:
-    //! 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 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;
+	//! Stores the last mouse button pressed.
+	MouseButton last_mouse_button = MouseButton::NONE;
 
-    //! The tolerance in pixels for detecting a mouse click.
-    const int click_tolerance = 5;
+	//! 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);
+	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);
+	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);
+	Transform *
+	find_transform_for_button(Button & button,
+							  std::vector<std::reference_wrapper<Transform>> & transforms);
 
-    /**
+	/**
      * \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);
+	bool is_mouse_inside_button(const SDLContext::EventData & eventData, const Button & button,
+								const Transform & transform);
 
-    /**
+	/**
      * \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);
+	void handle_button_press(Button & button);
 };
 
 } // namespace crepe
diff --git a/src/example/gameloop.cpp b/src/example/gameloop.cpp
index d45b3ce..b8ee9d8 100644
--- a/src/example/gameloop.cpp
+++ b/src/example/gameloop.cpp
@@ -1,17 +1,16 @@
-#include <iostream>
 #include "crepe/api/LoopManager.h"
 #include <crepe/api/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/IKeyListener.h>
 #include <crepe/api/IMouseListener.h>
+#include <iostream>
 using namespace crepe;
 class TestKeyListener : public IKeyListener {
 public:
 	bool on_key_pressed(const KeyPressEvent & event) override {
 		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
 				  << std::endl;
-		if(event.key == Keycode::ESCAPE){
-			
+		if (event.key == Keycode::ESCAPE) {
 		}
 		return false;
 	}
@@ -21,20 +20,19 @@ public:
 		return false;
 	}
 };
-bool on_key_pressed(const KeyPressEvent & event){
-		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
-				  << std::endl;
-		if(event.key == Keycode::ESCAPE){
-			return true;
-		}
-		return false;
+bool on_key_pressed(const KeyPressEvent & event) {
+	std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
+			  << std::endl;
+	if (event.key == Keycode::ESCAPE) {
+		return true;
 	}
+	return false;
+}
 int main() {
 	LoopManager gameloop;
 	TestKeyListener key_listener;
 	EventManager::get_instance().subscribe<KeyPressEvent>(on_key_pressed);
 	gameloop.start();
-	
-	
+
 	return 1;
 }
diff --git a/src/test/EventTest.cpp b/src/test/EventTest.cpp
index 4af0830..c75bcc1 100644
--- a/src/test/EventTest.cpp
+++ b/src/test/EventTest.cpp
@@ -154,44 +154,44 @@ 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;
-    
-    // Adjusted to use KeyPressEvent with repeat as the first variable
-    EventHandler<KeyPressEvent> key_handler1 = [&](const KeyPressEvent & e) {
-        triggered1 = true;
-        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<KeyPressEvent> key_handler2 = [&](const KeyPressEvent & e) {
-        triggered2 = true;
-        EXPECT_EQ(e.repeat, false);  // Expecting repeat to be false
-        EXPECT_EQ(e.key, Keycode::A);   // Adjust expected key code
-        return false; // Allows propagation
-    };
-
-    // 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);
-}
+	EventManager & event_manager = EventManager::get_instance();
+	bool triggered1 = false;
+	bool triggered2 = false;
+	int test_channel = 1;
 
+	// Adjusted to use KeyPressEvent with repeat as the first variable
+	EventHandler<KeyPressEvent> key_handler1 = [&](const KeyPressEvent & e) {
+		triggered1 = true;
+		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<KeyPressEvent> key_handler2 = [&](const KeyPressEvent & e) {
+		triggered2 = true;
+		EXPECT_EQ(e.repeat, false); // Expecting repeat to be false
+		EXPECT_EQ(e.key, Keycode::A); // Adjust expected key code
+		return false; // Allows propagation
+	};
+
+	// 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);
+}
 
 TEST_F(EventManagerTest, EventManagerTest_unsubscribe) {
 	EventManager & event_manager = EventManager::get_instance();
diff --git a/src/test/inputTest.cpp b/src/test/inputTest.cpp
index 8f3eb48..3a9d341 100644
--- a/src/test/inputTest.cpp
+++ b/src/test/inputTest.cpp
@@ -1,18 +1,17 @@
 #include <gtest/gtest.h>
 #define protected public
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_keycode.h>
-#include "system/InputSystem.h"
-#include <crepe/ComponentManager.h>
 #include "api/EventManager.h"
 #include "api/KeyCodes.h"
-#include <gmock/gmock.h>
+#include "system/InputSystem.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_keycode.h>
 #include <crepe/ComponentManager.h>
+#include <crepe/api/Button.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Metadata.h>
 #include <crepe/api/Transform.h>
 #include <crepe/api/Vector2.h>
-#include <crepe/api/Button.h>
+#include <gmock/gmock.h>
 
 using namespace std;
 using namespace std::chrono_literals;
@@ -20,77 +19,75 @@ using namespace crepe;
 
 class InputTest : public ::testing::Test {
 public:
-    ComponentManager mgr{};
-    InputSystem input_system{mgr};
+	ComponentManager mgr{};
+	InputSystem input_system{mgr};
 
-    EventManager& event_manager = EventManager::get_instance();
+	EventManager & event_manager = EventManager::get_instance();
 
 protected:
-    void SetUp() override {
-        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);
-        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);
-    }
+	void SetUp() override { 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);
+		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) {
-    bool mouse_triggered = false;
-    EventHandler<MousePressEvent> on_mouse_down = [&](const MousePressEvent& event) {
-        mouse_triggered = true;
-        EXPECT_EQ(event.mouse_x, 10);
-        EXPECT_EQ(event.mouse_y, 10);
-        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;
-    event.button.x = 10;
-    event.button.y = 10;
-    event.button.button = SDL_BUTTON_LEFT;
-    SDL_PushEvent(&event);
+	bool mouse_triggered = false;
+	EventHandler<MousePressEvent> on_mouse_down = [&](const MousePressEvent & event) {
+		mouse_triggered = true;
+		EXPECT_EQ(event.mouse_x, 10);
+		EXPECT_EQ(event.mouse_y, 10);
+		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;
+	event.button.x = 10;
+	event.button.y = 10;
+	event.button.button = SDL_BUTTON_LEFT;
+	SDL_PushEvent(&event);
 	input_system.update();
 	event_manager.dispatch_events();
-    EXPECT_TRUE(mouse_triggered);
+	EXPECT_TRUE(mouse_triggered);
 }
 
 TEST_F(InputTest, MouseUp) {
 	bool function_triggered = false;
-    EventHandler<MouseReleaseEvent> on_mouse_release = [&](const MouseReleaseEvent& e) {
-        // Handle the mouse click event here
+	EventHandler<MouseReleaseEvent> on_mouse_release = [&](const MouseReleaseEvent & e) {
+		// Handle the mouse click event here
 		function_triggered = true;
-        EXPECT_EQ(e.mouse_x, 10);
-        EXPECT_EQ(e.mouse_y, 10);
-        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 = 10;
-    event.button.y = 10;
-    event.button.button = SDL_BUTTON_LEFT;
-    SDL_PushEvent(&event);
+		EXPECT_EQ(e.mouse_x, 10);
+		EXPECT_EQ(e.mouse_y, 10);
+		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 = 10;
+	event.button.y = 10;
+	event.button.button = SDL_BUTTON_LEFT;
+	SDL_PushEvent(&event);
 	input_system.update();
 	event_manager.dispatch_events();
 	EXPECT_TRUE(function_triggered);
@@ -98,150 +95,148 @@ TEST_F(InputTest, MouseUp) {
 
 TEST_F(InputTest, MouseMove) {
 	bool function_triggered = false;
-    EventHandler<MouseMoveEvent> on_mouse_move = [&](const MouseMoveEvent& e) {
-        // Handle the mouse click event here
+	EventHandler<MouseMoveEvent> on_mouse_move = [&](const MouseMoveEvent & e) {
+		// Handle the mouse click event here
 		function_triggered = true;
-        EXPECT_EQ(e.mouse_x, 10);
-        EXPECT_EQ(e.mouse_y, 10);
+		EXPECT_EQ(e.mouse_x, 10);
+		EXPECT_EQ(e.mouse_y, 10);
 		EXPECT_EQ(e.rel_x, 10);
-        EXPECT_EQ(e.rel_y, 10);
-        return false;
-    };
-    event_manager.subscribe<MouseMoveEvent>(on_mouse_move);
-	
-    SDL_Event event;
-    SDL_zero(event);
-    event.type = SDL_MOUSEMOTION;
-    event.motion.x = 10;
-    event.motion.y = 10;
+		EXPECT_EQ(e.rel_y, 10);
+		return false;
+	};
+	event_manager.subscribe<MouseMoveEvent>(on_mouse_move);
+
+	SDL_Event event;
+	SDL_zero(event);
+	event.type = SDL_MOUSEMOTION;
+	event.motion.x = 10;
+	event.motion.y = 10;
 	event.motion.xrel = 10;
 	event.motion.yrel = 10;
-    SDL_PushEvent(&event);
+	SDL_PushEvent(&event);
 	input_system.update();
 	event_manager.dispatch_events();
 	EXPECT_TRUE(function_triggered);
 }
 
 TEST_F(InputTest, KeyDown) {
-    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
+	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) {
 	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);
+	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) {
-    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, 10);
-        EXPECT_EQ(event.mouse_y, 10);
-        return false;
-    };
-    event_manager.subscribe<MouseClickEvent>(on_mouse_click);
-	
-	this->simulate_mouse_click(10,10,SDL_BUTTON_LEFT);
+	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, 10);
+		EXPECT_EQ(event.mouse_y, 10);
+		return false;
+	};
+	event_manager.subscribe<MouseClickEvent>(on_mouse_click);
+
+	this->simulate_mouse_click(10, 10, SDL_BUTTON_LEFT);
 	input_system.update();
 	event_manager.dispatch_events();
-    EXPECT_TRUE(on_click_triggered);
+	EXPECT_TRUE(on_click_triggered);
 }
 
 TEST_F(InputTest, testButtonClick) {
-    GameObject obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
-    auto& button = obj.add_component<Button>();
+	GameObject obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	auto & button = obj.add_component<Button>();
 	bool button_clicked = false;
 	bool hover = false;
-    button.active = true;
+	button.active = true;
 	button.interactable = true;
-    button.width = 100;
-    button.height = 100;
-    std::function<void()> on_click = [&]() {
-        button_clicked = true;
-    };
+	button.width = 100;
+	button.height = 100;
+	std::function<void()> on_click = [&]() { button_clicked = true; };
 	button.on_click = on_click;
-    button.is_pressed = false;
-    button.is_toggle = false;
-    this->simulate_mouse_click(101,101, SDL_BUTTON_LEFT);
+	button.is_pressed = false;
+	button.is_toggle = false;
+	this->simulate_mouse_click(101, 101, SDL_BUTTON_LEFT);
 	input_system.update();
 	event_manager.dispatch_events();
 	EXPECT_FALSE(button_clicked);
-	this->simulate_mouse_click(10,10, SDL_BUTTON_LEFT);
+	this->simulate_mouse_click(10, 10, SDL_BUTTON_LEFT);
 	input_system.update();
 	event_manager.dispatch_events();
 	EXPECT_TRUE(button_clicked);
 }
 
 TEST_F(InputTest, testButtonHover) {
-    GameObject obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
-    auto& button = obj.add_component<Button>();
+	GameObject obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	auto & button = obj.add_component<Button>();
 	bool button_clicked = false;
-    button.active = true;
+	button.active = true;
 	button.interactable = true;
-    button.width = 100;
-    button.height = 100;
-    button.is_pressed = false;
-    button.is_toggle = false;
+	button.width = 100;
+	button.height = 100;
+	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 = 200;
-    event.motion.y = 200;
+	SDL_zero(event);
+	event.type = SDL_MOUSEMOTION;
+	event.motion.x = 200;
+	event.motion.y = 200;
 	event.motion.xrel = 10;
 	event.motion.yrel = 10;
-    SDL_PushEvent(&event);
+	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 = 10;
-    hover_event.motion.y = 10;
+	SDL_zero(hover_event);
+	hover_event.type = SDL_MOUSEMOTION;
+	hover_event.motion.x = 10;
+	hover_event.motion.y = 10;
 	hover_event.motion.xrel = 10;
 	hover_event.motion.yrel = 10;
-    SDL_PushEvent(&hover_event);
+	SDL_PushEvent(&hover_event);
 	input_system.update();
 	event_manager.dispatch_events();
 	EXPECT_TRUE(button.hover);
diff --git a/src/test/loopTimerTest.cpp b/src/test/loopTimerTest.cpp
index a3b1646..327e577 100644
--- a/src/test/loopTimerTest.cpp
+++ b/src/test/loopTimerTest.cpp
@@ -1,7 +1,7 @@
 #define private public
 #define protected public
-#include "api/LoopManager.h"
 #include "api/LoopTimer.h"
+#include "api/LoopManager.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -11,22 +11,19 @@ using namespace crepe;
 
 class LoopTimerTest : public ::testing::Test {
 public:
-LoopTimer loop_timer = LoopTimer::get_instance();
+	LoopTimer loop_timer = LoopTimer::get_instance();
+
 protected:
-	void SetUp() override {
-		loop_timer.start();
-	}
+	void SetUp() override { loop_timer.start(); }
 
-	void TearDown() override {
-		
-	}
+	void TearDown() override {}
 };
 TEST_F(LoopTimerTest, TestDeltaTime) {
-    auto start_time = std::chrono::steady_clock::now();
-    
-    loop_timer.update();  
-    double delta_time = loop_timer.get_delta_time();
+	auto start_time = std::chrono::steady_clock::now();
+
+	loop_timer.update();
+	double delta_time = loop_timer.get_delta_time();
 
-    auto elapsed_time = std::chrono::steady_clock::now() - start_time;
-    EXPECT_LE(delta_time, std::chrono::duration<double>(elapsed_time).count());
+	auto elapsed_time = std::chrono::steady_clock::now() - start_time;
+	EXPECT_LE(delta_time, std::chrono::duration<double>(elapsed_time).count());
 }
-- 
cgit v1.2.3


From 3d8251cd6b65a1e80002518ea48b1a74d91f6ab3 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Mon, 25 Nov 2024 12:07:37 +0100
Subject: removed gameLoop example

---
 src/example/CMakeLists.txt |  1 -
 src/example/gameloop.cpp   | 38 --------------------------------------
 2 files changed, 39 deletions(-)
 delete mode 100644 src/example/gameloop.cpp

(limited to 'src/example')

diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 560e2bc..85ec466 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -19,5 +19,4 @@ endfunction()
 add_example(asset_manager)
 add_example(savemgr)
 add_example(rendering_particle)
-add_example(gameloop)
 
diff --git a/src/example/gameloop.cpp b/src/example/gameloop.cpp
deleted file mode 100644
index b8ee9d8..0000000
--- a/src/example/gameloop.cpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "crepe/api/LoopManager.h"
-#include <crepe/api/EventManager.h>
-#include <crepe/api/GameObject.h>
-#include <crepe/api/IKeyListener.h>
-#include <crepe/api/IMouseListener.h>
-#include <iostream>
-using namespace crepe;
-class TestKeyListener : public IKeyListener {
-public:
-	bool on_key_pressed(const KeyPressEvent & event) override {
-		std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
-				  << std::endl;
-		if (event.key == Keycode::ESCAPE) {
-		}
-		return false;
-	}
-	bool on_key_released(const KeyReleaseEvent & event) override {
-		std::cout << "TestKeyListener: Key Released - Code: " << static_cast<int>(event.key)
-				  << std::endl;
-		return false;
-	}
-};
-bool on_key_pressed(const KeyPressEvent & event) {
-	std::cout << "TestKeyListener: Key Pressed - Code: " << static_cast<int>(event.key)
-			  << std::endl;
-	if (event.key == Keycode::ESCAPE) {
-		return true;
-	}
-	return false;
-}
-int main() {
-	LoopManager gameloop;
-	TestKeyListener key_listener;
-	EventManager::get_instance().subscribe<KeyPressEvent>(on_key_pressed);
-	gameloop.start();
-
-	return 1;
-}
-- 
cgit v1.2.3


From 7ae597ac9268e031927f94dd89c20ab6c034f5de Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 29 Nov 2024 21:20:48 +0100
Subject: working floating point black bars

---
 src/crepe/api/Config.h             |  2 +-
 src/crepe/api/Sprite.cpp           |  2 +-
 src/crepe/api/Sprite.h             |  4 +--
 src/crepe/facade/SDLContext.cpp    | 71 ++++++++++++++++++++++++--------------
 src/example/rendering_particle.cpp |  7 ++--
 5 files changed, 55 insertions(+), 31 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Config.h b/src/crepe/api/Config.h
index 225e9b9..200a3b0 100644
--- a/src/crepe/api/Config.h
+++ b/src/crepe/api/Config.h
@@ -67,7 +67,7 @@ public:
 	//! default window settings
 	struct {
 		//TODO make this constexpr because this will never change
-		ivec2 default_size = {1080, 720};
+		ivec2 default_size = {1280, 720};
 		std::string window_title = "Jetpack joyride clone";
 
 	} window_settings;
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 8647794..1d57b53 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -11,7 +11,7 @@ using namespace std;
 using namespace crepe;
 
 Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, int height)
+			   const FlipSettings & flip, int sort_layer, int order_layer, float height)
 	: Component(id),
 	  color(color),
 	  flip(flip),
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index a0e90a0..5a7a1d9 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -41,7 +41,7 @@ public:
 	 * \param height the height of the image in game units
 	 */
 	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, int height);
+		   const FlipSettings & flip, int sort_layer, int order_layer, float height);
 
 	/**
 	 * \brief Destroys the Sprite instance.
@@ -63,7 +63,7 @@ public:
 	const int order_in_layer;
 
 	//! height in world units
-	const int height;
+	const float height;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 9f60285..56ba61a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -8,6 +8,7 @@
 #include <cmath>
 #include <cstddef>
 #include <functional>
+#include <iostream>
 #include <memory>
 #include <stdexcept>
 
@@ -94,7 +95,7 @@ void SDLContext::handle_events(bool & running) {
 }
 
 void SDLContext::clear_screen() {
-	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
+	SDL_SetRenderDrawColor(this->game_renderer.get(), 255, 255, 255, 255);
 	SDL_RenderClear(this->game_renderer.get());
 }
 void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
@@ -110,17 +111,19 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 								  const vec2 & cam_pos, const double & img_scale) const {
 
-	int width = sprite.height * sprite.aspect_ratio;
-	int height = sprite.height;
+	double width = sprite.height * sprite.aspect_ratio;
+	double height = sprite.height;
 
 	width *= img_scale * cam.zoom;
 	height *= img_scale * cam.zoom;
 
 	return SDL_Rect{
-		.x = static_cast<int>((pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
-		.y = static_cast<int>((pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
-		.w = width,
-		.h = height,
+		.x
+		= static_cast<int>(round(pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
+		.y
+		= static_cast<int>(round(pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
+		.w = static_cast<int>(width),
+		.h = static_cast<int>(height),
 	};
 }
 
@@ -134,6 +137,8 @@ void SDLContext::draw(const RenderContext & ctx) {
 	SDL_Rect dstrect
 		= this->get_dst_rect(ctx.sprite, ctx.pos, ctx.cam, ctx.cam_pos, ctx.scale);
 
+	cout << dstrect.x << " " << dstrect.y << " " << dstrect.w << " " << dstrect.h << endl;
+
 	SDL_RenderCopyEx(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
 					 &srcrect, &dstrect, ctx.angle, NULL, render_flip);
 }
@@ -147,30 +152,44 @@ void SDLContext::set_camera(const Camera & cam) {
 		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
-	double screen_aspect = cam.screen.x / cam.screen.y;
+	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = cam.viewport_size.x / cam.viewport_size.y;
 
-	SDL_Rect view;
+	cout << screen_aspect << " " << viewport_aspect << endl;
+	SDL_FRect black_bars[2];
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
-		// letterboxing
-		view.h = cam.screen.y / cam.zoom;
-		view.w = cam.screen.y * viewport_aspect;
-		view.x = (cam.screen.x - view.w) / 2;
-		view.y = 0;
-	} else {
 		// pillarboxing
-		view.h = cam.screen.x / viewport_aspect;
-		view.w = cam.screen.x / cam.zoom;
-		view.x = 0;
-		view.y = (cam.screen.y - view.h) / 2;
+		cout << "pillarboxing" << endl;
+		float render_scale = cam.screen.y / cam.viewport_size.y;
+		float adj_width = cam.viewport_size.x * render_scale;
+		float bar_width = (cam.screen.x - adj_width) / 2;
+		black_bars[0] = {0, 0, bar_width, (float)cam.screen.y};
+		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float)cam.screen.y};
+		cout << render_scale << " " << adj_width << " " << bar_width << " " << cam.screen.y
+			 << " " << cam.viewport_size.y << endl;
+	} else {
+		// letterboxing
+		cout << "letterboxing" << endl;
+		float render_scale = cam.screen.y / cam.viewport_size.y;
+		float adj_width = cam.viewport_size.x * render_scale;
+		float bar_height = (cam.screen.x - adj_width) / 2;
+		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		black_bars[1] = {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
+		cout << render_scale << " " << adj_width << " " << bar_height << " " << cam.screen.y
+			 << " " << cam.viewport_size.y << endl;
 	}
-	// set drawing area
-	SDL_RenderSetViewport(this->game_renderer.get(), &view);
 
-	SDL_RenderSetLogicalSize(this->game_renderer.get(), static_cast<int>(cam.viewport_size.x),
-							 static_cast<int>(cam.viewport_size.y));
+	for (int i = 0; i < 2; ++i) {
+		cout << black_bars[i].x << " " << black_bars[i].y << " " << black_bars[i].w << " "
+			 << black_bars[i].h << endl;
+	}
+
+	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[0]);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[1]);
 
+	/*
 	// set bg color
 	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
 						   cam.bg_color.b, cam.bg_color.a);
@@ -178,11 +197,13 @@ void SDLContext::set_camera(const Camera & cam) {
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = static_cast<int>(cam.viewport_size.x),
-		.h = static_cast<int>(cam.viewport_size.y),
+		.w = (int)cam.viewport_size.x,
+		.h = (int)cam.viewport_size.y,
 	};
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
+
+	*/
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 3a12144..5896c81 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -31,12 +31,15 @@ int main(int argc, char * argv[]) {
 	Color color(255, 255, 255, 255);
 
 	auto img = Texture("asset/texture/test_ap43.png");
+
+	/*
 	Sprite & test_sprite = game_object.add_component<Sprite>(
 		img, color, Sprite::FlipSettings{true, true}, 1, 1, 500);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
 
+	*/
 	/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
@@ -59,8 +62,8 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1080, 720},
-												   vec2{2000, 2000}, 1.0f);
+	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1600, 900},
+												   vec2{800,800}, 1.0f);
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 4159c7187e17d6318e33d8a0c014ba042ae8261b Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 15:22:17 +0100
Subject: first version of new viewport floats without the use of sdl functions

---
 src/crepe/api/Sprite.h             |  2 +-
 src/crepe/facade/SDLContext.cpp    | 60 +++++++++++++++++++++++---------------
 src/crepe/facade/SDLContext.h      |  2 +-
 src/example/rendering_particle.cpp |  9 +++---
 4 files changed, 42 insertions(+), 31 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 5a7a1d9..7d9c14b 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -71,7 +71,7 @@ public:
 	 * cannot be const because if Animator component is addded then ratio becomes scuffed and
 	 * does it need to be calculated again in the Animator
 	 */
-	double aspect_ratio;
+	float aspect_ratio;
 
 private:
 	//! Reads the mask of sprite
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 56ba61a..0ba1db4 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -108,22 +108,30 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 		.h = sprite.mask.h,
 	};
 }
-SDL_Rect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
+
+vec2 bar_size;
+vec2 scale;
+
+SDL_FRect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 								  const vec2 & cam_pos, const double & img_scale) const {
 
-	double width = sprite.height * sprite.aspect_ratio;
-	double height = sprite.height;
 
-	width *= img_scale * cam.zoom;
-	height *= img_scale * cam.zoom;
+	vec2 size = { (sprite.height * sprite.aspect_ratio), sprite.height};
+	
+	size *=  scale * img_scale * cam.zoom ;
 
-	return SDL_Rect{
-		.x
-		= static_cast<int>(round(pos.x - cam_pos.x + (cam.viewport_size.x / 2) - width / 2)),
-		.y
-		= static_cast<int>(round(pos.y - cam_pos.y + (cam.viewport_size.y / 2) - height / 2)),
-		.w = static_cast<int>(width),
-		.h = static_cast<int>(height),
+	vec2 screen_pos = (pos - cam_pos + cam.viewport_size / 2) * scale - size / 2 + bar_size;
+
+	cout << size.x << " " << size.y << endl;
+	cout << pos.x << " " << pos.y << endl;
+	cout << scale.x << " " << scale.y << endl;
+	cout << screen_pos.x << " " << screen_pos.y << endl;
+
+	return SDL_FRect{
+		.x = screen_pos.x,
+		.y = screen_pos.y,
+		.w = size.x,
+		.h = size.y,
 	};
 }
 
@@ -134,12 +142,12 @@ void SDLContext::draw(const RenderContext & ctx) {
 							  | (SDL_FLIP_VERTICAL * ctx.sprite.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
-	SDL_Rect dstrect
+	SDL_FRect dstrect
 		= this->get_dst_rect(ctx.sprite, ctx.pos, ctx.cam, ctx.cam_pos, ctx.scale);
 
 	cout << dstrect.x << " " << dstrect.y << " " << dstrect.w << " " << dstrect.h << endl;
 
-	SDL_RenderCopyEx(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
+	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
 					 &srcrect, &dstrect, ctx.angle, NULL, render_flip);
 }
 
@@ -155,7 +163,7 @@ void SDLContext::set_camera(const Camera & cam) {
 	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = cam.viewport_size.x / cam.viewport_size.y;
 
-	cout << screen_aspect << " " << viewport_aspect << endl;
+
 	SDL_FRect black_bars[2];
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
@@ -164,22 +172,26 @@ void SDLContext::set_camera(const Camera & cam) {
 		float render_scale = cam.screen.y / cam.viewport_size.y;
 		float adj_width = cam.viewport_size.x * render_scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
-		black_bars[0] = {0, 0, bar_width, (float)cam.screen.y};
-		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float)cam.screen.y};
-		cout << render_scale << " " << adj_width << " " << bar_width << " " << cam.screen.y
-			 << " " << cam.viewport_size.y << endl;
+		black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
+		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+
+		bar_size = {bar_width,0};
+		scale.x = scale.y = cam.screen.y / cam.viewport_size.y;
 	} else {
 		// letterboxing
 		cout << "letterboxing" << endl;
-		float render_scale = cam.screen.y / cam.viewport_size.y;
-		float adj_width = cam.viewport_size.x * render_scale;
-		float bar_height = (cam.screen.x - adj_width) / 2;
+		float render_scale = cam.screen.x / cam.viewport_size.x;
+		float adj_height = cam.viewport_size.y * render_scale;
+		float bar_height = (cam.screen.y - adj_height) / 2;
 		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
 		black_bars[1] = {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
-		cout << render_scale << " " << adj_width << " " << bar_height << " " << cam.screen.y
-			 << " " << cam.viewport_size.y << endl;
+
+		bar_size = {0,bar_height};
+		scale.x = scale.y = render_scale;
 	}
 
+	cout << "BARS" << endl;
+
 	for (int i = 0; i < 2; ++i) {
 		cout << black_bars[i].x << " " << black_bars[i].y << " " << black_bars[i].w << " "
 			 << black_bars[i].h << endl;
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 6030a6e..ead0c72 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -158,7 +158,7 @@ private:
 	 * \param img_scale the image multiplier for increasing img size 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_Rect get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
+	SDL_FRect get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
 						  const vec2 & cam_pos, const double & img_scale) const;
 
 private:
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 5896c81..f5b9ab3 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -32,14 +32,12 @@ int main(int argc, char * argv[]) {
 
 	auto img = Texture("asset/texture/test_ap43.png");
 
-	/*
 	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 500);
+		img, color, Sprite::FlipSettings{true, true}, 1, 1, 3000);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
 
-	*/
 	/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
@@ -62,8 +60,9 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1600, 900},
-												   vec2{800,800}, 1.0f);
+	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1280, 720},
+												   vec2{8000,6000}, 1.0f);
+	cam.offset.x = 4000;
 
 	/*
 	game_object
-- 
cgit v1.2.3


From ad4f8acfb252b8be3a3fbb74ed97b32e498a26a4 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 15:43:36 +0100
Subject: zoomed viewport

---
 src/crepe/facade/SDLContext.cpp    | 14 +++++++-------
 src/example/rendering_particle.cpp |  6 +++---
 2 files changed, 10 insertions(+), 10 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 0ba1db4..6d79c73 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -118,9 +118,9 @@ SDL_FRect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, cons
 
 	vec2 size = { (sprite.height * sprite.aspect_ratio), sprite.height};
 	
-	size *=  scale * img_scale * cam.zoom ;
+	size *=  scale * img_scale;
 
-	vec2 screen_pos = (pos - cam_pos + cam.viewport_size / 2) * scale - size / 2 + bar_size;
+	vec2 screen_pos = (pos - cam_pos + (cam.viewport_size / cam.zoom ) / 2) * scale - size / 2 + bar_size;
 
 	cout << size.x << " " << size.y << endl;
 	cout << pos.x << " " << pos.y << endl;
@@ -161,7 +161,7 @@ void SDLContext::set_camera(const Camera & cam) {
 	}
 
 	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
-	double viewport_aspect = cam.viewport_size.x / cam.viewport_size.y;
+	double viewport_aspect = (cam.viewport_size.x / cam.zoom ) / (cam.viewport_size.y / cam.zoom);
 
 
 	SDL_FRect black_bars[2];
@@ -169,18 +169,18 @@ void SDLContext::set_camera(const Camera & cam) {
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
 		cout << "pillarboxing" << endl;
-		float render_scale = cam.screen.y / cam.viewport_size.y;
-		float adj_width = cam.viewport_size.x * render_scale;
+		float render_scale = cam.screen.y / (cam.viewport_size.y / cam.zoom);
+		float adj_width = (cam.viewport_size.x / cam.zoom )* render_scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
 		black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
 		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
 		bar_size = {bar_width,0};
-		scale.x = scale.y = cam.screen.y / cam.viewport_size.y;
+		scale.x = scale.y = render_scale;
 	} else {
 		// letterboxing
 		cout << "letterboxing" << endl;
-		float render_scale = cam.screen.x / cam.viewport_size.x;
+		float render_scale = cam.screen.x / (cam.viewport_size.x * cam.zoom);
 		float adj_height = cam.viewport_size.y * render_scale;
 		float bar_height = (cam.screen.y - adj_height) / 2;
 		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index f5b9ab3..b4bfeb2 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -33,7 +33,7 @@ int main(int argc, char * argv[]) {
 	auto img = Texture("asset/texture/test_ap43.png");
 
 	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 3000);
+		img, color, Sprite::FlipSettings{true, true}, 1, 1, 300);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
@@ -61,8 +61,8 @@ int main(int argc, char * argv[]) {
 	*/
 
 	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1280, 720},
-												   vec2{8000,6000}, 1.0f);
-	cam.offset.x = 4000;
+												   vec2{400,300}, 0.5f);
+	cam.offset.x = 0;
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 1520cb55ad714583c3903f2988b0fdc38ede9c18 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 16:44:47 +0100
Subject: cleaner camera implementation

---
 src/crepe/facade/SDLContext.cpp    | 101 ++++++++++++++++---------------------
 src/crepe/facade/SDLContext.h      |  26 ++++++++--
 src/crepe/system/RenderSystem.cpp  |  10 ++--
 src/crepe/system/RenderSystem.h    |   5 +-
 src/example/rendering_particle.cpp |   8 +--
 5 files changed, 74 insertions(+), 76 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 6d79c73..1f729b2 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -94,11 +94,13 @@ void SDLContext::handle_events(bool & running) {
 	*/
 }
 
-void SDLContext::clear_screen() {
-	SDL_SetRenderDrawColor(this->game_renderer.get(), 255, 255, 255, 255);
-	SDL_RenderClear(this->game_renderer.get());
+void SDLContext::clear_screen() { SDL_RenderClear(this->game_renderer.get()); }
+void SDLContext::present_screen() {
+	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[0]);
+	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[1]);
+	SDL_RenderPresent(this->game_renderer.get());
 }
-void SDLContext::present_screen() { SDL_RenderPresent(this->game_renderer.get()); }
 
 SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 	return SDL_Rect{
@@ -109,23 +111,16 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 	};
 }
 
-vec2 bar_size;
-vec2 scale;
+SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-SDL_FRect SDLContext::get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
-								  const vec2 & cam_pos, const double & img_scale) const {
+	vec2 size = {(ctx.sprite.height * ctx.sprite.aspect_ratio), ctx.sprite.height};
 
+	const CameraValues & cam = ctx.cam;
 
-	vec2 size = { (sprite.height * sprite.aspect_ratio), sprite.height};
-	
-	size *=  scale * img_scale;
+	size *= cam.render_scale * ctx.img_scale;
 
-	vec2 screen_pos = (pos - cam_pos + (cam.viewport_size / cam.zoom ) / 2) * scale - size / 2 + bar_size;
-
-	cout << size.x << " " << size.y << endl;
-	cout << pos.x << " " << pos.y << endl;
-	cout << scale.x << " " << scale.y << endl;
-	cout << screen_pos.x << " " << screen_pos.y << endl;
+	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
+					  - size / 2 + cam.bar_size;
 
 	return SDL_FRect{
 		.x = screen_pos.x,
@@ -142,16 +137,18 @@ void SDLContext::draw(const RenderContext & ctx) {
 							  | (SDL_FLIP_VERTICAL * ctx.sprite.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
-	SDL_FRect dstrect
-		= this->get_dst_rect(ctx.sprite, ctx.pos, ctx.cam, ctx.cam_pos, ctx.scale);
-
-	cout << dstrect.x << " " << dstrect.y << " " << dstrect.w << " " << dstrect.h << endl;
+	SDL_FRect dstrect = this->get_dst_rect(SDLContext::DstRect{
+		.sprite = ctx.sprite,
+		.cam = ctx.cam,
+		.pos = ctx.pos,
+		.img_scale = ctx.scale,
+	});
 
 	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
-					 &srcrect, &dstrect, ctx.angle, NULL, render_flip);
+					  &srcrect, &dstrect, ctx.angle, NULL, render_flip);
 }
 
-void SDLContext::set_camera(const Camera & cam) {
+void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 
 	// resize window
 	int w, h;
@@ -160,62 +157,50 @@ void SDLContext::set_camera(const Camera & cam) {
 		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
-	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
-	double viewport_aspect = (cam.viewport_size.x / cam.zoom ) / (cam.viewport_size.y / cam.zoom);
+	vec2 & zoomed_viewport = ctx.zoomed_viewport;
+	vec2 & bar_size = ctx.bar_size;
+	vec2 & render_scale = ctx.render_scale;
 
+	zoomed_viewport = cam.viewport_size * cam.zoom;
+	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
+	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
-	SDL_FRect black_bars[2];
-	// calculate black bars
+	// calculate black bars 
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		cout << "pillarboxing" << endl;
-		float render_scale = cam.screen.y / (cam.viewport_size.y / cam.zoom);
-		float adj_width = (cam.viewport_size.x / cam.zoom )* render_scale;
+		float scale = cam.screen.y / zoomed_viewport.y;
+		float adj_width = zoomed_viewport.x * scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
-		black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
+		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
-		bar_size = {bar_width,0};
-		scale.x = scale.y = render_scale;
+		bar_size = {bar_width, 0};
+		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		cout << "letterboxing" << endl;
-		float render_scale = cam.screen.x / (cam.viewport_size.x * cam.zoom);
-		float adj_height = cam.viewport_size.y * render_scale;
+		float scale = cam.screen.x / (cam.viewport_size.x * cam.zoom);
+		float adj_height = cam.viewport_size.y * scale;
 		float bar_height = (cam.screen.y - adj_height) / 2;
-		black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
-		black_bars[1] = {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
-
-		bar_size = {0,bar_height};
-		scale.x = scale.y = render_scale;
-	}
+		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		this->black_bars[1]
+			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
 
-	cout << "BARS" << endl;
-
-	for (int i = 0; i < 2; ++i) {
-		cout << black_bars[i].x << " " << black_bars[i].y << " " << black_bars[i].w << " "
-			 << black_bars[i].h << endl;
+		bar_size = {0, bar_height};
+		render_scale.x = render_scale.y = scale;
 	}
 
-	SDL_SetRenderDrawColor(this->game_renderer.get(), 0, 0, 0, 255);
-	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[0]);
-	SDL_RenderFillRectF(this->game_renderer.get(), &black_bars[1]);
-
-	/*
-	// set bg color
 	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
 						   cam.bg_color.b, cam.bg_color.a);
 
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = (int)cam.viewport_size.x,
-		.h = (int)cam.viewport_size.y,
+		.w = cam.screen.x,
+		.h = cam.screen.y,
 	};
+
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
-
-	*/
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index ead0c72..285eee2 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -29,15 +29,23 @@ typedef SDL_Keycode CREPE_KEYCODES;
  */
 class SDLContext {
 public:
+	//! data that the camera component cannot hold
+	struct CameraValues {
+		vec2 zoomed_viewport;
+		vec2 render_scale;
+		vec2 bar_size;
+		vec2 cam_pos;
+	};
+
 	struct RenderContext {
 		const Sprite & sprite;
-		const Camera & cam;
-		const vec2 & cam_pos;
+		const CameraValues & cam;
 		const vec2 & pos;
 		const double & angle;
 		const double & scale;
 	};
 
+
 public:
 	/**
 	 * \brief Gets the singleton instance of SDLContext.
@@ -137,9 +145,15 @@ private:
 	 * \brief sets the background of the camera (will be adjusted in future PR)
 	 * \param camera Reference to the Camera object.
 	 */
-	void set_camera(const Camera & camera);
+	void set_camera(const Camera & camera, CameraValues & ctx);
 
 private:
+	struct DstRect {
+		const Sprite & sprite;
+		const CameraValues & cam;
+		const vec2 & pos;
+		const double & img_scale;
+	};
 	/**
 	 * \brief calculates the sqaure size of the image
 	 *
@@ -158,8 +172,7 @@ private:
 	 * \param img_scale the image multiplier for increasing img size 
 	 * \return sdl rectangle to draw a dst image to draw on the screen
 	 */
-	SDL_FRect get_dst_rect(const Sprite & sprite, const vec2 & pos, const Camera & cam,
-						  const vec2 & cam_pos, const double & img_scale) const;
+	SDL_FRect get_dst_rect(const DstRect & ctx) const;
 
 private:
 	//! sdl Window
@@ -167,6 +180,9 @@ private:
 
 	//! renderer for the crepe engine
 	std::unique_ptr<SDL_Renderer, std::function<void(SDL_Renderer *)>> game_renderer;
+
+	//! black bars rectangle to draw
+	SDL_FRect black_bars[2];
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index c196bb1..944ac86 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -32,8 +32,8 @@ const Camera & RenderSystem::update_camera() {
 		if (!cam.active) continue;
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
-		this->context.set_camera(cam);
-		this->cam_pos = transform.position + cam.offset;
+		this->context.set_camera(cam, this->cam_ctx);
+		this->cam_ctx.cam_pos = transform.position + cam.offset;
 		return cam;
 	}
 	throw std::runtime_error("No active cameras in current scene");
@@ -79,8 +79,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
 
 			this->context.draw(SDLContext::RenderContext{
 				.sprite = sprite,
-				.cam = cam,
-				.cam_pos = this->cam_pos,
+				.cam = this->cam_ctx,
 				.pos = p.position,
 				.angle = p.angle,
 				.scale = scale,
@@ -93,8 +92,7 @@ void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
 								 const Transform & tm) {
 	this->context.draw(SDLContext::RenderContext{
 		.sprite = sprite,
-		.cam = cam,
-		.cam_pos = this->cam_pos,
+		.cam = this->cam_ctx,
 		.pos = tm.position,
 		.angle = tm.rotation,
 		.scale = tm.scale,
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index e70831e..9ff015e 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -76,9 +76,8 @@ private:
 
 private:
 	SDLContext & context = SDLContext::get_instance();
-
-	//! camera postion in the current scene
-	vec2 cam_pos;
+	
+	SDLContext::CameraValues cam_ctx;
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index b4bfeb2..9dcaa49 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -33,7 +33,7 @@ int main(int argc, char * argv[]) {
 	auto img = Texture("asset/texture/test_ap43.png");
 
 	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 300);
+		img, color, Sprite::FlipSettings{true, true}, 1, 1, 1.95);
 
 	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
 	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
@@ -60,9 +60,9 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{1280, 720},
-												   vec2{400,300}, 0.5f);
-	cam.offset.x = 0;
+	auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
+												   vec2{2.59,1.95}, 2.0);
+	cam.offset.x = 1;
 
 	/*
 	game_object
-- 
cgit v1.2.3


From 6ae0b9038e432869b506cbdfe2779e97d3732d87 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Sat, 30 Nov 2024 21:02:27 +0100
Subject: improved animator

---
 src/crepe/api/Animator.cpp          |  1 -
 src/crepe/api/Animator.h            | 32 +++++++++++++------
 src/crepe/api/LoopManager.cpp       |  6 +++-
 src/crepe/api/Sprite.cpp            |  5 +--
 src/crepe/api/Sprite.h              |  8 ++---
 src/crepe/facade/SDLContext.cpp     |  6 +++-
 src/crepe/system/AnimatorSystem.cpp | 26 ++++++++++-----
 src/crepe/system/AnimatorSystem.h   |  7 +++--
 src/example/rendering_particle.cpp  | 63 +++++++++++++++++++------------------
 9 files changed, 93 insertions(+), 61 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 45f67f6..7fe49ee 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -18,7 +18,6 @@ Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_a
 	this->spritesheet.mask.w /= row;
 	this->spritesheet.mask.x = 0;
 	this->spritesheet.mask.y = col_animator * this->spritesheet.mask.h;
-	this->active = false;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
 	this->spritesheet.aspect_ratio
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 6c506aa..ede450a 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -17,11 +17,6 @@ class SDLContext;
  */
 class Animator : public Component {
 
-public:
-	//TODO: need to implement this
-	void loop();
-	void stop();
-
 public:
 	/**
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
@@ -57,15 +52,32 @@ private:
 	//! The current row being animated.
 	int curr_row = 0;
 
-	//TODO: Is this necessary?
-	//int fps;
+	//! should the animation loop
+	bool looping = false;
+
+	//! starting frame for cycling
+	int cycle_start = 0;
+
+	//! end frame for cycling (-1 --> use last frame)
+	int cycle_end = -1;
+
+	//! frames per second for animation
+	int fps = 1;
+
+	int offset_x = 0;
+
+public:
+	void loop() { this->looping = true; }
+	void play() {this->active = true;}
+	void pause() {this->active = false;}
+	void stop() {this->active = false; this->curr_col = 0; this->curr_row = 0;}
+	void set_fps(int fps) {this->fps = fps;}
+	void set_cycle_range(int start, int end) {this->cycle_start = start, this->cycle_end = end;}
+	void set_anim(int col) {this->curr_row = 0; this->curr_col = col; }
 
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
 	friend class AnimatorSystem;
-
-	//! SDLContext reads the Animator member var's
-	friend class SDLContext;
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 7edf4d1..88ca704 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -58,6 +58,7 @@ void LoopManager::setup() {
 	this->game_running = true;
 	LoopTimer::get_instance().start();
 	LoopTimer::get_instance().set_fps(200);
+	this->scene_manager.load_next_scene();
 }
 
 void LoopManager::render() {
@@ -66,4 +67,7 @@ void LoopManager::render() {
 	}
 }
 
-void LoopManager::update() { LoopTimer & timer = LoopTimer::get_instance(); }
+void LoopManager::update() { 
+	LoopTimer & timer = LoopTimer::get_instance(); 
+	this->get_system<AnimatorSystem>().update();
+}
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 1d57b53..29e415f 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -6,19 +6,20 @@
 #include "Component.h"
 #include "Sprite.h"
 #include "Texture.h"
+#include "types.h"
 
 using namespace std;
 using namespace crepe;
 
 Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, float height)
+			   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size)
 	: Component(id),
 	  color(color),
 	  flip(flip),
 	  sprite_image(std::move(image)),
 	  sorting_in_layer(sort_layer),
 	  order_in_layer(order_layer),
-	  height(height) {
+	  size(size) {
 
 	dbg_trace();
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 7d9c14b..f04f70c 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,11 +1,10 @@
 #pragma once
 
-#include <cstdint>
-
 #include "../Component.h"
 
 #include "Color.h"
 #include "Texture.h"
+#include "types.h"
 
 namespace crepe {
 
@@ -41,7 +40,7 @@ public:
 	 * \param height the height of the image in game units
 	 */
 	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, float height);
+		   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size);
 
 	/**
 	 * \brief Destroys the Sprite instance.
@@ -62,8 +61,7 @@ public:
 	//! Order within the sorting layer
 	const int order_in_layer;
 
-	//! height in world units
-	const float height;
+	vec2 size;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 1f729b2..f0a21d5 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -113,7 +113,11 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-	vec2 size = {(ctx.sprite.height * ctx.sprite.aspect_ratio), ctx.sprite.height};
+
+	vec2 size = {
+		ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio : ctx.sprite.size.x,
+		ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio : ctx.sprite.size.y
+	};
 
 	const CameraValues & cam = ctx.cam;
 
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 4c40940..6a84150 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -1,7 +1,6 @@
-#include <cstdint>
+
 
 #include "api/Animator.h"
-#include "facade/SDLContext.h"
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
@@ -13,12 +12,25 @@ void AnimatorSystem::update() {
 
 	RefVector<Animator> animations = mgr.get_components_by_type<Animator>();
 
-	uint64_t tick = SDLContext::get_instance().get_ticks();
+	double elapsed_time = this->timer.get_current_time();
+
 	for (Animator & a : animations) {
 		if (!a.active) continue;
-		// (10 frames per second)
-		a.curr_row = (tick / 100) % a.row;
-		a.spritesheet.mask.x = (a.curr_row * a.spritesheet.mask.w) + a.curr_col;
-		a.spritesheet.mask = a.spritesheet.mask;
+
+		double frame_duration = 1.0f / a.fps;
+
+		int cycle_end = (a.cycle_end == -1) ? a.row : cycle_end;
+		int total_frames = cycle_end - a.cycle_start;
+
+
+		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
+
+		a.curr_row = a.cycle_start + curr_frame;
+		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0, a.spritesheet.mask.w);
+		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
+
+		if (!a.looping && curr_frame == total_frames) {
+			a.active = false;
+		}
 	}
 }
diff --git a/src/crepe/system/AnimatorSystem.h b/src/crepe/system/AnimatorSystem.h
index f8179a9..e8a5158 100644
--- a/src/crepe/system/AnimatorSystem.h
+++ b/src/crepe/system/AnimatorSystem.h
@@ -1,9 +1,7 @@
 #pragma once
 
 #include "System.h"
-
-//TODO:
-// control if flip works with animation system
+#include "api/LoopTimer.h"
 
 namespace crepe {
 
@@ -26,6 +24,9 @@ public:
 	 * looping).
 	 */
 	void update() override;
+
+private:
+	LoopTimer & timer = LoopTimer::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 9dcaa49..026c9ce 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -1,5 +1,7 @@
 #include "api/Animator.h"
 #include "api/Camera.h"
+#include "api/LoopManager.h"
+#include "api/LoopTimer.h"
 #include "system/AnimatorSystem.h"
 #include "system/ParticleSystem.h"
 #include <SDL2/SDL_timer.h>
@@ -16,29 +18,10 @@
 #include <crepe/system/RenderSystem.h>
 #include <crepe/types.h>
 
-#include <chrono>
-
 using namespace crepe;
 using namespace std;
 
-int main(int argc, char * argv[]) {
-	ComponentManager mgr;
-	GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
-	RenderSystem sys{mgr};
-	ParticleSystem psys{mgr};
-	AnimatorSystem asys{mgr};
-
-	Color color(255, 255, 255, 255);
-
-	auto img = Texture("asset/texture/test_ap43.png");
-
-	Sprite & test_sprite = game_object.add_component<Sprite>(
-		img, color, Sprite::FlipSettings{true, true}, 1, 1, 1.95);
-
-	//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
-	game_object.add_component<Animator>(test_sprite, 1, 1, 0).active = true;
-
-	/*
+/*
 	auto & test = game_object.add_component<ParticleEmitter>(ParticleEmitter::Data{
 		.position = {0, 0},
 		.max_particles = 10,
@@ -60,9 +43,35 @@ int main(int argc, char * argv[]) {
 	});
 	*/
 
-	auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
-												   vec2{2.59,1.95}, 2.0);
-	cam.offset.x = 1;
+class TestScene : public Scene {
+public:
+	using Scene::Scene;
+
+	void load_scene() {
+		ComponentManager & mgr = this->component_manager;
+		GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
+
+		Color color(255, 255, 255, 255);
+
+		auto img = Texture("asset/spritesheet/spritesheet_test.png");
+
+		Sprite & test_sprite = game_object.add_component<Sprite>(
+			img, color, Sprite::FlipSettings{true, true}, 1, 1, vec2{1, 1});
+
+		//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+		game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+
+		auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
+													   vec2{2.59, 1.95}, 2.0);
+	}
+
+	string get_name() const { return "TestScene"; };
+};
+
+int main(int argc, char * argv[]) {
+	LoopManager engine;
+	engine.add_scene<TestScene>();
+	engine.start();
 
 	/*
 	game_object
@@ -73,13 +82,5 @@ int main(int argc, char * argv[]) {
 		= 6;
 	*/
 
-	auto start = std::chrono::steady_clock::now();
-	while (std::chrono::steady_clock::now() - start < std::chrono::seconds(5)) {
-		psys.update();
-		asys.update();
-		sys.update();
-		SDL_Delay(10);
-	}
-
 	return 0;
 }
-- 
cgit v1.2.3


From 135af8b0e0eaf8a5a5b7e1a42bfb20bb14ec97e5 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 18:51:47 +0100
Subject: tmp commit

---
 src/crepe/api/Animator.h            |  2 +-
 src/crepe/api/Sprite.h              |  4 ++--
 src/crepe/system/AnimatorSystem.cpp |  9 +++++----
 src/example/rendering_particle.cpp  | 11 +++++------
 4 files changed, 13 insertions(+), 13 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 188f193..511d6ef 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -89,7 +89,7 @@ public:
 
 	~Animator(); // dbg_trace
 
-private:
+public:
 	//! A reference to the Sprite sheet containing.
 	Sprite & spritesheet;
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 96b57e1..354f663 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -74,10 +74,10 @@ public:
 	vec2 size;
 
 	//! independent sprite angle. rotating clockwise direction in degrees
-	double angle_offset;
+	double angle_offset = 0;
 
 	//! independent sprite scale multiplier
-	double scale;
+	double scale = 1;
 
 	/**
 	 * \aspect_ratio ratio of the img so that scaling will not become weird
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index ee00728..1650b3d 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -4,6 +4,7 @@
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
+#include <iostream>
 
 using namespace crepe;
 
@@ -25,11 +26,11 @@ void AnimatorSystem::update() {
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
 		a.curr_row = a.cycle_start + curr_frame;
-		a.spritesheet.mask.x = std::clamp((a.curr_row * a.spritesheet.mask.w - a.offset_x), 0,
-										  a.spritesheet.mask.w);
+		a.spritesheet.mask.x = a.curr_row * a.spritesheet.mask.w;
 		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
-
-		if (!a.looping && curr_frame == total_frames) {
+	
+		std::cout << curr_frame << " " << total_frames << std::endl;
+		if (!a.looping && curr_frame == 0) {
 			a.active = false;
 		}
 	}
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 026c9ce..5a50d27 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -53,16 +53,15 @@ public:
 
 		Color color(255, 255, 255, 255);
 
-		auto img = Texture("asset/spritesheet/spritesheet_test.png");
+		auto img = Texture("asset/spritesheet/pokemon_spritesheet.png");
 
 		Sprite & test_sprite = game_object.add_component<Sprite>(
-			img, color, Sprite::FlipSettings{true, true}, 1, 1, vec2{1, 1});
+			img, color, Sprite::FlipSettings{false, false}, 1, 1, vec2{100, 100});
 
-		//game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
-		game_object.add_component<Animator>(test_sprite, 4, 1, 0).active = true;
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, 0);
 
-		auto & cam = game_object.add_component<Camera>(Color::RED, ivec2{1280, 720},
-													   vec2{2.59, 1.95}, 2.0);
+		auto & cam = game_object.add_component<Camera>(Color::, ivec2{720, 1280},
+													   vec2{400, 400}, 1.0);
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From a84ca09e97d466643f022acfffcf4c6a77f42052 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 20:02:14 +0100
Subject: making struct constructors

---
 src/crepe/api/Animator.cpp          | 34 ++++++-------
 src/crepe/api/Animator.h            | 66 +++++++++++++------------
 src/crepe/api/Camera.cpp            | 11 +----
 src/crepe/api/Camera.h              | 37 +++++++-------
 src/crepe/api/Sprite.cpp            | 17 +++----
 src/crepe/api/Sprite.h              | 98 +++++++++++++++++--------------------
 src/crepe/facade/SDLContext.cpp     | 25 +++++-----
 src/crepe/system/AnimatorSystem.cpp | 17 ++++---
 src/crepe/system/RenderSystem.cpp   |  5 +-
 src/example/rendering_particle.cpp  | 19 +++++--
 10 files changed, 166 insertions(+), 163 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 0b7e86d..ce824e6 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,37 +7,37 @@
 
 using namespace crepe;
 
-Animator::Animator(game_object_id_t id, Sprite & ss, int row, int col, int col_animator)
+Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	: Component(id),
-	  spritesheet(ss),
-	  row(row),
-	  col(col) {
+	data(ctx)
+{
 	dbg_trace();
 
-	this->spritesheet.mask.h /= col;
-	this->spritesheet.mask.w /= row;
-	this->spritesheet.mask.x = 0;
-	this->spritesheet.mask.y = col_animator * this->spritesheet.mask.h;
+	this->data.spritesheet.mask.h /= this->data.col;
+	this->data.spritesheet.mask.w /= this->data.row;
+	this->data.spritesheet.mask.x = 0;
+	this->data.spritesheet.mask.y = this->data.col * this->data.spritesheet.mask.h;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
-	this->spritesheet.aspect_ratio
-		= static_cast<double>(this->spritesheet.mask.w) / this->spritesheet.mask.h;
+	Sprite & ss = this->data.spritesheet;
+	ss.data.aspect_ratio
+		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
 }
 Animator::~Animator() { dbg_trace(); }
 
-void Animator::loop() { this->looping = true; }
+void Animator::loop() { this->data.looping = true; }
 void Animator::play() { this->active = true; }
 void Animator::pause() { this->active = false; }
 void Animator::stop() {
 	this->active = false;
-	this->curr_col = 0;
-	this->curr_row = 0;
+	this->data.curr_col = 0;
+	this->data.curr_row = 0;
 }
-void Animator::set_fps(int fps) { this->fps = fps; }
+void Animator::set_fps(int fps) { this->data.fps = fps; }
 void Animator::set_cycle_range(int start, int end) {
-	this->cycle_start = start, this->cycle_end = end;
+	this->data.cycle_start = start, this->data.cycle_end = end;
 }
 void Animator::set_anim(int col) {
-	this->curr_row = 0;
-	this->curr_col = col;
+	this->data.curr_row = 0;
+	this->data.curr_col = col;
 }
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 511d6ef..194a9cf 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -16,6 +16,39 @@ class SDLContext;
  * sheet. It can be used to play animations, loop them, or stop them.
  */
 class Animator : public Component {
+public:
+	struct Data {
+		//! A reference to the Sprite sheet containing.
+		Sprite & spritesheet;
+
+		//! The maximum number of columns in the sprite sheet.
+		const int col;
+
+		//! The maximum number of rows in the sprite sheet.
+		const int row;
+
+		//! frames per second for animation
+		int fps;
+
+		//! The current col being animated.
+		int curr_col;
+
+		//! The current row being animated.
+		int curr_row = 0;
+
+		//! should the animation loop
+		bool looping = false;
+
+		//! starting frame for cycling
+		int cycle_start = 0;
+
+		//! end frame for cycling (-1 --> use last frame)
+		int cycle_end = -1;
+
+
+		//! offset in pixels.
+		int offset_x = 0;
+	};
 
 public:
 	/**
@@ -85,40 +118,11 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, Sprite & spritesheet, int row, int col, int col_animate);
-
+	Animator(uint32_t id, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
-	//! A reference to the Sprite sheet containing.
-	Sprite & spritesheet;
-
-	//! The maximum number of columns in the sprite sheet.
-	const int col;
-
-	//! The maximum number of rows in the sprite sheet.
-	const int row;
-
-	//! The current col being animated.
-	int curr_col = 0;
-
-	//! The current row being animated.
-	int curr_row = 0;
-
-	//! should the animation loop
-	bool looping = false;
-
-	//! starting frame for cycling
-	int cycle_start = 0;
-
-	//! end frame for cycling (-1 --> use last frame)
-	int cycle_end = -1;
-
-	//! frames per second for animation
-	int fps = 1;
-
-	//! offset in pixels.
-	int offset_x = 0;
+	Animator::Data data;
 
 private:
 	//! AnimatorSystem adjust the private member parameters of Animator;
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index 39d8ab0..27bcb35 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -2,19 +2,12 @@
 #include "util/Log.h"
 
 #include "Camera.h"
-#include "Color.h"
 #include "Component.h"
 
 using namespace crepe;
 
-Camera::Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen,
-			   const vec2 & viewport_size, const double & zoom, const vec2 & offset)
-	: Component(id),
-	  bg_color(bg_color),
-	  offset(offset),
-	  screen(screen),
-	  viewport_size(viewport_size),
-	  zoom(zoom) {
+Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
+
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index 2d8fa48..e466d36 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -14,32 +14,35 @@ namespace crepe {
  * position, and zoom level. It controls what part of the game world is visible on the screen.
  */
 class Camera : public Component {
+public:
+	struct Data {
+		//! Background color of the camera view.
+		const Color bg_color;
+
+		//! screen the display size in pixels ( output resolution )
+		const ivec2 screen;
+
+		//! viewport is the area of the world visible through the camera (in world units)
+		const vec2 viewport_size;
+
+		//! Zoom level of the camera view.
+		double zoom;
+
+		//! offset postion from the game object transform component
+		vec2 offset;
+	};
 
 public:
 	/**
 	 * \brief Constructs a Camera with the specified ID and background color.
 	 * \param id Unique identifier for the camera component.
-	 * \param bg_color Background color for the camera view.
+	 * \param ctx the camera component data
 	 */
-	Camera(game_object_id_t id, const Color & bg_color, const ivec2 & screen,
-		   const vec2 & viewport_size, const double & zoom, const vec2 & offset = {0, 0});
+	Camera(game_object_id_t id, const Data & ctx);
 	~Camera(); // dbg_trace only
 
 public:
-	//! Background color of the camera view.
-	const Color bg_color;
-
-	//! offset postion from the game object transform component
-	vec2 offset;
-
-	//! screen the display size in pixels ( output resolution )
-	const ivec2 screen;
-
-	//! viewport is the area of the world visible through the camera (in world units)
-	const vec2 viewport_size;
-
-	//! Zoom level of the camera view.
-	const double zoom;
+	Camera::Data data;
 
 public:
 	/**
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index 29e415f..fe495a1 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -11,21 +11,16 @@
 using namespace std;
 using namespace crepe;
 
-Sprite::Sprite(game_object_id_t id, Texture & image, const Color & color,
-			   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size)
+Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & ctx)
 	: Component(id),
-	  color(color),
-	  flip(flip),
-	  sprite_image(std::move(image)),
-	  sorting_in_layer(sort_layer),
-	  order_in_layer(order_layer),
-	  size(size) {
+	  texture(std::move(texture)),
+	  data(ctx) {
 
 	dbg_trace();
 
-	this->mask.w = sprite_image.get_width();
-	this->mask.h = sprite_image.get_height();
-	this->aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
+	this->mask.w = this->texture.get_width();
+	this->mask.h = this->texture.get_height();
+	this->data.aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
 }
 
 Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 354f663..aef6a8d 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -19,73 +19,67 @@ class AnimatorSystem;
  * flip settings, and is managed in layers with defined sorting orders.
  */
 class Sprite : public Component {
-
 public:
 	struct FlipSettings {
 		bool flip_x = false;
 		bool flip_y = false;
 	};
 
+	struct Data {
+		//! Color tint of the sprite
+		Color color;
+
+		//! Flip settings for the sprite
+		FlipSettings flip;
+
+		//! Layer sorting level of the sprite
+		const int sorting_in_layer;
+
+		//! Order within the sorting layer
+		const int order_in_layer;
+
+		/**
+	 	* \size width and height of the sprite in game units
+	 	*
+	 	* if height is filled in and not width it will multiply width by aspect_ratio.
+	 	* if width is filled in and not height it will multiply height by aspect_ratio.
+	 	* if neither is filled it will not show sprite because size will be zero
+	 	* if both are filled will it use the width and height without making sure the aspect_ratio
+	 	* is correct
+	 	*/
+		vec2 size;
+
+		//! independent sprite angle. rotating clockwise direction in degrees
+		double angle_offset = 0;
+
+		//! independent sprite scale multiplier
+		double scale = 1;
+
+		/**
+	 	* \aspect_ratio ratio of the img so that scaling will not become weird
+	 	*
+	 	* cannot be const because if Animator component is addded then ratio becomes scuffed and
+	 	* does it need to be calculated again in the Animator
+	 	*/
+		float aspect_ratio;
+	};
+
 public:
-	// TODO: Loek comment in github #27 will be looked another time
-	// about shared_ptr Texture
 	/**
 	 * \brief Constructs a Sprite with specified parameters.
 	 * \param game_id Unique identifier for the game object this sprite belongs to.
-	 * \param image Shared pointer to the texture for this sprite.
-	 * \param color Color tint applied to the sprite.
-	 * \param flip Flip settings for horizontal and vertical orientation.
-	 * \param order_layer decides the sorting in layer of the sprite.
-	 * \param sort_layer decides the order in layer of the sprite.
-	 * \param height the height of the image in game units
-	 */
-	Sprite(game_object_id_t id, Texture & image, const Color & color,
-		   const FlipSettings & flip, int sort_layer, int order_layer, const vec2 & size);
-
-	/**
-	 * \brief Destroys the Sprite instance.
+	 * \param texture asset of the image
+	 * \param ctx all the sprite data
 	 */
+	//TODO: texture is outside the Sprite::Data because of the deleted copy constructer. eventually
+	//  texture will go into data when it becomes asset
+	Sprite(game_object_id_t id, Texture & texture, const Data & ctx);
 	~Sprite();
 
 	//! Texture used for the sprite
-	const Texture sprite_image;
-
-	//! Color tint of the sprite
-	Color color;
-
-	//! Flip settings for the sprite
-	FlipSettings flip;
-
-	//! Layer sorting level of the sprite
-	const int sorting_in_layer;
+	const Texture texture;
 
-	//! Order within the sorting layer
-	const int order_in_layer;
-
-	/**
-	 * \size width and height of the sprite in game units
-	 *
-	 * if height is filled in and not width it will multiply width by aspect_ratio.
-	 * if width is filled in and not height it will multiply height by aspect_ratio.
-	 * if neither is filled it will not show sprite because size will be zero
-	 * if both are filled will it use the width and height without making sure the aspect_ratio
-	 * is correct
-	 */
-	vec2 size;
-
-	//! independent sprite angle. rotating clockwise direction in degrees
-	double angle_offset = 0;
-
-	//! independent sprite scale multiplier
-	double scale = 1;
-
-	/**
-	 * \aspect_ratio ratio of the img so that scaling will not become weird
-	 *
-	 * cannot be const because if Animator component is addded then ratio becomes scuffed and
-	 * does it need to be calculated again in the Animator
-	 */
-	float aspect_ratio;
+	Data data;
 
 private:
 	//! Reads the mask of sprite
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index bba26a3..ab3fa45 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -112,17 +112,15 @@ SDL_Rect SDLContext::get_src_rect(const Sprite & sprite) const {
 
 SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
-	// this might not work all the time because of float checking zero -_-
-	vec2 size = {ctx.sprite.size.x == 0 && ctx.sprite.size.y != 0
-					 ? ctx.sprite.size.y * ctx.sprite.aspect_ratio
-					 : ctx.sprite.size.x,
-				 ctx.sprite.size.y == 0 && ctx.sprite.size.x != 0
-					 ? ctx.sprite.size.x / ctx.sprite.aspect_ratio
-					 : ctx.sprite.size.y};
+	const Sprite::Data & data = ctx.sprite.data;
+
+	vec2 size = {
+		data.size.x == 0 && data.size.y != 0 ? data.size.y * data.aspect_ratio : data.size.x,
+		data.size.y == 0 && data.size.x != 0 ? data.size.x / data.aspect_ratio : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
-	size *= cam.render_scale * ctx.img_scale * ctx.sprite.scale;
+	size *= cam.render_scale * ctx.img_scale * data.scale;
 
 	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
@@ -137,9 +135,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 void SDLContext::draw(const RenderContext & ctx) {
 
+	const Sprite::Data & data = ctx.sprite.data;
 	SDL_RendererFlip render_flip
-		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * ctx.sprite.flip.flip_x)
-							  | (SDL_FLIP_VERTICAL * ctx.sprite.flip.flip_y));
+		= (SDL_RendererFlip) ((SDL_FLIP_HORIZONTAL * data.flip.flip_x)
+							  | (SDL_FLIP_VERTICAL * data.flip.flip_y));
 
 	SDL_Rect srcrect = this->get_src_rect(ctx.sprite);
 	SDL_FRect dstrect = this->get_dst_rect(SDLContext::DstRect{
@@ -149,10 +148,10 @@ void SDLContext::draw(const RenderContext & ctx) {
 		.img_scale = ctx.scale,
 	});
 
-	double angle = ctx.angle + ctx.sprite.angle_offset;
+	double angle = ctx.angle + data.angle_offset;
 
-	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.sprite_image.texture.get(),
-					  &srcrect, &dstrect, angle, NULL, render_flip);
+	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.texture.texture.get(), &srcrect,
+					  &dstrect, angle, NULL, render_flip);
 }
 
 void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 1650b3d..b1f23d1 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -17,20 +17,21 @@ void AnimatorSystem::update() {
 
 	for (Animator & a : animations) {
 		if (!a.active) continue;
+		
+		Animator::Data & ctx = a.data;
+		double frame_duration = 1.0f / ctx.fps;
 
-		double frame_duration = 1.0f / a.fps;
-
-		int cycle_end = (a.cycle_end == -1) ? a.row : cycle_end;
-		int total_frames = cycle_end - a.cycle_start;
+		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : cycle_end;
+		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
-		a.curr_row = a.cycle_start + curr_frame;
-		a.spritesheet.mask.x = a.curr_row * a.spritesheet.mask.w;
-		a.spritesheet.mask.y = (a.curr_col * a.spritesheet.mask.h);
+		ctx.curr_row = ctx.cycle_start + curr_frame;
+		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
 	
 		std::cout << curr_frame << " " << total_frames << std::endl;
-		if (!a.looping && curr_frame == 0) {
+		if (!ctx.looping && curr_frame == 0) {
 			a.active = false;
 		}
 	}
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 944ac86..08f254f 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -40,8 +40,9 @@ const Camera & RenderSystem::update_camera() {
 }
 
 bool sorting_comparison(const Sprite & a, const Sprite & b) {
-	if (a.sorting_in_layer < b.sorting_in_layer) return true;
-	if (a.sorting_in_layer == b.sorting_in_layer) return a.order_in_layer < b.order_in_layer;
+	if (a.data.sorting_in_layer < b.data.sorting_in_layer) return true;
+	if (a.data.sorting_in_layer == b.data.sorting_in_layer)
+		return a.data.order_in_layer < b.data.order_in_layer;
 
 	return false;
 }
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 5a50d27..4fd4071 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -56,11 +56,24 @@ public:
 		auto img = Texture("asset/spritesheet/pokemon_spritesheet.png");
 
 		Sprite & test_sprite = game_object.add_component<Sprite>(
-			img, color, Sprite::FlipSettings{false, false}, 1, 1, vec2{100, 100});
+			img, Sprite::Data{
+					 .color = color,
+					 .flip = Sprite::FlipSettings{false, false},
+					 .sorting_in_layer = 2,
+					 .order_in_layer = 2,
+					 .size = {0, 100},
+					 .angle_offset = 0,
+					 .scale = 1,
+				 });
 
-		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, 0);
+		auto & anim = game_object.add_component<Animator>(Animator::Data{
+			.spritesheet = test_sprite,
+			.col = 4,
+			.row = 4,
+			.fps = 10,
+		});
 
-		auto & cam = game_object.add_component<Camera>(Color::, ivec2{720, 1280},
+		auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{720, 1280},
 													   vec2{400, 400}, 1.0);
 	}
 
-- 
cgit v1.2.3


From 4bbc27098d5a8907ab0500ad3ccc82283cf95ddf Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Mon, 2 Dec 2024 20:34:00 +0100
Subject: merge fix and review fix

---
 src/example/game.cpp     | 13 ++++---------
 src/test/CMakeLists.txt  | 24 ++++++++++++------------
 src/test/PhysicsTest.cpp | 10 ++++------
 src/test/Profiling.cpp   | 10 +---------
 4 files changed, 21 insertions(+), 36 deletions(-)

(limited to 'src/example')

diff --git a/src/example/game.cpp b/src/example/game.cpp
index e851526..c439f5d 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -18,7 +18,7 @@ using namespace std;
 
 class MyScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
-		Log::logf("Box {} script on_collision()", test.info.first.collider.game_object_id);
+		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
 		return true;
 	}
 	void init() {
@@ -50,8 +50,6 @@ public:
 		.gravity_scale = 0,
 		.body_type = Rigidbody::BodyType::STATIC,
 		.constraints = {0, 0, 0},
-		.use_gravity = false,
-		.bounce = false,
 		.offset = {0,0}
 	});
 	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
@@ -67,17 +65,14 @@ public:
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.linear_velocity = {1,1},
 		.constraints = {0, 0, 0},
-		.use_gravity = true,
-		.bounce = true,
 		.elastisity = 1,
 		.offset = {0,0},
 	});
 	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	game_object1.add_component<Sprite>(
-	make_shared<Texture>("/home/jaro/crepe/asset/texture/green_square.png"), color,
-	FlipSettings{true, true});
-	game_object1.add_component<Camera>(Color::WHITE);
+	auto img = Texture("asset/texture/green_square.png");
+	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+	game_object1.add_component<Camera>(Color::WHITE, ivec2{1080, 720},vec2{2000, 2000}, 1.0f);
 	}
 
 	string get_name() const { return "scene1"; }
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index 4555c0b..cd61fb7 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,17 +1,17 @@
 target_sources(test_main PUBLIC
 	CollisionTest.cpp
 	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
+	PhysicsTest.cpp
+	ScriptTest.cpp
+	ParticleTest.cpp
+	AssetTest.cpp
+	OptionalRefTest.cpp
+	RenderSystemTest.cpp
+	EventTest.cpp
+	ECSTest.cpp
+	SceneManagerTest.cpp
+	ValueBrokerTest.cpp
+	DBTest.cpp
+	Vector2Test.cpp
 	Profiling.cpp
 )
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index 33b6020..5dd448f 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -28,8 +28,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);
@@ -105,16 +103,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_factor.x = 0.5;
+	rigidbody.data.linear_velocity_factor.y = 0.5;
+	rigidbody.data.angular_velocity_factor = 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_factor = 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
index a88bf85..e46d5ff 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -26,14 +26,6 @@ using namespace std::chrono_literals;
 using namespace crepe;
 using namespace testing;
 
-
-/*
-List of test cases with component settings/details
-1. Minimal test creates gameobject without additonal components
-2. Minimal 'Complex' gameobject. Has dynamic body without bounce and no collision handler
-3. Minimal 'Complex' gameobject. Same as test 2 but with particle emitter
-*/
-
 class TestScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
 		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
@@ -55,7 +47,7 @@ public:
 	// Minimum amount to let test pass
 	const int min_gameobject_count = 100;
 	// Maximum amount to stop test
-	const int max_gameobject_count = 200;
+	const int max_gameobject_count = 150;
 	// Amount of times a test runs to calculate average
 	const int average = 5;
 	// Maximum duration to stop test
-- 
cgit v1.2.3


From 0a1739de21e5ab270cb45efb6fc0aed092d81227 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Mon, 2 Dec 2024 21:00:54 +0100
Subject: added all the contructor strutcts for animator,sprite and camera

---
 src/crepe/api/Animator.cpp          | 15 +++++++++++++--
 src/crepe/api/Animator.h            |  8 ++------
 src/crepe/api/Camera.cpp            |  1 -
 src/crepe/facade/SDLContext.cpp     | 35 ++++++++++++++++++-----------------
 src/crepe/facade/SDLContext.h       |  2 +-
 src/crepe/system/AnimatorSystem.cpp |  6 ++----
 src/crepe/system/RenderSystem.cpp   |  2 +-
 src/example/rendering_particle.cpp  | 14 +++++++++++---
 8 files changed, 48 insertions(+), 35 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index ce824e6..1234967 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -9,8 +9,7 @@ using namespace crepe;
 
 Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	: Component(id),
-	data(ctx)
-{
+	  data(ctx) {
 	dbg_trace();
 
 	this->data.spritesheet.mask.h /= this->data.col;
@@ -23,21 +22,33 @@ Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
 	ss.data.aspect_ratio
 		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
 }
+
 Animator::~Animator() { dbg_trace(); }
 
 void Animator::loop() { this->data.looping = true; }
+
 void Animator::play() { this->active = true; }
+
 void Animator::pause() { this->active = false; }
+
 void Animator::stop() {
 	this->active = false;
 	this->data.curr_col = 0;
 	this->data.curr_row = 0;
 }
 void Animator::set_fps(int fps) { this->data.fps = fps; }
+
 void Animator::set_cycle_range(int start, int end) {
 	this->data.cycle_start = start, this->data.cycle_end = end;
 }
+
 void Animator::set_anim(int col) {
 	this->data.curr_row = 0;
 	this->data.curr_col = col;
 }
+
+void Animator::next_anim() {
+	Animator::Data & ctx = this->data;
+	ctx.curr_row = ctx.curr_row++ % ctx.row;
+	ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+}
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 194a9cf..36bc9f4 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -47,6 +47,7 @@ public:
 
 
 		//! offset in pixels.
+		// TODO implement
 		int offset_x = 0;
 	};
 
@@ -108,12 +109,7 @@ public:
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
 	 *
 	 * \param id The unique identifier for the component, typically assigned automatically.
-	 * \param spritesheet A reference to the Sprite object which holds the sprite sheet for
-	 * animation.
-	 * \param row The maximum number of rows in the sprite sheet.
-	 * \param col The maximum number of columns in the sprite sheet.
-	 * \param col_animate The specific col index of the sprite sheet to animate. This allows
-	 * selecting which col to animate from multiple col in the sheet.
+	 * \param ctx animator data
 	 *
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index 27bcb35..ff41710 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -7,7 +7,6 @@
 using namespace crepe;
 
 Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
-
 	dbg_trace();
 }
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index ab3fa45..32461f2 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -156,53 +156,54 @@ void SDLContext::draw(const RenderContext & ctx) {
 
 void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 
+	const Camera::Data & cam_data = cam.data;
 	// resize window
 	int w, h;
 	SDL_GetWindowSize(this->game_window.get(), &w, &h);
-	if (w != cam.screen.x || h != cam.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
+	if (w != cam_data.screen.x || h != cam_data.screen.y) {
+		SDL_SetWindowSize(this->game_window.get(), cam_data.screen.x, cam_data.screen.y);
 	}
 
 	vec2 & zoomed_viewport = ctx.zoomed_viewport;
 	vec2 & bar_size = ctx.bar_size;
 	vec2 & render_scale = ctx.render_scale;
 
-	zoomed_viewport = cam.viewport_size * cam.zoom;
-	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
+	zoomed_viewport = cam_data.viewport_size * cam_data.zoom;
+	double screen_aspect = static_cast<double>(cam_data.screen.x) / cam_data.screen.y;
 	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		float scale = cam.screen.y / zoomed_viewport.y;
+		float scale = cam_data.screen.y / zoomed_viewport.y;
 		float adj_width = zoomed_viewport.x * scale;
-		float bar_width = (cam.screen.x - adj_width) / 2;
-		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		float bar_width = (cam_data.screen.x - adj_width) / 2;
+		this->black_bars[0] = {0, 0, bar_width, (float) cam_data.screen.y};
+		this->black_bars[1] = {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		float scale = cam.screen.x / (cam.viewport_size.x * cam.zoom);
-		float adj_height = cam.viewport_size.y * scale;
-		float bar_height = (cam.screen.y - adj_height) / 2;
-		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
+		float scale = cam_data.screen.x / (cam_data.viewport_size.x * cam_data.zoom);
+		float adj_height = cam_data.viewport_size.y * scale;
+		float bar_height = (cam_data.screen.y - adj_height) / 2;
+		this->black_bars[0] = {0, 0, (float) cam_data.screen.x, bar_height};
 		this->black_bars[1]
-			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
+			= {0, (cam_data.screen.y - bar_height), (float) cam_data.screen.x, bar_height};
 
 		bar_size = {0, bar_height};
 		render_scale.x = render_scale.y = scale;
 	}
 
-	SDL_SetRenderDrawColor(this->game_renderer.get(), cam.bg_color.r, cam.bg_color.g,
-						   cam.bg_color.b, cam.bg_color.a);
+	SDL_SetRenderDrawColor(this->game_renderer.get(), cam_data.bg_color.r, cam_data.bg_color.g,
+						   cam_data.bg_color.b, cam_data.bg_color.a);
 
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = cam.screen.x,
-		.h = cam.screen.y,
+		.w = cam_data.screen.x,
+		.h = cam_data.screen.y,
 	};
 
 	// fill bg color
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 0a6fce6..a0d1da8 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -128,7 +128,7 @@ private:
 
 	/**
 	 * \brief Draws a sprite to the screen using the specified transform and camera.
-	 * \param RenderCtx Reference to rendering data to draw
+	 * \param RenderContext Reference to rendering data to draw
 	 */
 	void draw(const RenderContext & ctx);
 
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index b1f23d1..ff8d2ce 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -4,7 +4,6 @@
 
 #include "AnimatorSystem.h"
 #include "ComponentManager.h"
-#include <iostream>
 
 using namespace crepe;
 
@@ -21,7 +20,7 @@ void AnimatorSystem::update() {
 		Animator::Data & ctx = a.data;
 		double frame_duration = 1.0f / ctx.fps;
 
-		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
@@ -30,8 +29,7 @@ void AnimatorSystem::update() {
 		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
 		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
 	
-		std::cout << curr_frame << " " << total_frames << std::endl;
-		if (!ctx.looping && curr_frame == 0) {
+		if (!ctx.looping && curr_frame == total_frames - 1) {
 			a.active = false;
 		}
 	}
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 08f254f..1bf5f65 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -33,7 +33,7 @@ const Camera & RenderSystem::update_camera() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
 		this->context.set_camera(cam, this->cam_ctx);
-		this->cam_ctx.cam_pos = transform.position + cam.offset;
+		this->cam_ctx.cam_pos = transform.position + cam.data.offset;
 		return cam;
 	}
 	throw std::runtime_error("No active cameras in current scene");
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 4fd4071..f84eb94 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -70,11 +70,19 @@ public:
 			.spritesheet = test_sprite,
 			.col = 4,
 			.row = 4,
-			.fps = 10,
+			.fps = 1,
+			.looping = true,
+			.cycle_start = 1,
+			.cycle_end = 3,
 		});
+		anim.set_anim(2);
 
-		auto & cam = game_object.add_component<Camera>(Color::WHITE, ivec2{720, 1280},
-													   vec2{400, 400}, 1.0);
+		auto & cam = game_object.add_component<Camera>(Camera::Data{
+			.bg_color = Color::WHITE,
+			.screen = ivec2{720, 1280},
+			.viewport_size = vec2{400, 400},
+			.zoom = 1.0,
+		});
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From 683ae28b81a66f18bbadbe7ae70eb8ddd952c293 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Tue, 3 Dec 2024 10:40:37 +0100
Subject: fixed the one cycle aimatorsystem where it did not do the last
 frame_for the full duration

---
 src/crepe/system/AnimatorSystem.cpp | 4 +++-
 src/example/rendering_particle.cpp  | 6 ++----
 2 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index 9cf8ba5..e9cdd4c 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -20,6 +20,8 @@ void AnimatorSystem::update() {
 		Animator::Data & ctx = a.data;
 		double frame_duration = 1.0f / ctx.fps;
 
+		int last_frame = ctx.curr_row;
+
 		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
@@ -29,7 +31,7 @@ void AnimatorSystem::update() {
 		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
 		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
 
-		if (!ctx.looping && curr_frame == total_frames - 1) {
+		if (!ctx.looping && curr_frame == ctx.cycle_start && last_frame == total_frames - 1) {
 			a.active = false;
 		}
 	}
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index f84eb94..e18c7b7 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -71,15 +71,13 @@ public:
 			.col = 4,
 			.row = 4,
 			.fps = 1,
-			.looping = true,
-			.cycle_start = 1,
-			.cycle_end = 3,
+			.looping = false,
 		});
 		anim.set_anim(2);
 
 		auto & cam = game_object.add_component<Camera>(Camera::Data{
 			.bg_color = Color::WHITE,
-			.screen = ivec2{720, 1280},
+			.screen = ivec2{1280, 720},
 			.viewport_size = vec2{400, 400},
 			.zoom = 1.0,
 		});
-- 
cgit v1.2.3


From 0da996d1c206947fdc54e324e46025efcf15fe64 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Tue, 3 Dec 2024 17:52:24 +0100
Subject: button example

---
 src/example/CMakeLists.txt |  2 +-
 src/example/button.cpp     | 50 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 src/example/button.cpp

(limited to 'src/example')

diff --git a/src/example/CMakeLists.txt b/src/example/CMakeLists.txt
index 85ec466..93b9ee2 100644
--- a/src/example/CMakeLists.txt
+++ b/src/example/CMakeLists.txt
@@ -19,4 +19,4 @@ endfunction()
 add_example(asset_manager)
 add_example(savemgr)
 add_example(rendering_particle)
-
+add_example(button)
diff --git a/src/example/button.cpp b/src/example/button.cpp
new file mode 100644
index 0000000..d74f781
--- /dev/null
+++ b/src/example/button.cpp
@@ -0,0 +1,50 @@
+#include <crepe/api/Camera.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/Component.h>
+#include <crepe/api/Color.h>
+#include <crepe/api/GameObject.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Transform.h>
+#include <crepe/system/RenderSystem.h>
+#include <crepe/api/EventManager.h>
+#include <crepe/system/InputSystem.h>
+#include <crepe/system/AnimatorSystem.h>
+#include <crepe/api/Button.h>
+#include <crepe/api/Animator.h>
+#include <crepe/api/Texture.h>
+#include <SDL2/SDL_timer.h>
+#include <crepe/types.h>
+#include <chrono>
+#include <iostream>
+using namespace crepe;
+using namespace std;
+
+int main(int argc, char * argv[]) {
+	ComponentManager mgr;
+	RenderSystem sys{mgr};
+	EventManager& event_mgr = EventManager::get_instance();
+	InputSystem input_sys{mgr};
+	AnimatorSystem asys{mgr};
+	GameObject camera_obj = mgr.new_object("", "", vec2{0, 0}, 0, 1);
+	camera_obj.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000}, 1.0f);
+
+	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	auto s2 = Texture("asset/texture/test_ap43.png");
+	bool button_clicked = false;
+	auto & sprite2 = button_obj.add_component<Sprite>(
+			s2, Color::GREEN, Sprite::FlipSettings{false, false}, 2, 1, 100);
+	std::function<void()> on_click = [&]() { 
+		std::cout << "button clicked" << std::endl;
+	};
+	auto & button = button_obj.add_component<Button>(100, 100, on_click, false);
+	button.active = true;
+	auto start = std::chrono::steady_clock::now();
+	while (true) {
+		input_sys.update();
+		sys.update();
+		asys.update();
+		event_mgr.dispatch_events();
+		SDL_Delay(30);
+	}
+	return 0;
+}
-- 
cgit v1.2.3


From ff618da3f97237796042fa3664da59ed147bc1da Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 19:32:15 +0100
Subject: improved comments

---
 src/crepe/Collider.h                 |  18 +++-
 src/crepe/api/BoxCollider.cpp        |   2 +-
 src/crepe/api/BoxCollider.h          |  10 +--
 src/crepe/api/Rigidbody.h            | 128 +++++++++++++++++++++++----
 src/crepe/system/CollisionSystem.cpp | 167 ++++++++++++++++-------------------
 src/crepe/system/CollisionSystem.h   |  32 ++-----
 src/crepe/system/PhysicsSystem.cpp   |   8 +-
 src/example/game.cpp                 |   4 +-
 src/test/CollisionTest.cpp           |  56 ++++++------
 src/test/PhysicsTest.cpp             |   8 +-
 src/test/Profiling.cpp               |   2 +-
 11 files changed, 257 insertions(+), 178 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index 15d3a24..f5f53d2 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -10,7 +10,23 @@ public:
 	Collider(game_object_id_t id, const vec2& offset);
 
 public:
-	//! Offset of the collider relative to rigidbody position 
+	/**
+	* \brief Offset of the collider relative to the rigidbody position.
+	*
+	* The `offset` defines the positional shift applied to the collider relative to the position of the rigidbody it is attached to.
+	* This allows the collider to be placed at a different position than the rigidbody, which can be useful for scenarios
+	* where the collider's position needs to differ from the rigidbody's center, such as in non-centered colliders.
+	* 
+	* - The `offset` is typically used when the collider is not meant to be centered exactly on the rigidbody's position.
+	* - For example, the collider might need to be shifted to account for an object with an asymmetrical shape or for objects
+	*   where the pivot point of the rigidbody is different from the collider's center.
+	* 
+	* When multiple colliders are added to the same object (e.g., a character with separate body parts or a vehicle with multiple zones),
+	* the offset is important for properly positioning each collider relative to the rigidbody, allowing accurate collision detection.
+	* 
+	* - Multiple colliders can be used on the same object, and each can have its own unique offset.
+	* - Overlap between colliders is allowed and does not impact performance.
+	*/
 	vec2 offset;
 };
 
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index 1069e90..f94ced7 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -4,4 +4,4 @@
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height) : Collider(game_object_id,offset), width(width), height(height) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions) : Collider(game_object_id,offset), dimensions(dimensions) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index c83d54a..1f5f1c1 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -2,6 +2,7 @@
 
 #include "Vector2.h"
 #include "../Collider.h"
+#include "types.h"
 
 namespace crepe {
 
@@ -12,13 +13,10 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,const vec2& offset, float width, float height);
+	BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions);
 
-	//! Width of box collider 
-	float width;
-
-	//! Height of box collider
-	float height;
+	//! Width and height of the box collider 
+	vec2 dimensions;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 63b1b51..9cdf3f5 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -36,11 +36,11 @@ public:
 	 * the systems will not move the object.
 	 */
 	struct PhysicsConstraints {
-		//! X constraint
+		//! Prevent movement along X axis
 		bool x = false;
-		//! Y constraint
+		//! Prevent movement along Y axis
 		bool y = false;
-		//! rotation constraint
+		//! Prevent rotation
 		bool rotation = false;
 	};
 
@@ -53,27 +53,112 @@ public:
 	struct Data {
 		//! objects mass
 		float mass = 0.0;
-		//! gravtiy scale
+		/**
+		* \brief Gravity scale factor.
+		*
+		* The `gravity_scale` controls how much gravity affects the object. It is a multiplier applied to the default
+		* gravity force, allowing for fine-grained control over how the object responds to gravity.
+		* 
+		* - A value of `0.0` means that gravity has **no effect** on the object (i.e., the object is completely immune to gravity).
+		* - A value of `1.0` means that gravity is applied at its **normal intensity** (the default behavior).
+		* - A value greater than `1.0` means the object is affected by gravity more strongly than normal.
+		* - A value less than `1.0` (but greater than `0.0`) reduces the effect of gravity on the object.
+		* 
+		* This is useful in cases where you need objects to behave differently under gravity, such as lighter objects (like feathers),
+		* objects that float in water, or heavier objects that fall faster.
+		*/
 		float gravity_scale = 0;
-		//! Changes if physics apply
+		/**
+		* \brief Defines the type of the physics body, which determines how the physics system interacts with the object.
+		*
+		* - **Static**: The object does not move and is not affected by forces. It is used for immovable objects like walls or terrain. Does not have collision detection.
+		* - **Dynamic**: The object is fully affected by physics forces, including gravity, collisions, and other physical interactions. It can move and be moved by forces.
+		* - **Kinematic**: The object does not move and is not affected by forces. It is typically controlled by external factors (e.g., animations or user input), and collision detection is handled without affecting its velocity.
+		*
+		* The `body_type` defines the behavior of the object in the physics system.
+		*
+		* \default BodyType::DYNAMIC
+		*/
 		BodyType body_type = BodyType::DYNAMIC;
-		//! linear velocity of object
+
+		/**
+		* \name Linear (positional) motion
+		*
+		* These variables define the linear motion (movement along the position) of an object.
+		* The linear velocity is applied to the object's position in each update of the PhysicsSystem.
+		* The motion is affected by the object's linear velocity, its maximum velocity, and a coefficient
+		* that can scale the velocity over time.
+		*
+		* \{
+		*/
+		//! Linear velocity of the object (speed and direction).
 		vec2 linear_velocity;
-		//! maximum linear velocity of object
+		//! Maximum linear velocity of the object. This limits the object's speed.
 		vec2 max_linear_velocity = {INFINITY ,INFINITY};
-		//! linear damping of object
-		vec2 linear_velocity_factor;
-		//! angular velocity of object
+		//! Linear velocity coefficient. This scales the object's velocity for adjustment or damping.
+		vec2 linear_velocity_coefficient = {1,1};
+		//! \}
+
+		/**
+		* \name Angular (rotational) motion
+		*
+		* These variables define the angular motion (rotation) of an object.
+		* The angular velocity determines how quickly the object rotates, while the maximum angular velocity
+		* sets a limit on the rotation speed. The angular velocity coefficient applies damping or scaling
+		* to the angular velocity, which can be used to simulate friction or other effects that slow down rotation.
+		*
+		* \{
+		*/
+		//! Angular velocity of the object, representing the rate of rotation (in radians per second).
 		float angular_velocity = 1;
-		//! max angular velocity of object
+		//! Maximum angular velocity of the object. This limits the maximum rate of rotation.
 		float max_angular_velocity = INFINITY;
-		//! angular damping of object
-		float angular_velocity_factor = 1;
-		//! movements constraints of object
+		//! Angular velocity coefficient. This scales the object's angular velocity, typically used for damping.
+		float angular_velocity_coefficient = 1;
+		//! \}
+
+		/**
+		* \brief Movement constraints for an object.
+		*
+		* The `PhysicsConstraints` struct defines the constraints that restrict an object's movement
+		* in certain directions or prevent rotation. These constraints effect only the physics system
+		* to prevent the object from moving or rotating in specified ways.
+		* 
+		* - **X Constraint**: If enabled, the object cannot move along the X-axis.
+		* - **Y Constraint**: If enabled, the object cannot move along the Y-axis.
+		* - **Rotation Constraint**: If enabled, the object cannot rotate.
+		* 
+		* These constraints allow you to restrict movement for specific scenarios (e.g., a platform that shouldn't move
+		* or a character that should only move horizontally).
+		*/
 		PhysicsConstraints constraints;
-		//! bounce factor of material. 0.0 <= means all velocity is lost, 1.0 means it gets the same momentum but the mirrored direction. 0.5 is half of the velocity is saved.
-		float elastisity = 0.0;
-		//! offset of all colliders relative to transform position
+
+		/**
+		* \brief Elasticity factor of the material (bounce factor).
+		*
+		* The `elasticity_coefficient` controls how much of the object's velocity is retained after a collision.
+		* It represents the material's ability to bounce or recover velocity upon impact. The coefficient is a value
+		* between 0.0 and 1.0, where:
+		*
+		* - **0.0** means no velocity is retained after the collision (all velocity is lost, and the object does not bounce).
+		* - **1.0** means the object retains its full velocity but in the opposite direction (perfect elastic bounce).
+		* - **0.5** means the object retains half of its velocity, resulting in a bounce with reduced speed.
+		*
+		* This factor can be used to simulate different materials, such as rubber (high elasticity) or concrete (low elasticity).
+		*/
+		float elastisity_coefficient = 0.0;
+
+		/**
+		* \brief Offset of all colliders relative to the object's transform position.
+		*
+		* The `offset` defines a positional shift applied to all colliders associated with the object, relative to the object's
+		* transform position. This allows for the colliders to be placed at a different position than the object's actual
+		* position, without modifying the object's transform itself.
+		* 
+		* - The `offset` is typically used to adjust the collider's position in cases where all colluders should be moved.
+		* - For example, if a character has a animation where all colliders should be moved this offset can be used to 
+		*		achieve this.
+		*/
 		vec2 offset;
 	};
 
@@ -99,6 +184,15 @@ public:
 	 * \param force Vector2 that is added to the angular force.
 	 */
 	void add_force_angular(float force);
+
+protected:
+	/**
+	* Ensures there is at most one Rigidbody component per entity.
+	* \return Always returns 1, indicating this constraint.
+	*/
+	virtual int get_instances_max() const { return 1; }
+	//! ComponentManager instantiates all components
+	friend class ComponentManager;
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 380cc3d..2d5ce9d 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -10,6 +10,7 @@
 #include "api/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Metadata.h"
 #include "api/Vector2.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
@@ -23,18 +24,16 @@
 using namespace crepe;
 
 void CollisionSystem::update() {
-	
 	std::vector<CollisionInternal> all_colliders;
-	ComponentManager & mgr = this->component_manager;
 	game_object_id_t id = 0;
-	RefVector<Rigidbody> rigidbodies = mgr.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
 	for(Rigidbody& rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
 		Transform& transform = this->component_manager.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders	= mgr.get_components_by_type<BoxCollider>();
+		RefVector<BoxCollider> boxcolliders	= this->component_manager.get_components_by_type<BoxCollider>();
 		for (BoxCollider& boxcollider : boxcolliders) {
 			if(boxcollider.game_object_id != id) continue;
 			if(!boxcollider.active) continue;
@@ -48,7 +47,7 @@ void CollisionSystem::update() {
 				);
 		}
 		// Check if the circlecollider is active and has the same id as the rigidbody.
-		RefVector<CircleCollider> circlecolliders	= mgr.get_components_by_type<CircleCollider>();
+		RefVector<CircleCollider> circlecolliders	= this->component_manager.get_components_by_type<CircleCollider>();
 		for (CircleCollider& circlecollider : circlecolliders) {
 			if(circlecollider.game_object_id != id) continue;
 			if(!circlecollider.active) continue;
@@ -64,59 +63,63 @@ void CollisionSystem::update() {
 	}
 
 	// Check between all colliders if there is a collision
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = gather_collisions(all_colliders);
+	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = this->gather_collisions(all_colliders);
 
 	// For both objects call the collision handler 
 	for (auto& collision_pair : collided) {
-		collision_handler_request(collision_pair.first,collision_pair.second);
-		collision_handler_request(collision_pair.second,collision_pair.first);
+		this->collision_handler_request(collision_pair.first,collision_pair.second);
+		this->collision_handler_request(collision_pair.second,collision_pair.first);
 	}
 }
 
-void CollisionSystem::collision_handler_request(CollisionInternal& data1,CollisionInternal& data2){
+void CollisionSystem::collision_handler_request(CollisionInternal& this_data,CollisionInternal& other_data){
 
-	CollisionInternalType type = get_collider_type(data1.collider,data2.collider);
-	std::pair<vec2,CollisionSystem::Direction> resolution_data = collision_handler(data1,data2,type);
+	CollisionInternalType type = this->get_collider_type(this_data.collider,other_data.collider);
+	std::pair<vec2,CollisionSystem::Direction> resolution_data = this->collision_handler(this_data,other_data,type);
 
-	OptionalRef<Collider> collider1;
-	OptionalRef<Collider> collider2;
+	OptionalRef<Metadata> this_metadata = this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
+	OptionalRef<Metadata> other_metadata = this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
+	OptionalRef<Collider> this_collider;
+	OptionalRef<Collider> other_collider;
 	switch (type) {
 		case CollisionInternalType::BOX_BOX:{
-			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE:{
-			collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_BOX:{
-			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:{
-			collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 	}
-	
+
 	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
-						.first_collider = collider1,
-						.first_transform = data1.transform,
-						.first_rigidbody = data1.rigidbody,
-						.second_collider = collider2,
-						.second_transform = data2.transform,
-						.second_rigidbody = data2.rigidbody,
+						.this_collider = this_collider,
+						.this_transform = this_data.transform,
+						.this_rigidbody = this_data.rigidbody,
+						.this_metadata = this_metadata,
+						.other_collider = other_collider,
+						.other_transform = other_data.transform,
+						.other_rigidbody = other_data.rigidbody,
+						.other_metadata = other_metadata,
 						.resolution = resolution_data.first,
 						.resolution_direction = resolution_data.second,
         };
 
 	// Determine if static needs to be called
-	determine_collision_handler(collision_info);	
+	this->determine_collision_handler(collision_info);	
 }
 
 
@@ -126,33 +129,33 @@ std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(Co
 		case CollisionInternalType::BOX_BOX:	{
 			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
 			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
 			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
 			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
 			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
 			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
 			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
 			break;
 		}
 	}
@@ -179,10 +182,10 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,co
 	vec2 delta = final_position2 - final_position1;
 
 	// Compute half-dimensions of the boxes
-	float half_width1 = box_collider1.width / 2.0;
-	float half_height1 = box_collider1.height / 2.0;
-	float half_width2 = box_collider2.width / 2.0;
-	float half_height2 = box_collider2.height / 2.0;
+	float half_width1 = box_collider1.dimensions.x / 2.0;
+	float half_height1 = box_collider1.dimensions.y / 2.0;
+	float half_width2 = box_collider2.dimensions.x / 2.0;
+	float half_height2 = box_collider2.dimensions.y / 2.0;
 
 	// Calculate overlaps along X and Y axes
 	float overlap_x = (half_width1 + half_width2) - std::abs(delta.x);
@@ -234,8 +237,8 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_col
     vec2 delta = circle_position - box_position;
 
     // Compute half-dimensions of the box
-    float half_width = box_collider.width / 2.0f;
-    float half_height = box_collider.height / 2.0f;
+    float half_width = box_collider.dimensions.x / 2.0f;
+    float half_height = box_collider.dimensions.y / 2.0f;
 
     // Clamp circle center to the nearest point on the box
     vec2 closest_point;
@@ -261,37 +264,37 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_col
 
 void CollisionSystem::determine_collision_handler(CollisionInfo& info){
 	// Check rigidbody type for static
-	if(info.first_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
+	if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
 	// If second body is static perform the static collision handler in this system
-	if(info.second_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+	if(info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
 		static_collision_handler(info);
 	}; 
 	// Call collision event for user
 	CollisionEvent data(info);
-	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.first_collider.game_object_id);
+	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo& info){
 	// Move object back using calculate move back value 
-	info.first_transform.position += info.resolution;
+	info.this_transform.position += info.resolution;
 
 	// If bounce is enabled mirror velocity
-	if(info.first_rigidbody.data.elastisity > 0) {
+	if(info.this_rigidbody.data.elastisity_coefficient > 0) {
 		if(info.resolution_direction == Direction::BOTH)
 		{
-			info.first_rigidbody.data.linear_velocity.y = -info.first_rigidbody.data.linear_velocity.y * info.first_rigidbody.data.elastisity;
-			info.first_rigidbody.data.linear_velocity.x = -info.first_rigidbody.data.linear_velocity.x * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
+			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
 		}
 		else if(info.resolution_direction == Direction::Y_DIRECTION) {
-			info.first_rigidbody.data.linear_velocity.y = -info.first_rigidbody.data.linear_velocity.y * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
 		}
 		else if(info.resolution_direction == Direction::X_DIRECTION){
-			info.first_rigidbody.data.linear_velocity.x = -info.first_rigidbody.data.linear_velocity.x * info.first_rigidbody.data.elastisity;
+			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
 		}
 	}
 	// Stop movement if bounce is disabled
 	else {
-		info.first_rigidbody.data.linear_velocity = {0,0};
+		info.this_rigidbody.data.linear_velocity = {0,0};
 	}
 }
 
@@ -332,24 +335,6 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 	return collisions_ret;
 }
 
-std::optional<std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>>>
-CollisionSystem::get_active_transform_and_rigidbody(game_object_id_t game_object_id) const{
-    RefVector<Transform> transforms = this->component_manager.get_components_by_id<Transform>(game_object_id);
-    if (transforms.empty()) return std::nullopt;
-
-		Transform& transform = transforms.front().get();
-    if (!transform.active) return std::nullopt;
-
-    RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_id<Rigidbody>(game_object_id);
-    if (rigidbodies.empty()) return std::nullopt;
-
-    Rigidbody& rigidbody = rigidbodies.front().get();
-    if (!rigidbody.active) return std::nullopt;
-
-    // Return the active components
-    return std::make_pair(std::ref(transform), std::ref(rigidbody));
-}
-
 CollisionSystem::CollisionInternalType CollisionSystem::get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const{
 	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
 		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
@@ -376,22 +361,22 @@ bool CollisionSystem::get_collision(const CollisionInternal& first_info,const Co
 		case CollisionInternalType::BOX_BOX:	{
 			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
 			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
 			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
 			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE:	{
 			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
 			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 		case CollisionInternalType::CIRCLE_BOX:	{
 			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
 			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
 		}
 	}
 	return false;
@@ -401,14 +386,14 @@ bool CollisionSystem::get_collision(const CollisionInternal& first_info,const Co
 bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const
 {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(box1.offset,transform1,rigidbody1);
-	vec2 final_position2 = get_current_position(box2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset,transform1,rigidbody1);
+	vec2 final_position2 = this->get_current_position(box2.offset,transform2,rigidbody2);
 
 	// Calculate half-extents (half width and half height)
-	float half_width1 = box1.width / 2.0;
-	float half_height1 = box1.height / 2.0;
-	float half_width2 = box2.width / 2.0;
-	float half_height2 = box2.height / 2.0;
+	float half_width1 = box1.dimensions.x / 2.0;
+	float half_height1 = box1.dimensions.y / 2.0;
+	float half_width2 = box2.dimensions.x / 2.0;
+	float half_height2 = box2.dimensions.y / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
 	return (final_position1.x + half_width1 > final_position2.x - half_width2 &&
@@ -419,12 +404,12 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCo
 
 bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(box1.offset, transform1, rigidbody1);
-	vec2 final_position2 = get_current_position(circle2.offset, transform2, rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
 
 	// Calculate box half-extents
-	float half_width = box1.width / 2.0;
-	float half_height = box1.height / 2.0;
+	float half_width = box1.dimensions.x / 2.0;
+	float half_height = box1.dimensions.y / 2.0;
 
 	// Find the closest point on the box to the circle's center
 	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
@@ -441,8 +426,8 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 
 bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = get_current_position(circle1.offset,transform1,rigidbody1);
-	vec2 final_position2 = get_current_position(circle2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(circle1.offset,transform1,rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset,transform2,rigidbody2);
 
 	float distance_x = final_position1.x - final_position2.x;
 	float distance_y = final_position1.y - final_position2.y;
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 7fb8b45..85ae5ad 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -8,6 +8,7 @@
 #include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Metadata.h"
 #include "api/Vector2.h"
 
 #include "Collider.h"
@@ -68,12 +69,14 @@ public:
 		* Includes information about the colliding objects and the resolution data for handling the collision.
 		*/
 	struct CollisionInfo{
-    Collider& first_collider;
-		Transform& first_transform;
-		Rigidbody& first_rigidbody;
-    Collider& second_collider;
-		Transform& second_transform;
-		Rigidbody& second_rigidbody;
+    Collider& this_collider;
+		Transform& this_transform;
+		Rigidbody& this_rigidbody;
+		Metadata& this_metadata;
+    Collider& other_collider;
+		Transform& other_transform;
+		Rigidbody& other_rigidbody;
+		Metadata& other_metadata;
 		//! The resolution vector for the collision.
 		vec2 resolution;
 		//! The direction of movement for resolving the collision.
@@ -213,23 +216,6 @@ private:
 		*/
 	bool get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const;
 	
-	/**
-		* \brief Retrieves the active Transform and Rigidbody components for a given game object.
-		* 
-		* This function looks up the Transform and Rigidbody components associated with the specified 
-		* game object ID. It checks if both components are present and active. If both are found 
-		* to be active, they are returned wrapped in reference wrappers; otherwise, an empty 
-		* optional is returned.
-		*
-		* \param game_object_id The ID of the game object for which to retrieve the components.
-		* 
-		* \return A std::optional containing a pair of reference wrappers to the active Transform 
-		*         and Rigidbody components, or std::nullopt if either component is not found 
-		*         or not active.
-		*/
-	std::optional<std::pair<std::reference_wrapper<Transform>, std::reference_wrapper<Rigidbody>>> get_active_transform_and_rigidbody(game_object_id_t game_object_id) const;
-
-
 	/**
 		* \brief Detects collisions between two BoxColliders.
 		* 
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index 8f21727..f3833cb 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -31,11 +31,11 @@ void PhysicsSystem::update() {
 									* gravity);
 						}
 						// Add damping
-						if (rigidbody.data.angular_velocity_factor != 1 && rigidbody.data.angular_velocity_factor > 0) {
-							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_factor;
+						if (rigidbody.data.angular_velocity_coefficient != 1 && rigidbody.data.angular_velocity_coefficient > 0) {
+							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_factor != vec2{1, 1} && rigidbody.data.linear_velocity_factor.x > 0 && rigidbody.data.linear_velocity_factor.y > 0) {
-							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_factor;
+						if (rigidbody.data.linear_velocity_coefficient != vec2{1, 1} && rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
+							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
 						}
 
 						// Max velocity check
diff --git a/src/example/game.cpp b/src/example/game.cpp
index c439f5d..4e16d4a 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -18,7 +18,7 @@ using namespace std;
 
 class MyScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
-		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
@@ -65,7 +65,7 @@ public:
 		.body_type = Rigidbody::BodyType::DYNAMIC,
 		.linear_velocity = {1,1},
 		.constraints = {0, 0, 0},
-		.elastisity = 1,
+		.elastisity_coefficient = 1,
 		.offset = {0,0},
 	});
 	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 92ff7ba..fec42f3 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -68,10 +68,10 @@ public:
 			.offset = {0,0},
 		});
 		// Create a box with an inner size of 10x10 units
-		world.add_component<BoxCollider>(vec2{0, -100}, 100, 100); // Top
-		world.add_component<BoxCollider>(vec2{0, 100}, 100, 100); // Bottom
-		world.add_component<BoxCollider>(vec2{-100, 0}, 100, 100); // Left
-		world.add_component<BoxCollider>(vec2{100, 0}, 100, 100); // right
+		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,
@@ -79,10 +79,10 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.elastisity = 1,
+			.elastisity_coefficient = 1,
 			.offset = {0,0},
 		});
-		game_object1.add_component<BoxCollider>(vec2{0, 0}, 10, 10);
+		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);
@@ -93,10 +93,10 @@ public:
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0,0},
 			.constraints = {0, 0, 0},
-			.elastisity = 1,
+			.elastisity_coefficient = 1,
 			.offset = {0,0},
 		});
-		game_object2.add_component<BoxCollider>(vec2{0, 0}, 10, 10);
+		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);
@@ -110,11 +110,11 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		EXPECT_EQ(ev.info.this_collider.game_object_id, 2);
 	};
 	EXPECT_FALSE(collision_happend);
 	collision_sys.update();
@@ -125,14 +125,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -148,14 +148,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -171,14 +171,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -194,14 +194,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -221,14 +221,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -248,14 +248,14 @@ 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.first_collider.game_object_id, 1);
+		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.first_collider.game_object_id, 2);
+		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);
@@ -276,7 +276,7 @@ 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.first_collider.game_object_id, 1);
+		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);
@@ -298,7 +298,7 @@ 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.first_collider.game_object_id, 1);
+		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);
@@ -322,7 +322,7 @@ 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.first_collider.game_object_id, 1);
+		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);
@@ -348,8 +348,8 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	float resolution = 0;
 	script_object1_ref->test_fn = [&](const CollisionEvent & ev) {
 		collision_happend = true;
-		EXPECT_EQ(ev.info.first_collider.game_object_id, 1);
-		EXPECT_EQ(ev.info.first_collider.offset.x , offset_value);
+		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) {
@@ -365,7 +365,7 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	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}, 10, 10);
+	this->game_object1.add_component<BoxCollider>(vec2{-5, 0}, vec2{10, 10});
 	offset_value = 5;
 	resolution = 10;
 	collision_sys.update();
diff --git a/src/test/PhysicsTest.cpp b/src/test/PhysicsTest.cpp
index 5dd448f..ad7cb03 100644
--- a/src/test/PhysicsTest.cpp
+++ b/src/test/PhysicsTest.cpp
@@ -103,16 +103,16 @@ TEST_F(PhysicsTest, movement) {
 	EXPECT_EQ(transform.position.y, 1);
 	EXPECT_EQ(transform.rotation, 1);
 
-	rigidbody.data.linear_velocity_factor.x = 0.5;
-	rigidbody.data.linear_velocity_factor.y = 0.5;
-	rigidbody.data.angular_velocity_factor = 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_velocity_factor = 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
index e46d5ff..fa0f5f3 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -28,7 +28,7 @@ using namespace testing;
 
 class TestScript : public Script {
 	bool oncollision(const CollisionEvent& test) {
-		Log::logf("Box {} script on_collision()", test.info.first_collider.game_object_id);
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
 	}
 	void init() {
-- 
cgit v1.2.3


From 9416841ad776d9117bc3b12ee3ceb9a8c7af4c73 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 19:44:01 +0100
Subject: removed part of if

---
 src/crepe/api/Rigidbody.h          |  4 ++--
 src/crepe/system/PhysicsSystem.cpp |  4 ++--
 src/example/game.cpp               | 13 ++++++-------
 3 files changed, 10 insertions(+), 11 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 9cdf3f5..14b183b 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -109,8 +109,8 @@ public:
 		*
 		* \{
 		*/
-		//! Angular velocity of the object, representing the rate of rotation (in radians per second).
-		float angular_velocity = 1;
+		//! Angular velocity of the object, representing the rate of rotation (in degrees).
+		float angular_velocity = 0;
 		//! Maximum angular velocity of the object. This limits the maximum rate of rotation.
 		float max_angular_velocity = INFINITY;
 		//! Angular velocity coefficient. This scales the object's angular velocity, typically used for damping.
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index f3833cb..b5da042 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -31,10 +31,10 @@ void PhysicsSystem::update() {
 									* gravity);
 						}
 						// Add damping
-						if (rigidbody.data.angular_velocity_coefficient != 1 && rigidbody.data.angular_velocity_coefficient > 0) {
+						if (rigidbody.data.angular_velocity_coefficient > 0) {
 							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_coefficient != vec2{1, 1} && rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
+						if (rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
 							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
 						}
 
diff --git a/src/example/game.cpp b/src/example/game.cpp
index 4e16d4a..5e3fab7 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -52,11 +52,11 @@ public:
 		.constraints = {0, 0, 0},
 		.offset = {0,0}
 	});
-	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, world_collider, world_collider);;	// Top
-	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, world_collider, world_collider); // Bottom
-	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, world_collider, world_collider); // Left
-	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, world_collider, world_collider); // right
-
+	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, vec2{world_collider, world_collider});;	// Top
+	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, vec2{world_collider, world_collider}); // Bottom
+	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, vec2{world_collider, world_collider}); // Left
+	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, vec2{world_collider, world_collider}); // right
+	world.add_component<Camera>(Color::WHITE, ivec2{640, 480},vec2{640, 480}, 1.0f);
 
 	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
 	game_object1.add_component<Rigidbody>(Rigidbody::Data{
@@ -68,11 +68,10 @@ public:
 		.elastisity_coefficient = 1,
 		.offset = {0,0},
 	});
-	game_object1.add_component<BoxCollider>(vec2{0, 0}, 20, 20);
+	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	auto img = Texture("asset/texture/green_square.png");
 	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
-	game_object1.add_component<Camera>(Color::WHITE, ivec2{1080, 720},vec2{2000, 2000}, 1.0f);
 	}
 
 	string get_name() const { return "scene1"; }
-- 
cgit v1.2.3


From 322e9a8ceaa8b2ce5d3e6056be4a9739817d47cf Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Tue, 3 Dec 2024 20:43:57 +0100
Subject: improved comments

---
 src/crepe/Collider.h      | 12 +-----------
 src/crepe/api/Rigidbody.h | 36 +++---------------------------------
 src/example/game.cpp      |  4 ++--
 3 files changed, 6 insertions(+), 46 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index f5f53d2..b3a09fb 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -14,18 +14,8 @@ public:
 	* \brief Offset of the collider relative to the rigidbody position.
 	*
 	* The `offset` defines the positional shift applied to the collider relative to the position of the rigidbody it is attached to.
-	* This allows the collider to be placed at a different position than the rigidbody, which can be useful for scenarios
-	* where the collider's position needs to differ from the rigidbody's center, such as in non-centered colliders.
+	* This allows the collider to be placed at a different position than the rigidbody.
 	* 
-	* - The `offset` is typically used when the collider is not meant to be centered exactly on the rigidbody's position.
-	* - For example, the collider might need to be shifted to account for an object with an asymmetrical shape or for objects
-	*   where the pivot point of the rigidbody is different from the collider's center.
-	* 
-	* When multiple colliders are added to the same object (e.g., a character with separate body parts or a vehicle with multiple zones),
-	* the offset is important for properly positioning each collider relative to the rigidbody, allowing accurate collision detection.
-	* 
-	* - Multiple colliders can be used on the same object, and each can have its own unique offset.
-	* - Overlap between colliders is allowed and does not impact performance.
 	*/
 	vec2 offset;
 };
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 14b183b..431e000 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -59,26 +59,10 @@ public:
 		* The `gravity_scale` controls how much gravity affects the object. It is a multiplier applied to the default
 		* gravity force, allowing for fine-grained control over how the object responds to gravity.
 		* 
-		* - A value of `0.0` means that gravity has **no effect** on the object (i.e., the object is completely immune to gravity).
-		* - A value of `1.0` means that gravity is applied at its **normal intensity** (the default behavior).
-		* - A value greater than `1.0` means the object is affected by gravity more strongly than normal.
-		* - A value less than `1.0` (but greater than `0.0`) reduces the effect of gravity on the object.
-		* 
-		* This is useful in cases where you need objects to behave differently under gravity, such as lighter objects (like feathers),
-		* objects that float in water, or heavier objects that fall faster.
 		*/
 		float gravity_scale = 0;
-		/**
-		* \brief Defines the type of the physics body, which determines how the physics system interacts with the object.
-		*
-		* - **Static**: The object does not move and is not affected by forces. It is used for immovable objects like walls or terrain. Does not have collision detection.
-		* - **Dynamic**: The object is fully affected by physics forces, including gravity, collisions, and other physical interactions. It can move and be moved by forces.
-		* - **Kinematic**: The object does not move and is not affected by forces. It is typically controlled by external factors (e.g., animations or user input), and collision detection is handled without affecting its velocity.
-		*
-		* The `body_type` defines the behavior of the object in the physics system.
-		*
-		* \default BodyType::DYNAMIC
-		*/
+
+		//! Defines the type of the physics body, which determines how the physics system interacts with the object.
 		BodyType body_type = BodyType::DYNAMIC;
 
 		/**
@@ -124,12 +108,6 @@ public:
 		* in certain directions or prevent rotation. These constraints effect only the physics system
 		* to prevent the object from moving or rotating in specified ways.
 		* 
-		* - **X Constraint**: If enabled, the object cannot move along the X-axis.
-		* - **Y Constraint**: If enabled, the object cannot move along the Y-axis.
-		* - **Rotation Constraint**: If enabled, the object cannot rotate.
-		* 
-		* These constraints allow you to restrict movement for specific scenarios (e.g., a platform that shouldn't move
-		* or a character that should only move horizontally).
 		*/
 		PhysicsConstraints constraints;
 
@@ -138,13 +116,8 @@ public:
 		*
 		* The `elasticity_coefficient` controls how much of the object's velocity is retained after a collision.
 		* It represents the material's ability to bounce or recover velocity upon impact. The coefficient is a value
-		* between 0.0 and 1.0, where:
-		*
-		* - **0.0** means no velocity is retained after the collision (all velocity is lost, and the object does not bounce).
-		* - **1.0** means the object retains its full velocity but in the opposite direction (perfect elastic bounce).
-		* - **0.5** means the object retains half of its velocity, resulting in a bounce with reduced speed.
+		* above 0.0.
 		*
-		* This factor can be used to simulate different materials, such as rubber (high elasticity) or concrete (low elasticity).
 		*/
 		float elastisity_coefficient = 0.0;
 
@@ -155,9 +128,6 @@ public:
 		* transform position. This allows for the colliders to be placed at a different position than the object's actual
 		* position, without modifying the object's transform itself.
 		* 
-		* - The `offset` is typically used to adjust the collider's position in cases where all colluders should be moved.
-		* - For example, if a character has a animation where all colliders should be moved this offset can be used to 
-		*		achieve this.
 		*/
 		vec2 offset;
 	};
diff --git a/src/example/game.cpp b/src/example/game.cpp
index 5e3fab7..de08a22 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -38,7 +38,7 @@ public:
 
 	void load_scene() {
 	ComponentManager & mgr = this->component_manager;
-	Color color(0, 0, 0, 0);
+	Color color(0, 0, 0, 255);
 
 	float screen_size_width = 640;
 	float screen_size_height = 480;
@@ -71,7 +71,7 @@ public:
 	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
 	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
 	auto img = Texture("asset/texture/green_square.png");
-	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
+	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 20);
 	}
 
 	string get_name() const { return "scene1"; }
-- 
cgit v1.2.3


From a11824956b478e356fa684c9d88b980aa22cb19a Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 4 Dec 2024 10:56:53 +0100
Subject: implemented feedback, cameraValues need better name?

---
 src/crepe/api/Animator.cpp          | 29 ++++++++++++----------
 src/crepe/api/Animator.h            | 22 +++++++++--------
 src/crepe/api/Camera.cpp            |  7 +++++-
 src/crepe/api/Camera.h              | 19 ++++++++-------
 src/crepe/api/Sprite.cpp            |  2 +-
 src/crepe/api/Sprite.h              | 25 ++++++++++---------
 src/crepe/facade/SDLContext.cpp     | 48 ++++++++++++++++++++-----------------
 src/crepe/facade/SDLContext.h       |  2 +-
 src/crepe/system/AnimatorSystem.cpp |  6 ++---
 src/crepe/system/RenderSystem.cpp   | 19 +++++++--------
 src/crepe/system/RenderSystem.h     |  8 +++----
 src/example/rendering_particle.cpp  | 14 +++--------
 12 files changed, 103 insertions(+), 98 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index 1234967..dc99fd4 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,20 +7,23 @@
 
 using namespace crepe;
 
-Animator::Animator(game_object_id_t id, const Animator::Data & ctx)
+Animator::Animator(uint32_t id, Sprite & ss, int max_row, int max_col,
+				   const Animator::Data & ctx)
 	: Component(id),
+	  spritesheet(ss),
+	  row(max_row),
+	  col(max_col),
 	  data(ctx) {
 	dbg_trace();
 
-	this->data.spritesheet.mask.h /= this->data.col;
-	this->data.spritesheet.mask.w /= this->data.row;
-	this->data.spritesheet.mask.x = 0;
-	this->data.spritesheet.mask.y = this->data.col * this->data.spritesheet.mask.h;
+	this->spritesheet.mask.h /= this->col;
+	this->spritesheet.mask.w /= this->row;
+	this->spritesheet.mask.x = this->data.curr_row * this->spritesheet.mask.w;
+	this->spritesheet.mask.y = this->data.curr_col * this->spritesheet.mask.h;
 
 	// need to do this for to get the aspect ratio for a single clipping in the spritesheet
-	Sprite & ss = this->data.spritesheet;
-	ss.data.aspect_ratio
-		= static_cast<double>(this->data.spritesheet.mask.w) / this->data.spritesheet.mask.h;
+	this->spritesheet.aspect_ratio
+		= static_cast<double>(this->spritesheet.mask.w) / this->spritesheet.mask.h;
 }
 
 Animator::~Animator() { dbg_trace(); }
@@ -43,12 +46,14 @@ void Animator::set_cycle_range(int start, int end) {
 }
 
 void Animator::set_anim(int col) {
-	this->data.curr_row = 0;
-	this->data.curr_col = col;
+	Animator::Data & ctx = this->data;
+	this->spritesheet.mask.x = ctx.curr_row = 0;
+	ctx.curr_col = col;
+	this->spritesheet.mask.y = ctx.curr_col * this->spritesheet.mask.h;
 }
 
 void Animator::next_anim() {
 	Animator::Data & ctx = this->data;
-	ctx.curr_row = ctx.curr_row++ % ctx.row;
-	ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
+	ctx.curr_row = ctx.curr_row++ % this->row;
+	this->spritesheet.mask.x = ctx.curr_row * this->spritesheet.mask.w;
 }
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 74abd5e..1fe2b6f 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -18,20 +18,13 @@ class SDLContext;
 class Animator : public Component {
 public:
 	struct Data {
-		//! A reference to the Sprite sheet containing.
-		Sprite & spritesheet;
 
-		//! The maximum number of columns in the sprite sheet.
-		const int col;
-
-		//! The maximum number of rows in the sprite sheet.
-		const int row;
 
 		//! frames per second for animation
-		int fps;
+		int fps = 1;
 
 		//! The current col being animated.
-		int curr_col;
+		int curr_col = 0;
 
 		//! The current row being animated.
 		int curr_row = 0;
@@ -113,10 +106,19 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, const Animator::Data & ctx);
+	Animator(uint32_t id, Sprite & ss, int max_row, int max_col, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
+	//! A reference to the Sprite sheet containing.
+	Sprite & spritesheet;
+
+	//! The maximum number of columns in the sprite sheet.
+	const int col;
+
+	//! The maximum number of rows in the sprite sheet.
+	const int row;
+
 	Animator::Data data;
 
 private:
diff --git a/src/crepe/api/Camera.cpp b/src/crepe/api/Camera.cpp
index ff41710..b042c35 100644
--- a/src/crepe/api/Camera.cpp
+++ b/src/crepe/api/Camera.cpp
@@ -6,7 +6,12 @@
 
 using namespace crepe;
 
-Camera::Camera(game_object_id_t id, const Data & ctx) : Component(id), data(ctx) {
+Camera::Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
+			   const Data & ctx)
+	: Component(id),
+	  screen(screen),
+	  viewport_size(viewport_size),
+	  data(ctx) {
 	dbg_trace();
 }
 
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index e466d36..f626379 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -17,16 +17,10 @@ class Camera : public Component {
 public:
 	struct Data {
 		//! Background color of the camera view.
-		const Color bg_color;
-
-		//! screen the display size in pixels ( output resolution )
-		const ivec2 screen;
-
-		//! viewport is the area of the world visible through the camera (in world units)
-		const vec2 viewport_size;
+		const Color bg_color = Color::WHITE;
 
 		//! Zoom level of the camera view.
-		double zoom;
+		double zoom = 1;
 
 		//! offset postion from the game object transform component
 		vec2 offset;
@@ -38,12 +32,19 @@ public:
 	 * \param id Unique identifier for the camera component.
 	 * \param ctx the camera component data
 	 */
-	Camera(game_object_id_t id, const Data & ctx);
+	Camera(game_object_id_t id, const ivec2 & screen, const vec2 & viewport_size,
+		   const Data & ctx);
 	~Camera(); // dbg_trace only
 
 public:
 	Camera::Data data;
 
+	//! screen the display size in pixels ( output resolution )
+	const ivec2 screen;
+
+	//! viewport is the area of the world visible through the camera (in world units)
+	const vec2 viewport_size;
+
 public:
 	/**
 	 * \brief Gets the maximum number of camera instances allowed.
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index fe495a1..3a1acac 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -20,7 +20,7 @@ Sprite::Sprite(game_object_id_t id, Texture & texture, const Sprite::Data & ctx)
 
 	this->mask.w = this->texture.get_width();
 	this->mask.h = this->texture.get_height();
-	this->data.aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
+	this->aspect_ratio = static_cast<double>(this->mask.w) / this->mask.h;
 }
 
 Sprite::~Sprite() { dbg_trace(); }
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index aef6a8d..d82ae8d 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -27,16 +27,16 @@ public:
 
 	struct Data {
 		//! Color tint of the sprite
-		Color color;
+		Color color = Color::WHITE;
 
 		//! Flip settings for the sprite
 		FlipSettings flip;
 
 		//! Layer sorting level of the sprite
-		const int sorting_in_layer;
+		const int sorting_in_layer = 0;
 
 		//! Order within the sorting layer
-		const int order_in_layer;
+		const int order_in_layer = 0;
 
 		/**
 	 	* \size width and height of the sprite in game units
@@ -53,15 +53,8 @@ public:
 		double angle_offset = 0;
 
 		//! independent sprite scale multiplier
-		double scale = 1;
+		double scale_offset = 1;
 
-		/**
-	 	* \aspect_ratio ratio of the img so that scaling will not become weird
-	 	*
-	 	* cannot be const because if Animator component is addded then ratio becomes scuffed and
-	 	* does it need to be calculated again in the Animator
-	 	*/
-		float aspect_ratio;
 	};
 
 public:
@@ -71,8 +64,6 @@ public:
 	 * \param texture asset of the image
 	 * \param ctx all the sprite data
 	 */
-	//TODO: texture is outside the Sprite::Data because of the deleted copy constructer. eventually
-	//  texture will go into data when it becomes asset
 	Sprite(game_object_id_t id, Texture & texture, const Data & ctx);
 	~Sprite();
 
@@ -82,6 +73,14 @@ public:
 	Data data;
 
 private:
+	/**
+		* \aspect_ratio ratio of the img so that scaling will not become weird
+		*
+		* cannot be const because if Animator component is addded then ratio becomes scuffed and
+		* does it need to be calculated again in the Animator
+		*/
+	float aspect_ratio;
+
 	//! Reads the mask of sprite
 	friend class SDLContext;
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 391aa78..d3a15d9 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -115,12 +115,12 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 	const Sprite::Data & data = ctx.sprite.data;
 
 	vec2 size = {
-		data.size.x == 0 && data.size.y != 0 ? data.size.y * data.aspect_ratio : data.size.x,
-		data.size.y == 0 && data.size.x != 0 ? data.size.x / data.aspect_ratio : data.size.y};
+		data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio : data.size.x,
+		data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
-	size *= cam.render_scale * ctx.img_scale * data.scale;
+	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
 	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
@@ -154,44 +154,45 @@ void SDLContext::draw(const RenderContext & ctx) {
 					  &dstrect, angle, NULL, render_flip);
 }
 
-void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
+SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 
 	const Camera::Data & cam_data = cam.data;
+	CameraValues ret_cam;
 	// resize window
 	int w, h;
 	SDL_GetWindowSize(this->game_window.get(), &w, &h);
-	if (w != cam_data.screen.x || h != cam_data.screen.y) {
-		SDL_SetWindowSize(this->game_window.get(), cam_data.screen.x, cam_data.screen.y);
+	if (w != cam.screen.x || h != cam.screen.y) {
+		SDL_SetWindowSize(this->game_window.get(), cam.screen.x, cam.screen.y);
 	}
 
-	vec2 & zoomed_viewport = ctx.zoomed_viewport;
-	vec2 & bar_size = ctx.bar_size;
-	vec2 & render_scale = ctx.render_scale;
+	vec2 & zoomed_viewport = ret_cam.zoomed_viewport;
+	vec2 & bar_size = ret_cam.bar_size;
+	vec2 & render_scale = ret_cam.render_scale;
 
-	zoomed_viewport = cam_data.viewport_size * cam_data.zoom;
-	double screen_aspect = static_cast<double>(cam_data.screen.x) / cam_data.screen.y;
+	zoomed_viewport = cam.viewport_size * cam_data.zoom;
+	double screen_aspect = static_cast<double>(cam.screen.x) / cam.screen.y;
 	double viewport_aspect = zoomed_viewport.x / zoomed_viewport.y;
 
 	// calculate black bars
 	if (screen_aspect > viewport_aspect) {
 		// pillarboxing
-		float scale = cam_data.screen.y / zoomed_viewport.y;
+		float scale = cam.screen.y / zoomed_viewport.y;
 		float adj_width = zoomed_viewport.x * scale;
-		float bar_width = (cam_data.screen.x - adj_width) / 2;
-		this->black_bars[0] = {0, 0, bar_width, (float) cam_data.screen.y};
+		float bar_width = (cam.screen.x - adj_width) / 2;
+		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
 		this->black_bars[1]
-			= {(cam_data.screen.x - bar_width), 0, bar_width, (float) cam_data.screen.y};
+			= {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
 	} else {
 		// letterboxing
-		float scale = cam_data.screen.x / (cam_data.viewport_size.x * cam_data.zoom);
-		float adj_height = cam_data.viewport_size.y * scale;
-		float bar_height = (cam_data.screen.y - adj_height) / 2;
-		this->black_bars[0] = {0, 0, (float) cam_data.screen.x, bar_height};
+		float scale = cam.screen.x / (cam.viewport_size.x * cam_data.zoom);
+		float adj_height = cam.viewport_size.y * scale;
+		float bar_height = (cam.screen.y - adj_height) / 2;
+		this->black_bars[0] = {0, 0, (float) cam.screen.x, bar_height};
 		this->black_bars[1]
-			= {0, (cam_data.screen.y - bar_height), (float) cam_data.screen.x, bar_height};
+			= {0, (cam.screen.y - bar_height), (float) cam.screen.x, bar_height};
 
 		bar_size = {0, bar_height};
 		render_scale.x = render_scale.y = scale;
@@ -203,12 +204,15 @@ void SDLContext::set_camera(const Camera & cam, CameraValues & ctx) {
 	SDL_Rect bg = {
 		.x = 0,
 		.y = 0,
-		.w = cam_data.screen.x,
-		.h = cam_data.screen.y,
+		.w = cam.screen.x,
+		.h = cam.screen.y,
 	};
 
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
+
+
+	return ret_cam;
 }
 
 uint64_t SDLContext::get_ticks() const { return SDL_GetTicks64(); }
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index a0d1da8..d662bee 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -142,7 +142,7 @@ private:
 	 * \brief sets the background of the camera (will be adjusted in future PR)
 	 * \param camera Reference to the Camera object.
 	 */
-	void set_camera(const Camera & camera, CameraValues & ctx);
+	CameraValues set_camera(const Camera & camera);
 
 private:
 	struct DstRect {
diff --git a/src/crepe/system/AnimatorSystem.cpp b/src/crepe/system/AnimatorSystem.cpp
index e9cdd4c..a2ae529 100644
--- a/src/crepe/system/AnimatorSystem.cpp
+++ b/src/crepe/system/AnimatorSystem.cpp
@@ -22,14 +22,14 @@ void AnimatorSystem::update() {
 
 		int last_frame = ctx.curr_row;
 
-		int cycle_end = (ctx.cycle_end == -1) ? ctx.row : ctx.cycle_end;
+		int cycle_end = (ctx.cycle_end == -1) ? a.row : ctx.cycle_end;
 		int total_frames = cycle_end - ctx.cycle_start;
 
 		int curr_frame = static_cast<int>(elapsed_time / frame_duration) % total_frames;
 
 		ctx.curr_row = ctx.cycle_start + curr_frame;
-		ctx.spritesheet.mask.x = ctx.curr_row * ctx.spritesheet.mask.w;
-		ctx.spritesheet.mask.y = (ctx.curr_col * ctx.spritesheet.mask.h);
+		a.spritesheet.mask.x = ctx.curr_row * a.spritesheet.mask.w;
+		a.spritesheet.mask.y = (ctx.curr_col * a.spritesheet.mask.h);
 
 		if (!ctx.looping && curr_frame == ctx.cycle_start && last_frame == total_frames - 1) {
 			a.active = false;
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 1bf5f65..b5db45a 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -21,7 +21,7 @@ void RenderSystem::clear_screen() { this->context.clear_screen(); }
 
 void RenderSystem::present_screen() { this->context.present_screen(); }
 
-const Camera & RenderSystem::update_camera() {
+SDLContext::CameraValues RenderSystem::update_camera() {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Camera> cameras = mgr.get_components_by_type<Camera>();
@@ -32,9 +32,9 @@ const Camera & RenderSystem::update_camera() {
 		if (!cam.active) continue;
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
-		this->context.set_camera(cam, this->cam_ctx);
-		this->cam_ctx.cam_pos = transform.position + cam.data.offset;
-		return cam;
+		SDLContext::CameraValues cam_val = this->context.set_camera(cam);
+		cam_val.cam_pos = transform.position + cam.data.offset;
+		return cam_val;
 	}
 	throw std::runtime_error("No active cameras in current scene");
 }
@@ -60,7 +60,7 @@ void RenderSystem::update() {
 	this->present_screen();
 }
 
-bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
+bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,
 								   const double & scale) {
 
 	ComponentManager & mgr = this->component_manager;
@@ -80,7 +80,7 @@ bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
 
 			this->context.draw(SDLContext::RenderContext{
 				.sprite = sprite,
-				.cam = this->cam_ctx,
+				.cam = cam,
 				.pos = p.position,
 				.angle = p.angle,
 				.scale = scale,
@@ -89,11 +89,10 @@ bool RenderSystem::render_particle(const Sprite & sprite, const Camera & cam,
 	}
 	return rendering_particles;
 }
-void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
-								 const Transform & tm) {
+void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm) {
 	this->context.draw(SDLContext::RenderContext{
 		.sprite = sprite,
-		.cam = this->cam_ctx,
+		.cam = cam,
 		.pos = tm.position,
 		.angle = tm.rotation,
 		.scale = tm.scale,
@@ -102,7 +101,7 @@ void RenderSystem::render_normal(const Sprite & sprite, const Camera & cam,
 
 void RenderSystem::render() {
 	ComponentManager & mgr = this->component_manager;
-	const Camera & cam = this->update_camera();
+	const SDLContext::CameraValues & cam = this->update_camera();
 
 	RefVector<Sprite> sprites = mgr.get_components_by_type<Sprite>();
 	RefVector<Sprite> sorted_sprites = this->sort(sprites);
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index 249f3b8..e779047 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -37,7 +37,7 @@ private:
 	void present_screen();
 
 	//! Updates the active camera used for rendering.
-	const Camera & update_camera();
+	SDLContext::CameraValues update_camera();
 
 	//! Renders the whole screen
 	void render();
@@ -49,7 +49,7 @@ private:
 	 * \param tm the Transform component for scale
 	 * \return true if particles have been rendered
 	 */
-	bool render_particle(const Sprite & sprite, const Camera & cam, const double & scale);
+	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,  const double & scale);
 
 	/**
 	 * \brief renders a sprite with a Transform component on the screen 
@@ -57,7 +57,7 @@ private:
 	 * \param sprite  the sprite component that holds all the data
 	 * \param tm the Transform component that holds the position,rotation and scale 
 	 */
-	void render_normal(const Sprite & sprite, const Camera & cam, const Transform & tm);
+	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm);
 
 	/**
 	 * \brief sort a vector sprite objects with
@@ -76,8 +76,6 @@ private:
 
 private:
 	SDLContext & context = SDLContext::get_instance();
-
-	SDLContext::CameraValues cam_ctx;
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index e18c7b7..2e2552d 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -45,8 +45,6 @@ using namespace std;
 
 class TestScene : public Scene {
 public:
-	using Scene::Scene;
-
 	void load_scene() {
 		ComponentManager & mgr = this->component_manager;
 		GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
@@ -63,23 +61,17 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
-					 .scale = 1,
 				 });
 
-		auto & anim = game_object.add_component<Animator>(Animator::Data{
-			.spritesheet = test_sprite,
-			.col = 4,
-			.row = 4,
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, Animator::Data{
 			.fps = 1,
 			.looping = false,
 		});
 		anim.set_anim(2);
+		anim.active = false;
 
-		auto & cam = game_object.add_component<Camera>(Camera::Data{
+		auto & cam = game_object.add_component<Camera>(ivec2{1280,720}, vec2{400,400},Camera::Data{
 			.bg_color = Color::WHITE,
-			.screen = ivec2{1280, 720},
-			.viewport_size = vec2{400, 400},
-			.zoom = 1.0,
 		});
 	}
 
-- 
cgit v1.2.3


From 9cde6875186b335c75eafa6402f0957cd4252c76 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Wed, 4 Dec 2024 10:57:20 +0100
Subject: make format

---
 src/crepe/api/Animator.h           |  1 -
 src/crepe/api/Sprite.h             |  1 -
 src/crepe/facade/SDLContext.cpp    | 11 +++++------
 src/crepe/system/RenderSystem.cpp  |  3 ++-
 src/crepe/system/RenderSystem.h    |  6 ++++--
 src/example/rendering_particle.cpp | 16 +++++++++-------
 6 files changed, 20 insertions(+), 18 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index 1fe2b6f..dab6697 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -19,7 +19,6 @@ class Animator : public Component {
 public:
 	struct Data {
 
-
 		//! frames per second for animation
 		int fps = 1;
 
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index d82ae8d..a1230db 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -54,7 +54,6 @@ public:
 
 		//! independent sprite scale multiplier
 		double scale_offset = 1;
-
 	};
 
 public:
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index d3a15d9..86969ed 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -114,9 +114,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	const Sprite::Data & data = ctx.sprite.data;
 
-	vec2 size = {
-		data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio : data.size.x,
-		data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio : data.size.y};
+	vec2 size = {data.size.x == 0 && data.size.y != 0 ? data.size.y * ctx.sprite.aspect_ratio
+													  : data.size.x,
+				 data.size.y == 0 && data.size.x != 0 ? data.size.x / ctx.sprite.aspect_ratio
+													  : data.size.y};
 
 	const CameraValues & cam = ctx.cam;
 
@@ -180,8 +181,7 @@ SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 		float adj_width = zoomed_viewport.x * scale;
 		float bar_width = (cam.screen.x - adj_width) / 2;
 		this->black_bars[0] = {0, 0, bar_width, (float) cam.screen.y};
-		this->black_bars[1]
-			= {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
+		this->black_bars[1] = {(cam.screen.x - bar_width), 0, bar_width, (float) cam.screen.y};
 
 		bar_size = {bar_width, 0};
 		render_scale.x = render_scale.y = scale;
@@ -211,7 +211,6 @@ SDLContext::CameraValues SDLContext::set_camera(const Camera & cam) {
 	// fill bg color
 	SDL_RenderFillRect(this->game_renderer.get(), &bg);
 
-
 	return ret_cam;
 }
 
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index b5db45a..4c618d8 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -89,7 +89,8 @@ bool RenderSystem::render_particle(const Sprite & sprite, const SDLContext::Came
 	}
 	return rendering_particles;
 }
-void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm) {
+void RenderSystem::render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
+								 const Transform & tm) {
 	this->context.draw(SDLContext::RenderContext{
 		.sprite = sprite,
 		.cam = cam,
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index e779047..9c306c5 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -49,7 +49,8 @@ private:
 	 * \param tm the Transform component for scale
 	 * \return true if particles have been rendered
 	 */
-	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,  const double & scale);
+	bool render_particle(const Sprite & sprite, const SDLContext::CameraValues & cam,
+						 const double & scale);
 
 	/**
 	 * \brief renders a sprite with a Transform component on the screen 
@@ -57,7 +58,8 @@ private:
 	 * \param sprite  the sprite component that holds all the data
 	 * \param tm the Transform component that holds the position,rotation and scale 
 	 */
-	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam, const Transform & tm);
+	void render_normal(const Sprite & sprite, const SDLContext::CameraValues & cam,
+					   const Transform & tm);
 
 	/**
 	 * \brief sort a vector sprite objects with
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 2e2552d..07e43a1 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -63,16 +63,18 @@ public:
 					 .angle_offset = 0,
 				 });
 
-		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4, Animator::Data{
-			.fps = 1,
-			.looping = false,
-		});
+		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
+														  Animator::Data{
+															  .fps = 1,
+															  .looping = false,
+														  });
 		anim.set_anim(2);
 		anim.active = false;
 
-		auto & cam = game_object.add_component<Camera>(ivec2{1280,720}, vec2{400,400},Camera::Data{
-			.bg_color = Color::WHITE,
-		});
+		auto & cam = game_object.add_component<Camera>(ivec2{1280, 720}, vec2{400, 400},
+													   Camera::Data{
+														   .bg_color = Color::WHITE,
+													   });
 	}
 
 	string get_name() const { return "TestScene"; };
-- 
cgit v1.2.3


From 7fdbeb058bc85aaafd5f424687a4ae43e796d8e3 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 11:54:41 +0100
Subject: if button outside viewport fix

---
 src/crepe/system/InputSystem.cpp | 60 +++++++++++++++++++++++-----------------
 src/example/button.cpp           |  4 +--
 2 files changed, 36 insertions(+), 28 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 0cf5af1..e746ab0 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -3,9 +3,10 @@
 #include "../api/EventManager.h"
 
 #include "InputSystem.h"
-
+#include <iostream>
 using namespace crepe;
 
+
 void InputSystem::update() {
 	ComponentManager & mgr = this->component_manager;
 	EventManager & event_mgr = EventManager::get_instance();
@@ -20,17 +21,18 @@ void InputSystem::update() {
 		break;
 	}
 	if (!curr_cam_ref) return;
-	Camera & current_cam = curr_cam_ref;
-	RefVector<Transform> transform_vec
-		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
-	Transform & cam_transform = transform_vec.front().get();
-	int camera_origin_x
-		= cam_transform.position.x + current_cam.offset.x - (current_cam.viewport_size.x / 2);
-	int camera_origin_y
-		= cam_transform.position.y + current_cam.offset.y - (current_cam.viewport_size.y / 2);
+	Camera& current_cam = curr_cam_ref;
+	RefVector<Transform> transform_vec = mgr.get_components_by_id<Transform>(current_cam.game_object_id);
+	Transform& cam_transform = transform_vec.front().get();
+	int camera_origin_x = cam_transform.position.x + current_cam.offset.x - (current_cam.viewport_size.x / 2);
+	int camera_origin_y = cam_transform.position.y + current_cam.offset.y - (current_cam.viewport_size.y / 2);
+	
 	for (const SDLContext::EventData & event : event_list) {
 		int world_mouse_x = event.mouse_position.first + camera_origin_x;
 		int world_mouse_y = event.mouse_position.second + 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);
 
 		switch (event.event_type) {
 			case SDLContext::EventType::KEYDOWN:
@@ -45,6 +47,9 @@ void InputSystem::update() {
 				});
 				break;
 			case SDLContext::EventType::MOUSEDOWN:
+				if(!mouse_in_viewport){
+					break;
+				}
 				event_mgr.queue_event<MousePressEvent>(MousePressEvent{
 					.mouse_x = world_mouse_x,
 					.mouse_y = world_mouse_y,
@@ -54,6 +59,9 @@ void InputSystem::update() {
 				last_mouse_button = event.mouse_button;
 				break;
 			case SDLContext::EventType::MOUSEUP: {
+				if(!mouse_in_viewport){
+					break;
+				}
 				event_mgr.queue_event<MouseReleaseEvent>(MouseReleaseEvent{
 					.mouse_x = world_mouse_x,
 					.mouse_y = world_mouse_y,
@@ -76,6 +84,9 @@ void InputSystem::update() {
 				}
 			} break;
 			case SDLContext::EventType::MOUSEMOVE:
+				if(!mouse_in_viewport){
+					break;
+				}
 				event_mgr.queue_event<MouseMoveEvent>(MouseMoveEvent{
 					.mouse_x = world_mouse_x,
 					.mouse_y = world_mouse_y,
@@ -99,9 +110,7 @@ void InputSystem::update() {
 		}
 	}
 }
-
-void InputSystem::handle_move(const SDLContext::EventData & event_data,
-							  const int & world_mouse_x, const int & world_mouse_y) {
+void InputSystem::handle_move(const SDLContext::EventData & event_data, const int& world_mouse_x, const int& world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -113,8 +122,7 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data,
 		if (!transform) continue;
 
 		bool was_hovering = button.hover;
-		if (button.active
-			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+		if (button.active && is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
 			button.hover = true;
 			if (!was_hovering && button.on_enter) {
 				button.on_enter();
@@ -129,8 +137,7 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data,
 	}
 }
 
-void InputSystem::handle_click(const MouseButton & mouse_button, const int & world_mouse_x,
-							   const int & world_mouse_y) {
+void InputSystem::handle_click(const MouseButton& mouse_button, const int& world_mouse_x, const int& world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -140,21 +147,22 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const int & wor
 			= mgr.get_components_by_id<Transform>(button.game_object_id);
 		OptionalRef<Transform> transform(transform_vec.front().get());
 
-		if (button.active
-			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+		if (button.active && is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
 			handle_button_press(button);
 		}
 	}
 }
 
-bool InputSystem::is_mouse_inside_button(const int & mouse_x, const int & mouse_y,
-										 const Button & button, const Transform & transform) {
-	int half_width = button.width / 2;
-	int half_height = button.height / 2;
-	return mouse_x >= transform.position.x - half_width
-		   && mouse_x <= transform.position.x + half_width
-		   && mouse_y >= transform.position.y - half_height
-		   && mouse_y <= transform.position.y + half_height;
+bool InputSystem::is_mouse_inside_button(
+    const int& mouse_x, const int& mouse_y, 
+    const Button & button, const Transform & transform) {
+    int half_width = button.width / 2;
+    int half_height = button.height / 2;
+
+    return mouse_x >= transform.position.x - half_width
+        && mouse_x <= transform.position.x + half_width
+        && mouse_y >= transform.position.y - half_height
+        && mouse_y <= transform.position.y + half_height;
 }
 
 void InputSystem::handle_button_press(Button & button) {
diff --git a/src/example/button.cpp b/src/example/button.cpp
index d74f781..be236ec 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -26,9 +26,9 @@ int main(int argc, char * argv[]) {
 	InputSystem input_sys{mgr};
 	AnimatorSystem asys{mgr};
 	GameObject camera_obj = mgr.new_object("", "", vec2{0, 0}, 0, 1);
-	camera_obj.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000}, 1.0f);
+	camera_obj.add_component<Camera>(Color::WHITE, ivec2{720, 1080}, vec2{2000, 2000}, 1.0f);
 
-	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
+	GameObject button_obj = mgr.new_object("body", "person", vec2{0, -1000}, 0, 1);
 	auto s2 = Texture("asset/texture/test_ap43.png");
 	bool button_clicked = false;
 	auto & sprite2 = button_obj.add_component<Sprite>(
-- 
cgit v1.2.3


From 2ad609ac1b08894b607fb56d74f45fffaba6c9ed Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 11:55:07 +0100
Subject: make format

---
 src/crepe/system/InputSystem.cpp | 58 +++++++++++++++++++++++-----------------
 src/example/button.cpp           | 28 +++++++++----------
 2 files changed, 46 insertions(+), 40 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index e746ab0..f590649 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -6,7 +6,6 @@
 #include <iostream>
 using namespace crepe;
 
-
 void InputSystem::update() {
 	ComponentManager & mgr = this->component_manager;
 	EventManager & event_mgr = EventManager::get_instance();
@@ -21,18 +20,24 @@ void InputSystem::update() {
 		break;
 	}
 	if (!curr_cam_ref) return;
-	Camera& current_cam = curr_cam_ref;
-	RefVector<Transform> transform_vec = mgr.get_components_by_id<Transform>(current_cam.game_object_id);
-	Transform& cam_transform = transform_vec.front().get();
-	int camera_origin_x = cam_transform.position.x + current_cam.offset.x - (current_cam.viewport_size.x / 2);
-	int camera_origin_y = cam_transform.position.y + current_cam.offset.y - (current_cam.viewport_size.y / 2);
-	
+	Camera & current_cam = curr_cam_ref;
+	RefVector<Transform> transform_vec
+		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
+	Transform & cam_transform = transform_vec.front().get();
+	int camera_origin_x
+		= cam_transform.position.x + current_cam.offset.x - (current_cam.viewport_size.x / 2);
+	int camera_origin_y
+		= cam_transform.position.y + current_cam.offset.y - (current_cam.viewport_size.y / 2);
+
 	for (const SDLContext::EventData & event : event_list) {
 		int world_mouse_x = event.mouse_position.first + camera_origin_x;
 		int world_mouse_y = event.mouse_position.second + 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);
+		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);
 
 		switch (event.event_type) {
 			case SDLContext::EventType::KEYDOWN:
@@ -47,7 +52,7 @@ void InputSystem::update() {
 				});
 				break;
 			case SDLContext::EventType::MOUSEDOWN:
-				if(!mouse_in_viewport){
+				if (!mouse_in_viewport) {
 					break;
 				}
 				event_mgr.queue_event<MousePressEvent>(MousePressEvent{
@@ -59,7 +64,7 @@ void InputSystem::update() {
 				last_mouse_button = event.mouse_button;
 				break;
 			case SDLContext::EventType::MOUSEUP: {
-				if(!mouse_in_viewport){
+				if (!mouse_in_viewport) {
 					break;
 				}
 				event_mgr.queue_event<MouseReleaseEvent>(MouseReleaseEvent{
@@ -84,7 +89,7 @@ void InputSystem::update() {
 				}
 			} break;
 			case SDLContext::EventType::MOUSEMOVE:
-				if(!mouse_in_viewport){
+				if (!mouse_in_viewport) {
 					break;
 				}
 				event_mgr.queue_event<MouseMoveEvent>(MouseMoveEvent{
@@ -110,7 +115,8 @@ void InputSystem::update() {
 		}
 	}
 }
-void InputSystem::handle_move(const SDLContext::EventData & event_data, const int& world_mouse_x, const int& world_mouse_y) {
+void InputSystem::handle_move(const SDLContext::EventData & event_data,
+							  const int & world_mouse_x, const int & world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -122,7 +128,8 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data, const in
 		if (!transform) continue;
 
 		bool was_hovering = button.hover;
-		if (button.active && is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+		if (button.active
+			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
 			button.hover = true;
 			if (!was_hovering && button.on_enter) {
 				button.on_enter();
@@ -137,7 +144,8 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data, const in
 	}
 }
 
-void InputSystem::handle_click(const MouseButton& mouse_button, const int& world_mouse_x, const int& world_mouse_y) {
+void InputSystem::handle_click(const MouseButton & mouse_button, const int & world_mouse_x,
+							   const int & world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -147,22 +155,22 @@ void InputSystem::handle_click(const MouseButton& mouse_button, const int& world
 			= mgr.get_components_by_id<Transform>(button.game_object_id);
 		OptionalRef<Transform> transform(transform_vec.front().get());
 
-		if (button.active && is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+		if (button.active
+			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
 			handle_button_press(button);
 		}
 	}
 }
 
-bool InputSystem::is_mouse_inside_button(
-    const int& mouse_x, const int& mouse_y, 
-    const Button & button, const Transform & transform) {
-    int half_width = button.width / 2;
-    int half_height = button.height / 2;
+bool InputSystem::is_mouse_inside_button(const int & mouse_x, const int & mouse_y,
+										 const Button & button, const Transform & transform) {
+	int half_width = button.width / 2;
+	int half_height = button.height / 2;
 
-    return mouse_x >= transform.position.x - half_width
-        && mouse_x <= transform.position.x + half_width
-        && mouse_y >= transform.position.y - half_height
-        && mouse_y <= transform.position.y + half_height;
+	return mouse_x >= transform.position.x - half_width
+		   && mouse_x <= transform.position.x + half_width
+		   && mouse_y >= transform.position.y - half_height
+		   && mouse_y <= transform.position.y + half_height;
 }
 
 void InputSystem::handle_button_press(Button & button) {
diff --git a/src/example/button.cpp b/src/example/button.cpp
index be236ec..96e6571 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -1,20 +1,20 @@
-#include <crepe/api/Camera.h>
-#include <crepe/ComponentManager.h>
+#include <SDL2/SDL_timer.h>
+#include <chrono>
 #include <crepe/Component.h>
+#include <crepe/ComponentManager.h>
+#include <crepe/api/Animator.h>
+#include <crepe/api/Button.h>
+#include <crepe/api/Camera.h>
 #include <crepe/api/Color.h>
+#include <crepe/api/EventManager.h>
 #include <crepe/api/GameObject.h>
 #include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
 #include <crepe/api/Transform.h>
-#include <crepe/system/RenderSystem.h>
-#include <crepe/api/EventManager.h>
-#include <crepe/system/InputSystem.h>
 #include <crepe/system/AnimatorSystem.h>
-#include <crepe/api/Button.h>
-#include <crepe/api/Animator.h>
-#include <crepe/api/Texture.h>
-#include <SDL2/SDL_timer.h>
+#include <crepe/system/InputSystem.h>
+#include <crepe/system/RenderSystem.h>
 #include <crepe/types.h>
-#include <chrono>
 #include <iostream>
 using namespace crepe;
 using namespace std;
@@ -22,7 +22,7 @@ using namespace std;
 int main(int argc, char * argv[]) {
 	ComponentManager mgr;
 	RenderSystem sys{mgr};
-	EventManager& event_mgr = EventManager::get_instance();
+	EventManager & event_mgr = EventManager::get_instance();
 	InputSystem input_sys{mgr};
 	AnimatorSystem asys{mgr};
 	GameObject camera_obj = mgr.new_object("", "", vec2{0, 0}, 0, 1);
@@ -32,10 +32,8 @@ int main(int argc, char * argv[]) {
 	auto s2 = Texture("asset/texture/test_ap43.png");
 	bool button_clicked = false;
 	auto & sprite2 = button_obj.add_component<Sprite>(
-			s2, Color::GREEN, Sprite::FlipSettings{false, false}, 2, 1, 100);
-	std::function<void()> on_click = [&]() { 
-		std::cout << "button clicked" << std::endl;
-	};
+		s2, Color::GREEN, Sprite::FlipSettings{false, false}, 2, 1, 100);
+	std::function<void()> on_click = [&]() { std::cout << "button clicked" << std::endl; };
 	auto & button = button_obj.add_component<Button>(100, 100, on_click, false);
 	button.active = true;
 	auto start = std::chrono::steady_clock::now();
-- 
cgit v1.2.3


From dc6d3b94d322f6763ff9c7210ea33e747487772c Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 11:57:24 +0100
Subject: check if camera position change button still works

---
 src/example/button.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/example')

diff --git a/src/example/button.cpp b/src/example/button.cpp
index 96e6571..e63293b 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -25,10 +25,10 @@ int main(int argc, char * argv[]) {
 	EventManager & event_mgr = EventManager::get_instance();
 	InputSystem input_sys{mgr};
 	AnimatorSystem asys{mgr};
-	GameObject camera_obj = mgr.new_object("", "", vec2{0, 0}, 0, 1);
+	GameObject camera_obj = mgr.new_object("", "", vec2{1000, 1000}, 0, 1);
 	camera_obj.add_component<Camera>(Color::WHITE, ivec2{720, 1080}, vec2{2000, 2000}, 1.0f);
 
-	GameObject button_obj = mgr.new_object("body", "person", vec2{0, -1000}, 0, 1);
+	GameObject button_obj = mgr.new_object("body", "person", vec2{1000, 0}, 0, 1);
 	auto s2 = Texture("asset/texture/test_ap43.png");
 	bool button_clicked = false;
 	auto & sprite2 = button_obj.add_component<Sprite>(
-- 
cgit v1.2.3


From 2a2e991371fc1164015df045227a6535137e74bc Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 13:25:56 +0100
Subject: example change

---
 src/example/button.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/example')

diff --git a/src/example/button.cpp b/src/example/button.cpp
index e63293b..2ab0701 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -26,9 +26,9 @@ int main(int argc, char * argv[]) {
 	InputSystem input_sys{mgr};
 	AnimatorSystem asys{mgr};
 	GameObject camera_obj = mgr.new_object("", "", vec2{1000, 1000}, 0, 1);
-	camera_obj.add_component<Camera>(Color::WHITE, ivec2{720, 1080}, vec2{2000, 2000}, 1.0f);
+	camera_obj.add_component<Camera>(Color::WHITE, ivec2{1080,720 }, vec2{2000, 2000}, 1.0f);
 
-	GameObject button_obj = mgr.new_object("body", "person", vec2{1000, 0}, 0, 1);
+	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
 	auto s2 = Texture("asset/texture/test_ap43.png");
 	bool button_clicked = false;
 	auto & sprite2 = button_obj.add_component<Sprite>(
-- 
cgit v1.2.3


From 7068db1e5892d6326c99c3828e85bced80fce5b6 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 16:51:01 +0100
Subject: make format

---
 src/example/button.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/example')

diff --git a/src/example/button.cpp b/src/example/button.cpp
index 2ab0701..52fa199 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -26,7 +26,7 @@ int main(int argc, char * argv[]) {
 	InputSystem input_sys{mgr};
 	AnimatorSystem asys{mgr};
 	GameObject camera_obj = mgr.new_object("", "", vec2{1000, 1000}, 0, 1);
-	camera_obj.add_component<Camera>(Color::WHITE, ivec2{1080,720 }, vec2{2000, 2000}, 1.0f);
+	camera_obj.add_component<Camera>(Color::WHITE, ivec2{1080, 720}, vec2{2000, 2000}, 1.0f);
 
 	GameObject button_obj = mgr.new_object("body", "person", vec2{0, 0}, 0, 1);
 	auto s2 = Texture("asset/texture/test_ap43.png");
-- 
cgit v1.2.3


From d76ab0bf77d0a61712dc25bbe1760995be4c4782 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 4 Dec 2024 20:11:02 +0100
Subject: make format

---
 src/crepe/Collider.cpp               |   2 +-
 src/crepe/Collider.h                 |   2 +-
 src/crepe/api/BoxCollider.cpp        |   7 +-
 src/crepe/api/BoxCollider.h          |   6 +-
 src/crepe/api/CircleCollider.cpp     |   6 +-
 src/crepe/api/CircleCollider.h       |   3 +-
 src/crepe/api/Event.h                |   4 +-
 src/crepe/api/LoopManager.cpp        |   3 +-
 src/crepe/api/Rigidbody.cpp          |   4 +-
 src/crepe/api/Rigidbody.h            |   4 +-
 src/crepe/system/CollisionSystem.cpp | 514 ++++++++++++++++++++---------------
 src/crepe/system/CollisionSystem.h   | 121 +++++----
 src/crepe/system/PhysicsSystem.cpp   |   9 +-
 src/example/game.cpp                 |  97 ++++---
 src/test/CollisionTest.cpp           | 122 +++++----
 src/test/Profiling.cpp               | 121 +++++----
 16 files changed, 574 insertions(+), 451 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/Collider.cpp b/src/crepe/Collider.cpp
index 9d94152..77e11c8 100644
--- a/src/crepe/Collider.cpp
+++ b/src/crepe/Collider.cpp
@@ -2,4 +2,4 @@
 
 using namespace crepe;
 
-Collider::Collider(game_object_id_t id, const vec2& offset) : Component(id), offset(offset) {}
+Collider::Collider(game_object_id_t id, const vec2 & offset) : Component(id), offset(offset) {}
diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index b3a09fb..a08a68e 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -7,7 +7,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(game_object_id_t id, const vec2& offset);
+	Collider(game_object_id_t id, const vec2 & offset);
 
 public:
 	/**
diff --git a/src/crepe/api/BoxCollider.cpp b/src/crepe/api/BoxCollider.cpp
index f94ced7..c097a24 100644
--- a/src/crepe/api/BoxCollider.cpp
+++ b/src/crepe/api/BoxCollider.cpp
@@ -1,7 +1,10 @@
 #include "BoxCollider.h"
 
-#include "../Collider.h" 
+#include "../Collider.h"
 
 using namespace crepe;
 
-BoxCollider::BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions) : Collider(game_object_id,offset), dimensions(dimensions) {}
+BoxCollider::BoxCollider(game_object_id_t game_object_id, const vec2 & offset,
+						 const vec2 & dimensions)
+	: Collider(game_object_id, offset),
+	  dimensions(dimensions) {}
diff --git a/src/crepe/api/BoxCollider.h b/src/crepe/api/BoxCollider.h
index 1f5f1c1..89e43d8 100644
--- a/src/crepe/api/BoxCollider.h
+++ b/src/crepe/api/BoxCollider.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "Vector2.h"
 #include "../Collider.h"
+#include "Vector2.h"
 #include "types.h"
 
 namespace crepe {
@@ -13,9 +13,9 @@ namespace crepe {
  */
 class BoxCollider : public Collider {
 public:
-	BoxCollider(game_object_id_t game_object_id,const vec2& offset, const vec2& dimensions);
+	BoxCollider(game_object_id_t game_object_id, const vec2 & offset, const vec2 & dimensions);
 
-	//! Width and height of the box collider 
+	//! Width and height of the box collider
 	vec2 dimensions;
 };
 
diff --git a/src/crepe/api/CircleCollider.cpp b/src/crepe/api/CircleCollider.cpp
index 473734e..a4271e9 100644
--- a/src/crepe/api/CircleCollider.cpp
+++ b/src/crepe/api/CircleCollider.cpp
@@ -2,5 +2,7 @@
 
 using namespace crepe;
 
-
-CircleCollider::CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius) : Collider(game_object_id,offset), radius(radius) {}
+CircleCollider::CircleCollider(game_object_id_t game_object_id, const vec2 & offset,
+							   float radius)
+	: Collider(game_object_id, offset),
+	  radius(radius) {}
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index bbcc330..ebd1cb2 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -13,8 +13,7 @@ namespace crepe {
  */
 class CircleCollider : public Collider {
 public:
-
-	CircleCollider(game_object_id_t game_object_id,const vec2& offset, float radius);
+	CircleCollider(game_object_id_t game_object_id, const vec2 & offset, float radius);
 
 	//! Radius of the circle collider.
 	float radius;
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 259acba..152bc2c 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -98,8 +98,8 @@ public:
 class CollisionEvent : public Event {
 public:
 	crepe::CollisionSystem::CollisionInfo info;
-	CollisionEvent(const crepe::CollisionSystem::CollisionInfo& collisionInfo)
-        : info(collisionInfo) {}
+	CollisionEvent(const crepe::CollisionSystem::CollisionInfo & collisionInfo)
+		: info(collisionInfo) {}
 };
 
 /**
diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index feb1338..d4819ea 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -1,13 +1,12 @@
 #include "../facade/SDLContext.h"
 
+#include "../system/PhysicsSystem.h"
 #include "../system/AnimatorSystem.h"
 #include "../system/CollisionSystem.h"
 #include "../system/ParticleSystem.h"
 #include "../system/PhysicsSystem.h"
 #include "../system/RenderSystem.h"
 #include "../system/ScriptSystem.h"
-#include "..//system/PhysicsSystem.h"
-#include "../system/CollisionSystem.h"
 
 #include "LoopManager.h"
 #include "LoopTimer.h"
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index c4b1d6f..8213afb 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -10,6 +10,4 @@ void crepe::Rigidbody::add_force_linear(const vec2 & force) {
 	this->data.linear_velocity += force;
 }
 
-void crepe::Rigidbody::add_force_angular(float force) {
-	this->data.angular_velocity += force;
-}
+void crepe::Rigidbody::add_force_angular(float force) { this->data.angular_velocity += force; }
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index 431e000..756cc28 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -78,9 +78,9 @@ public:
 		//! Linear velocity of the object (speed and direction).
 		vec2 linear_velocity;
 		//! Maximum linear velocity of the object. This limits the object's speed.
-		vec2 max_linear_velocity = {INFINITY ,INFINITY};
+		vec2 max_linear_velocity = {INFINITY, INFINITY};
 		//! Linear velocity coefficient. This scales the object's velocity for adjustment or damping.
-		vec2 linear_velocity_coefficient = {1,1};
+		vec2 linear_velocity_coefficient = {1, 1};
 		//! \}
 
 		/**
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 2d5ce9d..34cd125 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -1,23 +1,23 @@
-#include <cmath>
 #include <algorithm>
+#include <cmath>
 #include <cstddef>
 #include <functional>
+#include <optional>
 #include <utility>
 #include <variant>
-#include <optional>
 
-#include "api/Event.h"
-#include "api/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Event.h"
+#include "api/EventManager.h"
 #include "api/Metadata.h"
-#include "api/Vector2.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
+#include "api/Vector2.h"
 
-#include "ComponentManager.h"
-#include "CollisionSystem.h"
 #include "Collider.h"
+#include "CollisionSystem.h"
+#include "ComponentManager.h"
 #include "types.h"
 #include "util/OptionalRef.h"
 
@@ -26,158 +26,191 @@ using namespace crepe;
 void CollisionSystem::update() {
 	std::vector<CollisionInternal> all_colliders;
 	game_object_id_t id = 0;
-	RefVector<Rigidbody> rigidbodies = this->component_manager.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies
+		= this->component_manager.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
-	for(Rigidbody& rigidbody : rigidbodies) {
+	for (Rigidbody & rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
-		Transform& transform = this->component_manager.get_components_by_id<Transform>(id).front().get();
+		Transform & transform
+			= this->component_manager.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders	= this->component_manager.get_components_by_type<BoxCollider>();
-		for (BoxCollider& boxcollider : boxcolliders) {
-			if(boxcollider.game_object_id != id) continue;
-			if(!boxcollider.active) continue;
-			all_colliders.push_back(
-				{
-					.id = id,
-				  .collider = collider_variant{boxcollider},
-					.transform = transform,
-					.rigidbody = rigidbody
-					}
-				);
+		RefVector<BoxCollider> boxcolliders
+			= this->component_manager.get_components_by_type<BoxCollider>();
+		for (BoxCollider & boxcollider : boxcolliders) {
+			if (boxcollider.game_object_id != id) continue;
+			if (!boxcollider.active) continue;
+			all_colliders.push_back({.id = id,
+									 .collider = collider_variant{boxcollider},
+									 .transform = transform,
+									 .rigidbody = rigidbody});
 		}
 		// Check if the circlecollider is active and has the same id as the rigidbody.
-		RefVector<CircleCollider> circlecolliders	= this->component_manager.get_components_by_type<CircleCollider>();
-		for (CircleCollider& circlecollider : circlecolliders) {
-			if(circlecollider.game_object_id != id) continue;
-			if(!circlecollider.active) continue;
-			all_colliders.push_back(
-				{
-					.id = id,
-				  .collider = collider_variant{circlecollider},
-					.transform = transform,
-					.rigidbody = rigidbody
-					}
-				);
+		RefVector<CircleCollider> circlecolliders
+			= this->component_manager.get_components_by_type<CircleCollider>();
+		for (CircleCollider & circlecollider : circlecolliders) {
+			if (circlecollider.game_object_id != id) continue;
+			if (!circlecollider.active) continue;
+			all_colliders.push_back({.id = id,
+									 .collider = collider_variant{circlecollider},
+									 .transform = transform,
+									 .rigidbody = rigidbody});
 		}
 	}
 
 	// Check between all colliders if there is a collision
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collided = this->gather_collisions(all_colliders);
+	std::vector<std::pair<CollisionInternal, CollisionInternal>> collided
+		= this->gather_collisions(all_colliders);
 
-	// For both objects call the collision handler 
-	for (auto& collision_pair : collided) {
-		this->collision_handler_request(collision_pair.first,collision_pair.second);
-		this->collision_handler_request(collision_pair.second,collision_pair.first);
+	// For both objects call the collision handler
+	for (auto & collision_pair : collided) {
+		this->collision_handler_request(collision_pair.first, collision_pair.second);
+		this->collision_handler_request(collision_pair.second, collision_pair.first);
 	}
 }
 
-void CollisionSystem::collision_handler_request(CollisionInternal& this_data,CollisionInternal& other_data){
+void CollisionSystem::collision_handler_request(CollisionInternal & this_data,
+												CollisionInternal & other_data) {
 
-	CollisionInternalType type = this->get_collider_type(this_data.collider,other_data.collider);
-	std::pair<vec2,CollisionSystem::Direction> resolution_data = this->collision_handler(this_data,other_data,type);
+	CollisionInternalType type
+		= this->get_collider_type(this_data.collider, other_data.collider);
+	std::pair<vec2, CollisionSystem::Direction> resolution_data
+		= this->collision_handler(this_data, other_data, type);
 
-	OptionalRef<Metadata> this_metadata = this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
-	OptionalRef<Metadata> other_metadata = this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
+	OptionalRef<Metadata> this_metadata
+		= this->component_manager.get_components_by_id<Metadata>(this_data.id).front().get();
+	OptionalRef<Metadata> other_metadata
+		= this->component_manager.get_components_by_id<Metadata>(other_data.id).front().get();
 	OptionalRef<Collider> this_collider;
 	OptionalRef<Collider> other_collider;
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:{
+		case CollisionInternalType::BOX_BOX: {
 			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::BOX_CIRCLE:{
+		case CollisionInternalType::BOX_CIRCLE: {
 			this_collider = std::get<std::reference_wrapper<BoxCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_BOX:{
-			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
+		case CollisionInternalType::CIRCLE_BOX: {
+			this_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(other_data.collider);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:{
-			this_collider = std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
-			other_collider = std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			this_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(this_data.collider);
+			other_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(other_data.collider);
 			break;
 		}
 	}
 
 	// collision info
 	crepe::CollisionSystem::CollisionInfo collision_info{
-						.this_collider = this_collider,
-						.this_transform = this_data.transform,
-						.this_rigidbody = this_data.rigidbody,
-						.this_metadata = this_metadata,
-						.other_collider = other_collider,
-						.other_transform = other_data.transform,
-						.other_rigidbody = other_data.rigidbody,
-						.other_metadata = other_metadata,
-						.resolution = resolution_data.first,
-						.resolution_direction = resolution_data.second,
-        };
+		.this_collider = this_collider,
+		.this_transform = this_data.transform,
+		.this_rigidbody = this_data.rigidbody,
+		.this_metadata = this_metadata,
+		.other_collider = other_collider,
+		.other_transform = other_data.transform,
+		.other_rigidbody = other_data.rigidbody,
+		.other_metadata = other_metadata,
+		.resolution = resolution_data.first,
+		.resolution_direction = resolution_data.second,
+	};
 
 	// Determine if static needs to be called
-	this->determine_collision_handler(collision_info);	
+	this->determine_collision_handler(collision_info);
 }
 
-
-std::pair<vec2,CollisionSystem::Direction> CollisionSystem::collision_handler(CollisionInternal& data1,CollisionInternal& data2,CollisionInternalType type) {
+std::pair<vec2, CollisionSystem::Direction>
+CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal & data2,
+								   CollisionInternalType type) {
 	vec2 resolution;
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:	{
-			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_box_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::BOX_BOX: {
+			const BoxCollider & collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			const BoxCollider & collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_box_box_resolution(collider1, collider2, collider_pos1,
+													  collider_pos2);
 			break;
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
-			const BoxCollider & collider1 = std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
-			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_box_resolution(collider2,collider1,collider_pos2,collider_pos1);
+			const BoxCollider & collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(data1.collider);
+			const CircleCollider & collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider2, collider1, collider_pos2,
+														 collider_pos1);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:	{
-			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			const CircleCollider & collider2 = std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_circle_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			const CircleCollider & collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			const CircleCollider & collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_circle_resolution(collider1, collider2,
+															collider_pos1, collider_pos2);
 			break;
 		}
-		case CollisionInternalType::CIRCLE_BOX:	{
-			const CircleCollider & collider1 = std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
-			const BoxCollider & collider2 = std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
-			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform, data1.rigidbody);
-			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform, data2.rigidbody);
-			resolution = this->get_circle_box_resolution(collider1,collider2,collider_pos1,collider_pos2);
+		case CollisionInternalType::CIRCLE_BOX: {
+			const CircleCollider & collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(data1.collider);
+			const BoxCollider & collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(data2.collider);
+			vec2 collider_pos1 = this->get_current_position(collider1.offset, data1.transform,
+															data1.rigidbody);
+			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
+															data2.rigidbody);
+			resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1,
+														 collider_pos2);
 			break;
 		}
 	}
 
 	Direction resolution_direction = Direction::NONE;
-	if(resolution.x != 0 && resolution.y > 0) {
+	if (resolution.x != 0 && resolution.y > 0) {
 		resolution_direction = Direction::BOTH;
 	} else if (resolution.x != 0) {
 		resolution_direction = Direction::X_DIRECTION;
-		if(data1.rigidbody.data.linear_velocity.y != 0)	
-		resolution.y = data1.rigidbody.data.linear_velocity.y * (resolution.x/data1.rigidbody.data.linear_velocity.x);
+		if (data1.rigidbody.data.linear_velocity.y != 0)
+			resolution.y = data1.rigidbody.data.linear_velocity.y
+						   * (resolution.x / data1.rigidbody.data.linear_velocity.x);
 	} else if (resolution.y != 0) {
 		resolution_direction = Direction::Y_DIRECTION;
-		if(data1.rigidbody.data.linear_velocity.x != 0) 
-		resolution.x = data1.rigidbody.data.linear_velocity.x * (resolution.y/data1.rigidbody.data.linear_velocity.y);
+		if (data1.rigidbody.data.linear_velocity.x != 0)
+			resolution.x = data1.rigidbody.data.linear_velocity.x
+						   * (resolution.y / data1.rigidbody.data.linear_velocity.y);
 	}
 
-	return std::make_pair(resolution,resolution_direction);
+	return std::make_pair(resolution, resolution_direction);
 }
 
-vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& final_position1,const vec2& final_position2) const
-{
+vec2 CollisionSystem::get_box_box_resolution(const BoxCollider & box_collider1,
+											 const BoxCollider & box_collider2,
+											 const vec2 & final_position1,
+											 const vec2 & final_position2) const {
 	vec2 resolution; // Default resolution vector
 	vec2 delta = final_position2 - final_position1;
 
@@ -210,97 +243,107 @@ vec2 CollisionSystem::get_box_box_resolution(const BoxCollider& box_collider1,co
 	return resolution;
 }
 
-vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const 
-{
-    vec2 delta = final_position2 - final_position1;
+vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle_collider1,
+												   const CircleCollider & circle_collider2,
+												   const vec2 & final_position1,
+												   const vec2 & final_position2) const {
+	vec2 delta = final_position2 - final_position1;
 
-    // Compute the distance between the two circle centers
-    float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y);
+	// Compute the distance between the two circle centers
+	float distance = std::sqrt(delta.x * delta.x + delta.y * delta.y);
 
-    // Compute the combined radii of the two circles
-    float combined_radius = circle_collider1.radius + circle_collider2.radius;
+	// Compute the combined radii of the two circles
+	float combined_radius = circle_collider1.radius + circle_collider2.radius;
 
-    // Compute the penetration depth
-    float penetration_depth = combined_radius - distance;
+	// Compute the penetration depth
+	float penetration_depth = combined_radius - distance;
 
-    // Normalize the delta vector to get the collision direction
-    vec2 collision_normal = delta / distance;
+	// Normalize the delta vector to get the collision direction
+	vec2 collision_normal = delta / distance;
 
-    // Compute the resolution vector
-    vec2 resolution = collision_normal * penetration_depth;
+	// Compute the resolution vector
+	vec2 resolution = collision_normal * penetration_depth;
 
-    return resolution;
+	return resolution;
 }
 
-vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const 
-{
-    vec2 delta = circle_position - box_position;
+vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider,
+												const BoxCollider & box_collider,
+												const vec2 & circle_position,
+												const vec2 & box_position) const {
+	vec2 delta = circle_position - box_position;
 
-    // Compute half-dimensions of the box
-    float half_width = box_collider.dimensions.x / 2.0f;
-    float half_height = box_collider.dimensions.y / 2.0f;
+	// Compute half-dimensions of the box
+	float half_width = box_collider.dimensions.x / 2.0f;
+	float half_height = box_collider.dimensions.y / 2.0f;
 
-    // Clamp circle center to the nearest point on the box
-    vec2 closest_point;
-    closest_point.x = std::clamp(delta.x, -half_width, half_width);
-    closest_point.y = std::clamp(delta.y, -half_height, half_height);
+	// Clamp circle center to the nearest point on the box
+	vec2 closest_point;
+	closest_point.x = std::clamp(delta.x, -half_width, half_width);
+	closest_point.y = std::clamp(delta.y, -half_height, half_height);
 
-    // Find the vector from the circle center to the closest point
-    vec2 closest_delta = delta - closest_point;
+	// Find the vector from the circle center to the closest point
+	vec2 closest_delta = delta - closest_point;
 
-    // Normalize the delta to get the collision direction
-    float distance = std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y);
-    vec2 collision_normal = closest_delta / distance;
+	// Normalize the delta to get the collision direction
+	float distance
+		= std::sqrt(closest_delta.x * closest_delta.x + closest_delta.y * closest_delta.y);
+	vec2 collision_normal = closest_delta / distance;
 
-    // Compute penetration depth
-    float penetration_depth = circle_collider.radius - distance;
+	// Compute penetration depth
+	float penetration_depth = circle_collider.radius - distance;
 
-    // Compute the resolution vector
-    vec2 resolution = collision_normal * penetration_depth;
+	// Compute the resolution vector
+	vec2 resolution = collision_normal * penetration_depth;
 
-    return resolution;
+	return resolution;
 }
 
-
-void CollisionSystem::determine_collision_handler(CollisionInfo& info){
+void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
 	// Check rigidbody type for static
-	if(info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
+	if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
 	// If second body is static perform the static collision handler in this system
-	if(info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC){
+	if (info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) {
 		static_collision_handler(info);
-	}; 
+	};
 	// Call collision event for user
 	CollisionEvent data(info);
-	EventManager::get_instance().trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
+	EventManager::get_instance().trigger_event<CollisionEvent>(
+		data, info.this_collider.game_object_id);
 }
 
-void CollisionSystem::static_collision_handler(CollisionInfo& info){
-	// Move object back using calculate move back value 
+void CollisionSystem::static_collision_handler(CollisionInfo & info) {
+	// Move object back using calculate move back value
 	info.this_transform.position += info.resolution;
 
 	// If bounce is enabled mirror velocity
-	if(info.this_rigidbody.data.elastisity_coefficient > 0) {
-		if(info.resolution_direction == Direction::BOTH)
-		{
-			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
-			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
-		}
-		else if(info.resolution_direction == Direction::Y_DIRECTION) {
-			info.this_rigidbody.data.linear_velocity.y = -info.this_rigidbody.data.linear_velocity.y * info.this_rigidbody.data.elastisity_coefficient;
-		}
-		else if(info.resolution_direction == Direction::X_DIRECTION){
-			info.this_rigidbody.data.linear_velocity.x = -info.this_rigidbody.data.linear_velocity.x * info.this_rigidbody.data.elastisity_coefficient;
+	if (info.this_rigidbody.data.elastisity_coefficient > 0) {
+		if (info.resolution_direction == Direction::BOTH) {
+			info.this_rigidbody.data.linear_velocity.y
+				= -info.this_rigidbody.data.linear_velocity.y
+				  * info.this_rigidbody.data.elastisity_coefficient;
+			info.this_rigidbody.data.linear_velocity.x
+				= -info.this_rigidbody.data.linear_velocity.x
+				  * info.this_rigidbody.data.elastisity_coefficient;
+		} else if (info.resolution_direction == Direction::Y_DIRECTION) {
+			info.this_rigidbody.data.linear_velocity.y
+				= -info.this_rigidbody.data.linear_velocity.y
+				  * info.this_rigidbody.data.elastisity_coefficient;
+		} else if (info.resolution_direction == Direction::X_DIRECTION) {
+			info.this_rigidbody.data.linear_velocity.x
+				= -info.this_rigidbody.data.linear_velocity.x
+				  * info.this_rigidbody.data.elastisity_coefficient;
 		}
 	}
 	// Stop movement if bounce is disabled
 	else {
-		info.this_rigidbody.data.linear_velocity = {0,0};
+		info.this_rigidbody.data.linear_velocity = {0, 0};
 	}
 }
 
-std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::CollisionInternal>> CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
-	
-	
+std::vector<std::pair<CollisionSystem::CollisionInternal, CollisionSystem::CollisionInternal>>
+CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
+
 	// TODO:
 	// If no colliders skip
 	// Check if colliders has rigidbody if not skip
@@ -311,83 +354,103 @@ std::vector<std::pair<CollisionSystem::CollisionInternal,CollisionSystem::Collis
 	// Quadtree is placed over the input vector
 
 	// Return data of collided colliders which are variants
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> collisions_ret;
-	//using visit to visit the variant to access the active and id.  
+	std::vector<std::pair<CollisionInternal, CollisionInternal>> collisions_ret;
+	//using visit to visit the variant to access the active and id.
 	for (size_t i = 0; i < colliders.size(); ++i) {
 		for (size_t j = i + 1; j < colliders.size(); ++j) {
-			if(colliders[i].id == colliders[j].id) continue;
-				CollisionInternalType type = get_collider_type(colliders[i].collider,colliders[j].collider);
-				if(!get_collision({
-					.collider = colliders[i].collider,
-					.transform = colliders[i].transform,
-					.rigidbody = colliders[i].rigidbody,
+			if (colliders[i].id == colliders[j].id) continue;
+			CollisionInternalType type
+				= get_collider_type(colliders[i].collider, colliders[j].collider);
+			if (!get_collision(
+					{
+						.collider = colliders[i].collider,
+						.transform = colliders[i].transform,
+						.rigidbody = colliders[i].rigidbody,
 					},
 					{
-					.collider = colliders[j].collider,
-					.transform = colliders[j].transform,
-					.rigidbody = colliders[j].rigidbody,
+						.collider = colliders[j].collider,
+						.transform = colliders[j].transform,
+						.rigidbody = colliders[j].rigidbody,
 					},
-					type)) continue;
-				collisions_ret.emplace_back(colliders[i],colliders[j]);
+					type))
+				continue;
+			collisions_ret.emplace_back(colliders[i], colliders[j]);
 		}
 	}
-	
+
 	return collisions_ret;
 }
 
-CollisionSystem::CollisionInternalType CollisionSystem::get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const{
-	if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)){
-		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
-		{
+CollisionSystem::CollisionInternalType
+CollisionSystem::get_collider_type(const collider_variant & collider1,
+								   const collider_variant & collider2) const {
+	if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider1)) {
+		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
 			return CollisionInternalType::CIRCLE_CIRCLE;
-		}
-		else {
+		} else {
 			return CollisionInternalType::CIRCLE_BOX;
 		}
-	}
-	else {
-		if(std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2))
-		{
+	} else {
+		if (std::holds_alternative<std::reference_wrapper<CircleCollider>>(collider2)) {
 			return CollisionInternalType::BOX_CIRCLE;
-		}
-		else {
+		} else {
 			return CollisionInternalType::BOX_BOX;
 		}
 	}
 }
 
-bool CollisionSystem::get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const{
+bool CollisionSystem::get_collision(const CollisionInternal & first_info,
+									const CollisionInternal & second_info,
+									CollisionInternalType type) const {
 	switch (type) {
-		case CollisionInternalType::BOX_BOX:	{
-			const BoxCollider & box_collider1 = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
-			const BoxCollider & box_collider2 = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return this->get_box_box_collision(box_collider1,box_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::BOX_BOX: {
+			const BoxCollider & box_collider1
+				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const BoxCollider & box_collider2
+				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return this->get_box_box_collision(box_collider1, box_collider2,
+											   first_info.transform, second_info.transform,
+											   second_info.rigidbody, second_info.rigidbody);
 		}
 		case CollisionInternalType::BOX_CIRCLE: {
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+			const BoxCollider & box_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(first_info.collider);
+			const CircleCollider & circle_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return this->get_box_circle_collision(
+				box_collider, circle_collider, first_info.transform, second_info.transform,
+				second_info.rigidbody, second_info.rigidbody);
 		}
-		case CollisionInternalType::CIRCLE_CIRCLE:	{
-			const CircleCollider & circle_collider1 = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
-			const CircleCollider & circle_collider2 = std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
-			return this->get_circle_circle_collision(circle_collider1,circle_collider2,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::CIRCLE_CIRCLE: {
+			const CircleCollider & circle_collider1
+				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const CircleCollider & circle_collider2
+				= std::get<std::reference_wrapper<CircleCollider>>(second_info.collider);
+			return this->get_circle_circle_collision(
+				circle_collider1, circle_collider2, first_info.transform,
+				second_info.transform, second_info.rigidbody, second_info.rigidbody);
 		}
-		case CollisionInternalType::CIRCLE_BOX:	{
-			const CircleCollider & circle_collider = std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
-			const BoxCollider & box_collider = std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
-			return this->get_box_circle_collision(box_collider,circle_collider,first_info.transform,second_info.transform,second_info.rigidbody,second_info.rigidbody);
+		case CollisionInternalType::CIRCLE_BOX: {
+			const CircleCollider & circle_collider
+				= std::get<std::reference_wrapper<CircleCollider>>(first_info.collider);
+			const BoxCollider & box_collider
+				= std::get<std::reference_wrapper<BoxCollider>>(second_info.collider);
+			return this->get_box_circle_collision(
+				box_collider, circle_collider, first_info.transform, second_info.transform,
+				second_info.rigidbody, second_info.rigidbody);
 		}
 	}
 	return false;
 }
 
-
-bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const
-{
+bool CollisionSystem::get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2,
+											const Transform & transform1,
+											const Transform & transform2,
+											const Rigidbody & rigidbody1,
+											const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = this->get_current_position(box1.offset,transform1,rigidbody1);
-	vec2 final_position2 = this->get_current_position(box2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(box2.offset, transform2, rigidbody2);
 
 	// Calculate half-extents (half width and half height)
 	float half_width1 = box1.dimensions.x / 2.0;
@@ -396,13 +459,18 @@ bool CollisionSystem::get_box_box_collision(const BoxCollider& box1, const BoxCo
 	float half_height2 = box2.dimensions.y / 2.0;
 
 	// Check if the boxes overlap along the X and Y axes
-	return (final_position1.x + half_width1 > final_position2.x - half_width2 &&
-        final_position1.x - half_width1 < final_position2.x + half_width2 &&
-        final_position1.y + half_height1 > final_position2.y - half_height2 &&
-        final_position1.y - half_height1 < final_position2.y + half_height2);
+	return (final_position1.x + half_width1 > final_position2.x - half_width2
+			&& final_position1.x - half_width1 < final_position2.x + half_width2
+			&& final_position1.y + half_height1 > final_position2.y - half_height2
+			&& final_position1.y - half_height1 < final_position2.y + half_height2);
 }
 
-bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
+bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1,
+											   const CircleCollider & circle2,
+											   const Transform & transform1,
+											   const Transform & transform2,
+											   const Rigidbody & rigidbody1,
+											   const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
 	vec2 final_position1 = this->get_current_position(box1.offset, transform1, rigidbody1);
 	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
@@ -412,8 +480,10 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 	float half_height = box1.dimensions.y / 2.0;
 
 	// Find the closest point on the box to the circle's center
-	float closest_x = std::max(final_position1.x - half_width, std::min(final_position2.x, final_position1.x + half_width));
-	float closest_y = std::max(final_position1.y - half_height, std::min(final_position2.y, final_position1.y + half_height));
+	float closest_x = std::max(final_position1.x - half_width,
+							   std::min(final_position2.x, final_position1.x + half_width));
+	float closest_y = std::max(final_position1.y - half_height,
+							   std::min(final_position2.y, final_position1.y + half_height));
 
 	// Calculate the distance squared between the circle's center and the closest point on the box
 	float distance_x = final_position2.x - closest_x;
@@ -424,10 +494,15 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider& box1, const Ci
 	return distance_squared <= circle2.radius * circle2.radius;
 }
 
-bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const {
+bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1,
+												  const CircleCollider & circle2,
+												  const Transform & transform1,
+												  const Transform & transform2,
+												  const Rigidbody & rigidbody1,
+												  const Rigidbody & rigidbody2) const {
 	// Get current positions of colliders
-	vec2 final_position1 = this->get_current_position(circle1.offset,transform1,rigidbody1);
-	vec2 final_position2 = this->get_current_position(circle2.offset,transform2,rigidbody2);
+	vec2 final_position1 = this->get_current_position(circle1.offset, transform1, rigidbody1);
+	vec2 final_position2 = this->get_current_position(circle2.offset, transform2, rigidbody2);
 
 	float distance_x = final_position1.x - final_position2.x;
 	float distance_y = final_position1.y - final_position2.y;
@@ -440,7 +515,9 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider& circle1,
 	return distance_squared <= radius_sum * radius_sum;
 }
 
-vec2 CollisionSystem::get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const {
+vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
+										   const Transform & transform,
+										   const Rigidbody & rigidbody) const {
 	// Get the rotation in radians
 	float radians1 = transform.rotation * (M_PI / 180.0);
 
@@ -448,10 +525,11 @@ vec2 CollisionSystem::get_current_position(const vec2& collider_offset, const Tr
 	vec2 total_offset = (rigidbody.data.offset + collider_offset) * transform.scale;
 
 	// Rotate
-	float rotated_total_offset_x1 = total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
-	float rotated_total_offset_y1 = total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
+	float rotated_total_offset_x1
+		= total_offset.x * cos(radians1) - total_offset.y * sin(radians1);
+	float rotated_total_offset_y1
+		= total_offset.x * sin(radians1) + total_offset.y * cos(radians1);
 
 	// Final positions considering scaling and rotation
-	return(transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
-
+	return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 }
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 85ae5ad..6b5a4bb 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -1,38 +1,37 @@
 #pragma once
 
-#include <vector>
-#include <variant>
 #include <optional>
+#include <variant>
+#include <vector>
 
-#include "api/Rigidbody.h"
-#include "api/Transform.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Metadata.h"
+#include "api/Rigidbody.h"
+#include "api/Transform.h"
 #include "api/Vector2.h"
 
 #include "Collider.h"
 #include "System.h"
 
-
 namespace crepe {
 
-
 //! A system responsible for detecting and handling collisions between colliders.
 class CollisionSystem : public System {
 public:
 	using System::System;
+
 private:
-	
 	//! A variant type that can hold either a BoxCollider or a CircleCollider.
-	using collider_variant = std::variant<std::reference_wrapper<BoxCollider>, std::reference_wrapper<CircleCollider>>;
+	using collider_variant = std::variant<std::reference_wrapper<BoxCollider>,
+										  std::reference_wrapper<CircleCollider>>;
 
 	//! Enum representing the types of collider pairs for collision detection.
 	enum class CollisionInternalType {
-    BOX_BOX,
-    CIRCLE_CIRCLE,
-    BOX_CIRCLE,
-    CIRCLE_BOX,
+		BOX_BOX,
+		CIRCLE_CIRCLE,
+		BOX_CIRCLE,
+		CIRCLE_BOX,
 	};
 
 	/**
@@ -45,21 +44,21 @@ private:
 		*/
 	struct CollisionInternal {
 		game_object_id_t id = 0;
-		collider_variant collider; 
-		Transform& transform;
-		Rigidbody& rigidbody;
+		collider_variant collider;
+		Transform & transform;
+		Rigidbody & rigidbody;
 	};
-	
+
 	//! Enum representing movement directions during collision resolution.
 	enum class Direction {
 		//! No movement required.
-    NONE,
+		NONE,
 		//! Movement in the X direction.
-    X_DIRECTION,
+		X_DIRECTION,
 		//! Movement in the Y direction.
-    Y_DIRECTION,
+		Y_DIRECTION,
 		//! Movement in both X and Y directions.
-    BOTH
+		BOTH
 	};
 
 public:
@@ -68,15 +67,15 @@ public:
 		* 
 		* Includes information about the colliding objects and the resolution data for handling the collision.
 		*/
-	struct CollisionInfo{
-    Collider& this_collider;
-		Transform& this_transform;
-		Rigidbody& this_rigidbody;
-		Metadata& this_metadata;
-    Collider& other_collider;
-		Transform& other_transform;
-		Rigidbody& other_rigidbody;
-		Metadata& other_metadata;
+	struct CollisionInfo {
+		Collider & this_collider;
+		Transform & this_transform;
+		Rigidbody & this_rigidbody;
+		Metadata & this_metadata;
+		Collider & other_collider;
+		Transform & other_transform;
+		Rigidbody & other_rigidbody;
+		Metadata & other_metadata;
 		//! The resolution vector for the collision.
 		vec2 resolution;
 		//! The direction of movement for resolving the collision.
@@ -84,11 +83,10 @@ public:
 	};
 
 public:
-
 	//! Updates the collision system by checking for collisions between colliders and handling them.
 	void update() override;
-private:
 
+private:
 	/**
 		* \brief Determines the type of collider pair from two colliders.
 		* 
@@ -98,7 +96,8 @@ private:
 		* \param collider2 Second collider variant (BoxCollider or CircleCollider).
 		* \return The combined type of the two colliders.
 		*/
-	CollisionInternalType get_collider_type(const collider_variant& collider1,const collider_variant& collider2) const;
+	CollisionInternalType get_collider_type(const collider_variant & collider1,
+											const collider_variant & collider2) const;
 
 	/**
 		* \brief Calculates the current position of a collider.
@@ -110,10 +109,10 @@ private:
 		* \param rigidbody The Rigidbody of the associated game object.
 		* \return The calculated position of the collider.
 		*/
-	vec2 get_current_position(const vec2& collider_offset, const Transform& transform, const Rigidbody& rigidbody) const;
+	vec2 get_current_position(const vec2 & collider_offset, const Transform & transform,
+							  const Rigidbody & rigidbody) const;
 
 private:
-
 	/**
 		* \brief Handles collision resolution between two colliders.
 		* 
@@ -122,7 +121,7 @@ private:
 		* \param data1 Collision data for the first collider.
 		* \param data2 Collision data for the second collider.
 		*/
-	void collision_handler_request(CollisionInternal& data1,CollisionInternal& data2);
+	void collision_handler_request(CollisionInternal & data1, CollisionInternal & data2);
 
 	/**
 		* \brief Resolves collision between two colliders and calculates the movement required.
@@ -134,7 +133,9 @@ private:
 		* \param type The type of collider pair.
 		* \return A pair containing the resolution vector and direction for the first collider.
 		*/
-	std::pair<vec2,Direction> collision_handler(CollisionInternal& data1,CollisionInternal& data2 ,CollisionInternalType type);
+	std::pair<vec2, Direction> collision_handler(CollisionInternal & data1,
+												 CollisionInternal & data2,
+												 CollisionInternalType type);
 
 	/**
 		* \brief Calculates the resolution vector for two BoxColliders.
@@ -147,7 +148,9 @@ private:
 		* \param position2 The position of the second BoxCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_box_box_resolution(const BoxCollider& box_collider1,const BoxCollider& box_collider2,const vec2& position1,const vec2& position2) const;
+	vec2 get_box_box_resolution(const BoxCollider & box_collider1,
+								const BoxCollider & box_collider2, const vec2 & position1,
+								const vec2 & position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -160,7 +163,10 @@ private:
 		* \param position2 The position of the second CircleCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_circle_resolution(const CircleCollider& circle_collider1, const CircleCollider& circle_collider2, const vec2& final_position1, const vec2& final_position2) const;
+	vec2 get_circle_circle_resolution(const CircleCollider & circle_collider1,
+									  const CircleCollider & circle_collider2,
+									  const vec2 & final_position1,
+									  const vec2 & final_position2) const;
 
 	/**
 		* \brief Calculates the resolution vector for two CircleCollider.
@@ -173,7 +179,10 @@ private:
 		* \param box_position The position of the BocCollider.
 		* \return The resolution vector for the collision.
 		*/
-	vec2 get_circle_box_resolution(const CircleCollider& circle_collider, const BoxCollider& box_collider, const vec2& circle_position, const vec2& box_position) const;
+	vec2 get_circle_box_resolution(const CircleCollider & circle_collider,
+								   const BoxCollider & box_collider,
+								   const vec2 & circle_position,
+								   const vec2 & box_position) const;
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
@@ -182,7 +191,7 @@ private:
 		* 
 		* \param info Collision information containing data about both colliders.
 		*/
-	void determine_collision_handler(CollisionInfo& info);
+	void determine_collision_handler(CollisionInfo & info);
 
 	/**
 		* \brief Handles collisions involving static objects.
@@ -191,9 +200,9 @@ private:
 		* 
 		* \param info Collision information containing data about both colliders.
 		*/
-	void static_collision_handler(CollisionInfo& info);
+	void static_collision_handler(CollisionInfo & info);
+
 private:
-	
 	/**
 		* \brief Checks for collisions between colliders.
 		* 
@@ -202,7 +211,8 @@ private:
 		* \param colliders A collection of all active colliders.
 		* \return A list of collision pairs with their associated data.
 		*/
-	std::vector<std::pair<CollisionInternal,CollisionInternal>> gather_collisions(std::vector<CollisionInternal> & colliders);
+	std::vector<std::pair<CollisionInternal, CollisionInternal>>
+	gather_collisions(std::vector<CollisionInternal> & colliders);
 
 	/**
 		* \brief Checks for collision between two colliders.
@@ -214,8 +224,10 @@ private:
 		* \param type The type of collider pair.
 		* \return True if a collision is detected, otherwise false.
 		*/
-	bool get_collision(const CollisionInternal& first_info,const CollisionInternal& second_info, CollisionInternalType type) const;
-	
+	bool get_collision(const CollisionInternal & first_info,
+					   const CollisionInternal & second_info,
+					   CollisionInternalType type) const;
+
 	/**
 		* \brief Detects collisions between two BoxColliders.
 		* 
@@ -227,8 +239,11 @@ private:
 		* \param rigidbody2 Rigidbody of the second object.
 		* \return True if a collision is detected, otherwise false.
 		*/
-	bool get_box_box_collision(const BoxCollider& box1, const BoxCollider& box2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
-	
+	bool get_box_box_collision(const BoxCollider & box1, const BoxCollider & box2,
+							   const Transform & transform1, const Transform & transform2,
+							   const Rigidbody & rigidbody1,
+							   const Rigidbody & rigidbody2) const;
+
 	/**
 	 * \brief Check collision for box on circle collider
 	 *
@@ -240,7 +255,10 @@ private:
 	 * \param rigidbody2 Rigidbody of the second object.
 	 * \return True if a collision is detected, otherwise false.
 	 */
-	bool get_box_circle_collision(const BoxCollider& box1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
+	bool get_box_circle_collision(const BoxCollider & box1, const CircleCollider & circle2,
+								  const Transform & transform1, const Transform & transform2,
+								  const Rigidbody & rigidbody1,
+								  const Rigidbody & rigidbody2) const;
 
 	/**
 	 * \brief Check collision for circle on circle collider
@@ -255,7 +273,12 @@ private:
 	 *
 	 * \return status of collision
 	 */
-	bool get_circle_circle_collision(const CircleCollider& circle1, const CircleCollider& circle2, const Transform& transform1, const Transform& transform2, const Rigidbody& rigidbody1, const Rigidbody& rigidbody2) const;
+	bool get_circle_circle_collision(const CircleCollider & circle1,
+									 const CircleCollider & circle2,
+									 const Transform & transform1,
+									 const Transform & transform2,
+									 const Rigidbody & rigidbody1,
+									 const Rigidbody & rigidbody2) const;
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/PhysicsSystem.cpp b/src/crepe/system/PhysicsSystem.cpp
index b5da042..b3adfa1 100644
--- a/src/crepe/system/PhysicsSystem.cpp
+++ b/src/crepe/system/PhysicsSystem.cpp
@@ -32,10 +32,13 @@ void PhysicsSystem::update() {
 						}
 						// Add damping
 						if (rigidbody.data.angular_velocity_coefficient > 0) {
-							rigidbody.data.angular_velocity *= rigidbody.data.angular_velocity_coefficient;
+							rigidbody.data.angular_velocity
+								*= rigidbody.data.angular_velocity_coefficient;
 						}
-						if (rigidbody.data.linear_velocity_coefficient.x > 0 && rigidbody.data.linear_velocity_coefficient.y > 0) {
-							rigidbody.data.linear_velocity *= rigidbody.data.linear_velocity_coefficient;
+						if (rigidbody.data.linear_velocity_coefficient.x > 0
+							&& rigidbody.data.linear_velocity_coefficient.y > 0) {
+							rigidbody.data.linear_velocity
+								*= rigidbody.data.linear_velocity_coefficient;
 						}
 
 						// Max velocity check
diff --git a/src/example/game.cpp b/src/example/game.cpp
index de08a22..70c562e 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -1,77 +1,84 @@
-#include <crepe/api/GameObject.h>
-#include <crepe/api/Transform.h>
-#include <crepe/api/Rigidbody.h>
 #include <crepe/api/BoxCollider.h>
 #include <crepe/api/Camera.h>
-#include <crepe/api/Script.h>
 #include <crepe/api/Color.h>
-#include <crepe/api/Sprite.h>
-#include <crepe/api/Texture.h>
-#include <crepe/api/Vector2.h>
 #include <crepe/api/Event.h>
 #include <crepe/api/EventManager.h>
+#include <crepe/api/GameObject.h>
 #include <crepe/api/LoopManager.h>
+#include <crepe/api/Rigidbody.h>
+#include <crepe/api/Script.h>
+#include <crepe/api/Sprite.h>
+#include <crepe/api/Texture.h>
+#include <crepe/api/Transform.h>
+#include <crepe/api/Vector2.h>
 
 using namespace crepe;
 
 using namespace std;
 
 class MyScript : public Script {
-	bool oncollision(const CollisionEvent& test) {
+	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);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
 };
 
-
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
 
 	void load_scene() {
-	ComponentManager & mgr = this->component_manager;
-	Color color(0, 0, 0, 255);
+		ComponentManager & mgr = this->component_manager;
+		Color color(0, 0, 0, 255);
 
-	float screen_size_width = 640;
-	float screen_size_height = 480;
-	float world_collider = 1000;
-	//define playable world 
-	GameObject world = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	world.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 0,
-		.gravity_scale = 0,
-		.body_type = Rigidbody::BodyType::STATIC,
-		.constraints = {0, 0, 0},
-		.offset = {0,0}
-	});
-	world.add_component<BoxCollider>(vec2{0, 0-(screen_size_height/2+world_collider/2)}, vec2{world_collider, world_collider});;	// Top
-	world.add_component<BoxCollider>(vec2{0, screen_size_height/2+world_collider/2}, vec2{world_collider, world_collider}); // Bottom
-	world.add_component<BoxCollider>(vec2{0-(screen_size_width/2+world_collider/2), 0}, vec2{world_collider, world_collider}); // Left
-	world.add_component<BoxCollider>(vec2{screen_size_width/2+world_collider/2, 0}, vec2{world_collider, world_collider}); // right
-	world.add_component<Camera>(Color::WHITE, ivec2{640, 480},vec2{640, 480}, 1.0f);
+		float screen_size_width = 640;
+		float screen_size_height = 480;
+		float world_collider = 1000;
+		//define playable world
+		GameObject world = mgr.new_object(
+			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
+		world.add_component<Rigidbody>(
+			Rigidbody::Data{.mass = 0,
+							.gravity_scale = 0,
+							.body_type = Rigidbody::BodyType::STATIC,
+							.constraints = {0, 0, 0},
+							.offset = {0, 0}});
+		world.add_component<BoxCollider>(
+			vec2{0, 0 - (screen_size_height / 2 + world_collider / 2)},
+			vec2{world_collider, world_collider});
+		; // Top
+		world.add_component<BoxCollider>(vec2{0, screen_size_height / 2 + world_collider / 2},
+										 vec2{world_collider, world_collider}); // Bottom
+		world.add_component<BoxCollider>(
+			vec2{0 - (screen_size_width / 2 + world_collider / 2), 0},
+			vec2{world_collider, world_collider}); // Left
+		world.add_component<BoxCollider>(vec2{screen_size_width / 2 + world_collider / 2, 0},
+										 vec2{world_collider, world_collider}); // right
+		world.add_component<Camera>(Color::WHITE, ivec2{640, 480}, vec2{640, 480}, 1.0f);
 
-	GameObject game_object1 = mgr.new_object("Name", "Tag", vec2{screen_size_width/2, screen_size_height/2}, 0, 1);
-	game_object1.add_component<Rigidbody>(Rigidbody::Data{
-		.mass = 1,
-		.gravity_scale = 0.01,
-		.body_type = Rigidbody::BodyType::DYNAMIC,
-		.linear_velocity = {1,1},
-		.constraints = {0, 0, 0},
-		.elastisity_coefficient = 1,
-		.offset = {0,0},
-	});
-	game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
-	game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-	auto img = Texture("asset/texture/green_square.png");
-	game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1, 1, 20);
+		GameObject game_object1 = mgr.new_object(
+			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
+		game_object1.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 1,
+			.gravity_scale = 0.01,
+			.body_type = Rigidbody::BodyType::DYNAMIC,
+			.linear_velocity = {1, 1},
+			.constraints = {0, 0, 0},
+			.elastisity_coefficient = 1,
+			.offset = {0, 0},
+		});
+		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
+		game_object1.add_component<BehaviorScript>().set_script<MyScript>();
+		auto img = Texture("asset/texture/green_square.png");
+		game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1,
+										   1, 20);
 	}
 
 	string get_name() const { return "scene1"; }
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index fec42f3..74edaf7 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -26,22 +26,19 @@ using namespace testing;
 class CollisionHandler : public Script {
 public:
 	int box_id;
-	function<void(const CollisionEvent& ev)> test_fn = [](const CollisionEvent & ev) { };
+	function<void(const CollisionEvent & ev)> test_fn = [](const CollisionEvent & ev) {};
 
-	CollisionHandler(int box_id) {
-		this->box_id = box_id;
-	}
+	CollisionHandler(int box_id) { this->box_id = box_id; }
 
-	bool on_collision(const CollisionEvent& ev) {
+	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);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->on_collision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
@@ -54,18 +51,18 @@ public:
 	CollisionSystem collision_sys{mgr};
 	ScriptSystem script_sys{mgr};
 
-	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});
+	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},
+			.offset = {0, 0},
 		});
 		// Create a box with an inner size of 10x10 units
 		world.add_component<BoxCollider>(vec2{0, -100}, vec2{100, 100}); // Top
@@ -77,28 +74,30 @@ public:
 			.mass = 1,
 			.gravity_scale = 0.01,
 			.body_type = Rigidbody::BodyType::DYNAMIC,
-			.linear_velocity = {0,0},
+			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
 			.elastisity_coefficient = 1,
-			.offset = {0,0},
+			.offset = {0, 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());
+		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},
+			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
 			.elastisity_coefficient = 1,
-			.offset = {0,0},
+			.offset = {0, 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());
+		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
@@ -139,7 +138,7 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both_no_velocity) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	tf.position = {50, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -151,18 +150,20 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction_no_velocity) {
 		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);
+		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_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};
+	tf.position = {45, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -174,18 +175,20 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction_no_velocity) {
 		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);
+		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_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};
+	tf.position = {50, 25};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -208,11 +211,11 @@ TEST_F(CollisionTest, collision_box_box_dynamic_both) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	tf.position = {50, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	rg2.data.linear_velocity = {10, 10};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -224,22 +227,24 @@ TEST_F(CollisionTest, collision_box_box_dynamic_x_direction) {
 		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);
+		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_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};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	rg2.data.linear_velocity = {10, 10};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
@@ -251,27 +256,28 @@ TEST_F(CollisionTest, collision_box_box_dynamic_y_direction) {
 		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);
+		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_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};
+	tf.position = {50, 25};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	rg1.data.linear_velocity = {10, 10};
 	Rigidbody & rg2 = this->mgr.get_components_by_id<Rigidbody>(2).front().get();
-	rg2.data.linear_velocity = {10,10};
+	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) {
@@ -287,7 +293,7 @@ TEST_F(CollisionTest, collision_box_box_static_both) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,30};
+	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();
@@ -301,7 +307,8 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) {
 		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);
+		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
@@ -309,9 +316,9 @@ TEST_F(CollisionTest, collision_box_box_static_x_direction) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	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();
@@ -325,7 +332,8 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) {
 		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);
+		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
@@ -333,24 +341,24 @@ TEST_F(CollisionTest, collision_box_box_static_y_direction) {
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {50,25};
+	tf.position = {50, 25};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	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
+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);
+		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
@@ -358,20 +366,20 @@ TEST_F(CollisionTest, collision_box_box_static_multiple) {//todo check visually
 	};
 	EXPECT_FALSE(collision_happend);
 	Transform & tf = this->mgr.get_components_by_id<Transform>(1).front().get();
-	tf.position = {45,30};
+	tf.position = {45, 30};
 	Rigidbody & rg1 = this->mgr.get_components_by_id<Rigidbody>(1).front().get();
-	rg1.data.linear_velocity = {10,10};
+	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};
+	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};
+	tf.position = {55, 30};
 	collision_sys.update();
 	EXPECT_TRUE(collision_happend);
 }
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index fa0f5f3..d2f219e 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -1,8 +1,8 @@
 #include "system/ParticleSystem.h"
 #include "system/PhysicsSystem.h"
 #include "system/RenderSystem.h"
-#include <cmath>
 #include <chrono>
+#include <cmath>
 #include <gtest/gtest.h>
 
 #define private public
@@ -12,10 +12,10 @@
 #include <crepe/api/Event.h>
 #include <crepe/api/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/api/ParticleEmitter.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
@@ -27,14 +27,13 @@ using namespace crepe;
 using namespace testing;
 
 class TestScript : public Script {
-	bool oncollision(const CollisionEvent& test) {
+	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);
-		});
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
@@ -52,10 +51,9 @@ public:
 	const int average = 5;
 	// Maximum duration to stop test
 	const std::chrono::microseconds duration = 16000us;
-	
 
 	ComponentManager mgr;
-	// Add system used for profling tests 
+	// Add system used for profling tests
 	CollisionSystem collision_sys{mgr};
 	PhysicsSystem physics_sys{mgr};
 	ParticleSystem particle_sys{mgr};
@@ -67,12 +65,11 @@ public:
 	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);
+
+		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();
@@ -82,11 +79,12 @@ public:
 
 	// 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) {
+	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);
+		std::chrono::microseconds duration
+			= std::chrono::duration_cast<std::chrono::microseconds>(end - start);
 		timings[name] += duration;
 		return duration;
 	}
@@ -95,8 +93,10 @@ public:
 	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("CollisionSystem", [&]() { collision_sys.update(); });
+		total_microseconds
+			+= time_function("ParticleSystem", [&]() { particle_sys.update(); });
 		total_microseconds += time_function("RenderSystem", [&]() { render_sys.update(); });
 		return total_microseconds;
 	}
@@ -104,34 +104,33 @@ public:
 	// 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;
+
+		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);
+		for (auto & [key, value] : timings) {
+			value = std::chrono::microseconds(0);
 		}
 	}
 };
 
 TEST_F(Profiling, Profiling_1) {
-	while (this->total_time/this->average < this->duration) {
-		
+	while (this->total_time / this->average < this->duration) {
 
 		{
 			//define gameobject used for testing
-			GameObject gameobject = mgr.new_object("gameobject","",{0,0});
+			GameObject gameobject = mgr.new_object("gameobject", "", {0, 0});
 		}
 
 		this->game_object_count++;
@@ -143,18 +142,19 @@ TEST_F(Profiling, Profiling_1) {
 			this->total_time += run_all_systems();
 		}
 
-		if(this->game_object_count >= this->max_gameobject_count) break;
+		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) {
-	
+	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 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,
@@ -163,7 +163,8 @@ TEST_F(Profiling, Profiling_2) {
 			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);
+			Sprite & test_sprite = gameobject.add_component<Sprite>(
+				img, color, Sprite::FlipSettings{false, false}, 1, 1, 500);
 		}
 
 		this->game_object_count++;
@@ -174,50 +175,52 @@ TEST_F(Profiling, Profiling_2) {
 			this->total_time += run_all_systems();
 		}
 
-		if(this->game_object_count >= this->max_gameobject_count) break;
+		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) {
-	
+	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 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,
+				.gravity_scale = 0,
+				.body_type = Rigidbody::BodyType::STATIC,
 			});
 			gameobject.add_component<BoxCollider>(vec2{0, 0}, 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);
+			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,
-	});
+				.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;
+		if (this->game_object_count >= this->max_gameobject_count) break;
 	}
 	log_timings();
 	EXPECT_GE(this->game_object_count, this->min_gameobject_count);
-- 
cgit v1.2.3


From 6454975779acb39d7d546e11855a07a952e68e5b Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 20:12:34 +0100
Subject: loeks feedback changes

---
 src/crepe/api/Button.cpp         |  4 +--
 src/crepe/api/Button.h           | 27 ++++++----------
 src/crepe/api/Event.h            | 14 +++++---
 src/crepe/api/UiObject.cpp       |  5 ++-
 src/crepe/api/UiObject.h         | 21 ++++--------
 src/crepe/facade/SDLContext.cpp  |  3 +-
 src/crepe/facade/SDLContext.h    | 19 +++++------
 src/crepe/system/InputSystem.cpp | 70 +++++++++++++++++++++++-----------------
 src/crepe/system/InputSystem.h   | 19 +++++------
 src/example/button.cpp           |  7 +++-
 src/test/InputTest.cpp           | 10 +++---
 11 files changed, 101 insertions(+), 98 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Button.cpp b/src/crepe/api/Button.cpp
index d325014..f179f60 100644
--- a/src/crepe/api/Button.cpp
+++ b/src/crepe/api/Button.cpp
@@ -2,9 +2,9 @@
 
 namespace crepe {
 
-Button::Button(game_object_id_t id, int width, int height, std::function<void()> on_click,
+Button::Button(game_object_id_t id, vec2 dimensions,vec2 offset, std::function<void()> on_click,
 			   bool is_toggle)
-	: UiObject(id, width, height),
+	: UIObject(id, dimensions,offset),
 	  is_toggle(is_toggle),
 	  on_click(on_click) {}
 
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
index 06d64d6..043cc78 100644
--- a/src/crepe/api/Button.h
+++ b/src/crepe/api/Button.h
@@ -7,25 +7,21 @@
 namespace crepe {
 
 /**
- * \class Button
  * \brief Represents a clickable UI button, derived from the UiObject class.
  * 
- * This class provides functionality for a button in the UI, including toggle state,
- * click handling, and mouse hover detection. A callback function can be provided to
- * handle button clicks.
  */
-class Button : public UiObject {
+class Button : public UIObject {
 public:
 	/**
      * \brief Constructs a Button with the specified game object ID and dimensions.
      * 
      * \param id The unique ID of the game object associated with this button.
-     * \param width The width of the button.
-     * \param height The height of the button.
+     * \param Dimensions The width and height of the UIObject
+     * \param offset The offset relative this GameObjects Transform
      * \param is_toggle Optional flag to indicate if the button is a toggle button. Defaults to false.
      * \param on_click callback function that will be invoked when the button is clicked.
      */
-	Button(game_object_id_t id, int width, int height, std::function<void()> on_click,
+	Button(game_object_id_t id, vec2 dimensions,vec2 offset, std::function<void()> on_click,
 		   bool is_toggle = false);
 
 	/**
@@ -50,7 +46,7 @@ public:
 	 * This function is triggered when the mouse cursor moves over the button, allowing
 	 * custom actions like visual effects, highlighting, or sound effects.
 	 */
-	std::function<void()> on_enter = nullptr;
+	std::function<void()> on_mouse_enter = nullptr;
 
 	/**
 	 * \brief Callback function to be executed when the mouse exits the button's boundaries.
@@ -58,14 +54,15 @@ public:
 	 * This function is triggered when the mouse cursor moves out of the button's area,
 	 * allowing custom actions like resetting visual effects or playing exit-related effects.
 	 */
-	std::function<void()> on_exit = nullptr;
+	std::function<void()> on_mouse_exit = nullptr;
 
 private:
+	//! friend relation for is_pressed and hover variables
 	friend class InputSystem;
 	/**
-     * \brief Indicates whether the button is currently pressed.
+     * \brief Indicates whether the toggle button is pressed
      * 
-     * This state is true when the button is actively pressed and false otherwise.
+     *  This state indicates if the toggle button is pressed or not
      */
 	bool is_pressed = false;
 
@@ -77,12 +74,6 @@ private:
 	bool hover = false;
 
 public:
-	/**
-     * \brief Retrieves the maximum number of instances allowed for this button type.
-     * 
-     * \return Always returns 1, as only a single instance of this type is allowed.
-     */
-	virtual int get_instances_max() const override { return 1; }
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 91a30b5..8083d7c 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -90,10 +90,12 @@ public:
 	int mouse_y = 0;
 
 	// Movement since last event in x
-	int rel_x = 0;
+	int delta_x = 0;
 
 	// Movement since last event in y
-	int rel_y = 0;
+	int delta_y = 0;
+
+	
 };
 
 /**
@@ -102,13 +104,15 @@ public:
 class MouseScrollEvent : public Event {
 public:
 	//! X-coordinate of the mouse position at the time of the event.
-	int scroll_x = 0;
+	int mouse_x = 0;
 
 	//! Y-coordinate of the mouse position at the time of the event.
-	int scroll_y = 0;
+	int mouse_y = 0;
 
 	//! scroll direction (-1 = down, 1 = up)
-	int direction = 0;
+	int scroll_direction = 0;
+	//! scroll amount in y axis (from and away from the person).
+	float scroll_delta = 0;
 };
 /**
  * \brief Event triggered during a collision between objects.
diff --git a/src/crepe/api/UiObject.cpp b/src/crepe/api/UiObject.cpp
index 7859a90..0262d31 100644
--- a/src/crepe/api/UiObject.cpp
+++ b/src/crepe/api/UiObject.cpp
@@ -2,7 +2,6 @@
 
 using namespace crepe;
 
-UiObject::UiObject(game_object_id_t id, int width, int height)
+UIObject::UIObject(game_object_id_t id, vec2 dimensions,vec2 offset)
 	: Component(id),
-	  width(width),
-	  height(height){};
+	  dimensions(dimensions),offset(offset){}
diff --git a/src/crepe/api/UiObject.h b/src/crepe/api/UiObject.h
index c056877..1130f99 100644
--- a/src/crepe/api/UiObject.h
+++ b/src/crepe/api/UiObject.h
@@ -8,26 +8,19 @@ namespace crepe {
  * @class UiObject
  * \brief Represents a UI object in the game, derived from the Component class.
  */
-class UiObject : public Component {
+class UIObject : public Component {
 public:
 	/**
      * \brief Constructs a UiObject with the specified game object ID.
      * \param id The unique ID of the game object associated with this UI object.
+	 * \param dimensions width and height of the UIObject
+	 * \param offset Offset relative to the GameObject Transform
      */
-	UiObject(game_object_id_t id, int width, int height);
+	UIObject(game_object_id_t id, vec2 dimensions,vec2 offset);
+	//! Width and height of the UIObject
+	vec2 dimensions;
+	vec2 offset;
 
-	//! The width of the UI object.
-	int width = 0;
-
-	//! The height of the UI object.
-	int height = 0;
-
-public:
-	/**
-     * \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 a657373..aba7ce7 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -393,7 +393,8 @@ std::vector<SDLContext::EventData> SDLContext::get_events() {
 				event_list.push_back(EventData{
 					.event_type = SDLContext::EventType::MOUSEWHEEL,
 					.mouse_position = {event.motion.x, event.motion.y},
-					.wheel_delta = event.wheel.y,
+					.scroll_direction = event.wheel.direction,
+					.scroll_delta = event.wheel.preciseY,
 				});
 			} break;
 		}
diff --git a/src/crepe/facade/SDLContext.h b/src/crepe/facade/SDLContext.h
index 2228950..bd0427a 100644
--- a/src/crepe/facade/SDLContext.h
+++ b/src/crepe/facade/SDLContext.h
@@ -62,7 +62,8 @@ public:
 		bool key_repeat = false;
 		MouseButton mouse_button = MouseButton::NONE;
 		std::pair<int, int> mouse_position = {-1, -1};
-		int wheel_delta = -1;
+		int scroll_direction = -1;
+		float scroll_delta = INFINITY;
 		std::pair<int, int> rel_mouse_move = {-1, -1};
 	};
 	/**
@@ -80,35 +81,35 @@ private:
 	//! will only use get_events
 	friend class InputSystem;
 	/**
-	 * @brief Retrieves a list of all events from the SDL context.
+	 * \brief Retrieves a list of all events from the SDL context.
 	 * 
 	 * This method retrieves all the events from the SDL context that are currently
 	 * available. It is primarily used by the InputSystem to process various
 	 * input events such as mouse clicks, mouse movements, and keyboard presses.
 	 * 
-	 * @return A vector of `SDLContext::EventData` containing the events.
+	 * \return Events that occurred since last call to `get_events()`
 	 */
 	std::vector<SDLContext::EventData> get_events();
 
 	/**
-	 * @brief Converts an SDL key code to the custom Keycode type.
+	 * \brief Converts an SDL key code to the custom Keycode type.
 	 * 
 	 * This method maps an SDL key code to the corresponding `Keycode` enum value,
 	 * which is used internally by the system to identify the keys.
 	 * 
-	 * @param sdl_key The SDL key code to convert.
-	 * @return The corresponding `Keycode` value.
+	 * \param sdl_key The SDL key code to convert.
+	 * \return The corresponding `Keycode` value or `Keycode::NONE` if the key is unrecognized.
 	 */
 	Keycode sdl_to_keycode(SDL_Keycode sdl_key);
 
 	/**
-	 * @brief Converts an SDL mouse button code to the custom MouseButton type.
+	 * \brief Converts an SDL mouse button code to the custom MouseButton type.
 	 * 
 	 * This method maps an SDL mouse button code to the corresponding `MouseButton` 
 	 * enum value, which is used internally by the system to identify mouse buttons.
 	 * 
-	 * @param sdl_button The SDL mouse button code to convert.
-	 * @return The corresponding `MouseButton` value.
+	 * \param sdl_button The SDL mouse button code to convert.
+	 * \return The corresponding `MouseButton` value or `MouseButton::NONE` if the key is unrecognized
 	 */
 	MouseButton sdl_to_mousebutton(Uint8 sdl_button);
 
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 11749e1..bbf2547 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -37,7 +37,7 @@ void InputSystem::update() {
 				|| 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);
-		
+
 		switch (event.event_type) {
 			case SDLContext::EventType::KEYDOWN:
 				event_mgr.queue_event<KeyPressEvent>(KeyPressEvent{
@@ -59,8 +59,8 @@ void InputSystem::update() {
 					.mouse_y = world_mouse_y,
 					.button = event.mouse_button,
 				});
-				last_mouse_down_position = {world_mouse_x, world_mouse_y};
-				last_mouse_button = event.mouse_button;
+				this->last_mouse_down_position = {world_mouse_x, world_mouse_y};
+				this->last_mouse_button = event.mouse_button;
 				break;
 			case SDLContext::EventType::MOUSEUP: {
 				if (!mouse_in_viewport) {
@@ -72,10 +72,10 @@ void InputSystem::update() {
 					.button = event.mouse_button,
 				});
 				//check if its a click by checking the last button down
-				int delta_x = world_mouse_x - last_mouse_down_position.first;
-				int delta_y = world_mouse_y - last_mouse_down_position.second;
+				int delta_x = world_mouse_x - this->last_mouse_down_position.x;
+				int delta_y = world_mouse_y - this->last_mouse_down_position.y;
 
-				if (last_mouse_button == event.mouse_button
+				if (this->last_mouse_button == event.mouse_button
 					&& std::abs(delta_x) <= click_tolerance
 					&& std::abs(delta_y) <= click_tolerance) {
 					event_mgr.queue_event<MouseClickEvent>(MouseClickEvent{
@@ -84,7 +84,7 @@ void InputSystem::update() {
 						.button = event.mouse_button,
 					});
 
-					handle_click(event.mouse_button, world_mouse_x, world_mouse_y);
+					this->handle_click(event.mouse_button, world_mouse_x, world_mouse_y);
 				}
 			} break;
 			case SDLContext::EventType::MOUSEMOVE:
@@ -94,16 +94,17 @@ void InputSystem::update() {
 				event_mgr.queue_event<MouseMoveEvent>(MouseMoveEvent{
 					.mouse_x = world_mouse_x,
 					.mouse_y = world_mouse_y,
-					.rel_x = event.rel_mouse_move.first,
-					.rel_y = event.rel_mouse_move.second,
+					.delta_x = event.rel_mouse_move.first,
+					.delta_y = event.rel_mouse_move.second,
 				});
 				handle_move(event, world_mouse_x, world_mouse_y);
 				break;
 			case SDLContext::EventType::MOUSEWHEEL:
 				event_mgr.queue_event<MouseScrollEvent>(MouseScrollEvent{
-					.scroll_x = event.wheel_delta,
-					.scroll_y = 0,
-					.direction = event.wheel_delta,
+					.mouse_x = world_mouse_x,
+					.mouse_y = world_mouse_y,
+					.scroll_direction = event.scroll_direction,
+					.scroll_delta = event.scroll_delta,
 				});
 				break;
 			case SDLContext::EventType::SHUTDOWN:
@@ -115,7 +116,7 @@ void InputSystem::update() {
 	}
 }
 void InputSystem::handle_move(const SDLContext::EventData & event_data,
-							  const int & world_mouse_x, const int & world_mouse_y) {
+							  const int world_mouse_x, const int world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -127,23 +128,23 @@ void InputSystem::handle_move(const SDLContext::EventData & event_data,
 
 		bool was_hovering = button.hover;
 		if (button.active
-			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+			&& this->is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
 			button.hover = true;
-			if (!was_hovering && button.on_enter) {
-				button.on_enter();
+			if (!was_hovering && button.on_mouse_enter) {
+				button.on_mouse_enter();
 			}
 		} else {
 			button.hover = false;
 			// Trigger the on_exit callback if the hover state just changed to false
-			if (was_hovering && button.on_exit) {
-				button.on_exit();
+			if (was_hovering && button.on_mouse_exit) {
+				button.on_mouse_exit();
 			}
 		}
 	}
 }
 
-void InputSystem::handle_click(const MouseButton & mouse_button, const int & world_mouse_x,
-							   const int & world_mouse_y) {
+void InputSystem::handle_click(const MouseButton & mouse_button, const int world_mouse_x,
+							   const int world_mouse_y) {
 	ComponentManager & mgr = this->component_manager;
 
 	RefVector<Button> buttons = mgr.get_components_by_type<Button>();
@@ -154,30 +155,39 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const int & wor
 		Transform& transform(transform_vec.front().get());
 
 		if (button.active
-			&& is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
-			handle_button_press(button);
+			&& this->is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
+			this->handle_button_press(button);
 		}
 	}
 }
 
-bool InputSystem::is_mouse_inside_button(const int & mouse_x, const int & mouse_y,
-										 const Button & button, const Transform & transform) {
-	int half_width = button.width / 2;
-	int half_height = button.height / 2;
+bool InputSystem::is_mouse_inside_button(const int mouse_x, const int mouse_y,
+                                         const Button &button, const Transform &transform) {
+    int actual_x = transform.position.x + button.offset.x;
+    int actual_y = transform.position.y + button.offset.y;
 
-	return mouse_x >= transform.position.x - half_width
-		   && mouse_x <= transform.position.x + half_width
-		   && mouse_y >= transform.position.y - half_height
-		   && mouse_y <= transform.position.y + half_height;
+    int half_width = button.dimensions.x / 2;
+    int half_height = button.dimensions.y / 2;
+
+    // Check if the mouse is within the button's boundaries
+    return mouse_x >= actual_x - half_width
+           && mouse_x <= actual_x + half_width
+           && mouse_y >= actual_y - half_height
+           && mouse_y <= actual_y + half_height;
 }
 
+
 void InputSystem::handle_button_press(Button & button) {
+	//checks if the button is a toggle button
 	if (button.is_toggle) {
+		//if the toggle button is not in a pressed state and it has a on_click call the on_click
 		if (!button.is_pressed && button.on_click) {
 			button.on_click();
 		}
+		//toggle the pressed state
 		button.is_pressed = !button.is_pressed;
 	} else if (button.on_click) {
+		// if the button is not a toggle button and has a on_click call the on_click
 		button.on_click();
 	}
 }
diff --git a/src/crepe/system/InputSystem.h b/src/crepe/system/InputSystem.h
index e65ad30..557ba47 100644
--- a/src/crepe/system/InputSystem.h
+++ b/src/crepe/system/InputSystem.h
@@ -13,7 +13,7 @@ class Button;
 class Transform;
 
 /**
- * \brief Handles the processing of input events like mouse and keyboard interactions.
+ * \brief Handles the processing of input events created by SDLContext
  *
  * This system processes events such as mouse clicks, mouse movement, and keyboard
  * actions. It is responsible for detecting interactions with UI buttons and
@@ -31,14 +31,15 @@ public:
 
 private:
 	//! Stores the last position of the mouse when the button was pressed.
-	std::pair<int, int> last_mouse_down_position{INFINITY, INFINITY};
+	ivec2 last_mouse_down_position{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()};
 
 	//! Stores the last mouse button pressed.
 	MouseButton last_mouse_button = MouseButton::NONE;
-	//
-	//! The tolerance in game units for detecting a mouse click.
+	
+	//! The maximum allowable distance between mouse down and mouse up to register as a click.
 	const int click_tolerance = 5;
 
+
 	/**
 	* \brief Handles the mouse click event.
 	* \param mouse_button The mouse button involved in the click.
@@ -47,8 +48,8 @@ private:
 	*
 	* This method processes the mouse click event and triggers the corresponding button action.
 	*/
-	void handle_click(const MouseButton & mouse_button, const int & world_mouse_x,
-					  const int & world_mouse_y);
+	void handle_click(const MouseButton & mouse_button, const int world_mouse_x,
+					  const int world_mouse_y);
 
 	/**
 	* \brief Handles the mouse movement event.
@@ -58,8 +59,8 @@ private:
 	*
 	* This method processes the mouse movement event and updates the button hover state.
 	*/
-	void handle_move(const SDLContext::EventData & event_data, const int & world_mouse_x,
-					 const int & world_mouse_y);
+	void handle_move(const SDLContext::EventData & event_data, const int world_mouse_x,
+					 const int world_mouse_y);
 
 	/**
 	* \brief Checks if the mouse position is inside the bounds of the button.
@@ -69,7 +70,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 int & world_mouse_x, const int & world_mouse_y,
+	bool is_mouse_inside_button(const int world_mouse_x, const int world_mouse_y,
 								const Button & button, const Transform & transform);
 
 	/**
diff --git a/src/example/button.cpp b/src/example/button.cpp
index 52fa199..7efd889 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -34,7 +34,12 @@ int main(int argc, char * argv[]) {
 	auto & sprite2 = button_obj.add_component<Sprite>(
 		s2, Color::GREEN, Sprite::FlipSettings{false, false}, 2, 1, 100);
 	std::function<void()> on_click = [&]() { std::cout << "button clicked" << std::endl; };
-	auto & button = button_obj.add_component<Button>(100, 100, on_click, false);
+	std::function<void()> on_enter = [&]() { std::cout << "enter" << std::endl; };
+	std::function<void()> on_exit = [&]() { std::cout << "exit" << std::endl; };
+	auto & button = button_obj.add_component<Button>(vec2{100,100},vec2{0,0}, on_click, false);
+	button.on_mouse_enter = on_enter;
+	button.on_mouse_exit = on_exit;
+	button.is_toggle = true;
 	button.active = true;
 	auto start = std::chrono::steady_clock::now();
 	while (true) {
diff --git a/src/test/InputTest.cpp b/src/test/InputTest.cpp
index 32111c0..f7d1059 100644
--- a/src/test/InputTest.cpp
+++ b/src/test/InputTest.cpp
@@ -119,8 +119,8 @@ TEST_F(InputTest, MouseMove) {
 		function_triggered = true;
 		EXPECT_EQ(e.mouse_x, 0);
 		EXPECT_EQ(e.mouse_y, 0);
-		EXPECT_EQ(e.rel_x, 10);
-		EXPECT_EQ(e.rel_y, 10);
+		EXPECT_EQ(e.delta_x , 10);
+		EXPECT_EQ(e.delta_y , 10);
 		return false;
 	};
 	event_manager.subscribe<MouseMoveEvent>(on_mouse_move);
@@ -223,7 +223,7 @@ TEST_F(InputTest, testButtonClick) {
 	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>(100, 100, on_click, false);
+	auto & button = button_obj.add_component<Button>(vec2{100,100},vec2{0,0}, on_click, false);
 
 	bool hover = false;
 	button.active = true;
@@ -249,10 +249,8 @@ TEST_F(InputTest, testButtonHover) {
 	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>(100, 100, on_click, false);
+	auto & button = button_obj.add_component<Button>(vec2{100,100},vec2{0,0}, on_click, false);
 	button.active = true;
-	button.width = 100;
-	button.height = 100;
 	button.is_pressed = false;
 	button.is_toggle = false;
 
-- 
cgit v1.2.3


From 66fdcffaddb0ab31d12b6b1d7892a8edaa31af65 Mon Sep 17 00:00:00 2001
From: WBoerenkamps <wrj.boerenkamps@student.avans.nl>
Date: Wed, 4 Dec 2024 20:13:09 +0100
Subject: make format

---
 src/crepe/api/Button.cpp         |  6 +++---
 src/crepe/api/Button.h           |  2 +-
 src/crepe/api/Event.h            |  2 --
 src/crepe/api/UiObject.cpp       |  5 +++--
 src/crepe/api/UiObject.h         |  3 +--
 src/crepe/system/InputSystem.cpp | 25 +++++++++++--------------
 src/crepe/system/InputSystem.h   |  6 +++---
 src/example/button.cpp           |  3 ++-
 src/test/InputTest.cpp           | 10 ++++++----
 9 files changed, 30 insertions(+), 32 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Button.cpp b/src/crepe/api/Button.cpp
index f179f60..b104329 100644
--- a/src/crepe/api/Button.cpp
+++ b/src/crepe/api/Button.cpp
@@ -2,9 +2,9 @@
 
 namespace crepe {
 
-Button::Button(game_object_id_t id, vec2 dimensions,vec2 offset, std::function<void()> on_click,
-			   bool is_toggle)
-	: UIObject(id, dimensions,offset),
+Button::Button(game_object_id_t id, vec2 dimensions, vec2 offset,
+			   std::function<void()> on_click, bool is_toggle)
+	: UIObject(id, dimensions, offset),
 	  is_toggle(is_toggle),
 	  on_click(on_click) {}
 
diff --git a/src/crepe/api/Button.h b/src/crepe/api/Button.h
index 043cc78..5c803ba 100644
--- a/src/crepe/api/Button.h
+++ b/src/crepe/api/Button.h
@@ -21,7 +21,7 @@ public:
      * \param is_toggle Optional flag to indicate if the button is a toggle button. Defaults to false.
      * \param on_click callback function that will be invoked when the button is clicked.
      */
-	Button(game_object_id_t id, vec2 dimensions,vec2 offset, std::function<void()> on_click,
+	Button(game_object_id_t id, vec2 dimensions, vec2 offset, std::function<void()> on_click,
 		   bool is_toggle = false);
 
 	/**
diff --git a/src/crepe/api/Event.h b/src/crepe/api/Event.h
index 8083d7c..6298118 100644
--- a/src/crepe/api/Event.h
+++ b/src/crepe/api/Event.h
@@ -94,8 +94,6 @@ public:
 
 	// Movement since last event in y
 	int delta_y = 0;
-
-	
 };
 
 /**
diff --git a/src/crepe/api/UiObject.cpp b/src/crepe/api/UiObject.cpp
index 0262d31..2b287b3 100644
--- a/src/crepe/api/UiObject.cpp
+++ b/src/crepe/api/UiObject.cpp
@@ -2,6 +2,7 @@
 
 using namespace crepe;
 
-UIObject::UIObject(game_object_id_t id, vec2 dimensions,vec2 offset)
+UIObject::UIObject(game_object_id_t id, vec2 dimensions, vec2 offset)
 	: Component(id),
-	  dimensions(dimensions),offset(offset){}
+	  dimensions(dimensions),
+	  offset(offset) {}
diff --git a/src/crepe/api/UiObject.h b/src/crepe/api/UiObject.h
index 1130f99..0634f97 100644
--- a/src/crepe/api/UiObject.h
+++ b/src/crepe/api/UiObject.h
@@ -16,11 +16,10 @@ public:
 	 * \param dimensions width and height of the UIObject
 	 * \param offset Offset relative to the GameObject Transform
      */
-	UIObject(game_object_id_t id, vec2 dimensions,vec2 offset);
+	UIObject(game_object_id_t id, vec2 dimensions, vec2 offset);
 	//! Width and height of the UIObject
 	vec2 dimensions;
 	vec2 offset;
-
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index bbf2547..21ec24b 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -152,7 +152,7 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const int world
 	for (Button & button : buttons) {
 		RefVector<Transform> transform_vec
 			= mgr.get_components_by_id<Transform>(button.game_object_id);
-		Transform& transform(transform_vec.front().get());
+		Transform & transform(transform_vec.front().get());
 
 		if (button.active
 			&& this->is_mouse_inside_button(world_mouse_x, world_mouse_y, button, transform)) {
@@ -162,20 +162,17 @@ void InputSystem::handle_click(const MouseButton & mouse_button, const int world
 }
 
 bool InputSystem::is_mouse_inside_button(const int mouse_x, const int mouse_y,
-                                         const Button &button, const Transform &transform) {
-    int actual_x = transform.position.x + button.offset.x;
-    int actual_y = transform.position.y + button.offset.y;
-
-    int half_width = button.dimensions.x / 2;
-    int half_height = button.dimensions.y / 2;
-
-    // Check if the mouse is within the button's boundaries
-    return mouse_x >= actual_x - half_width
-           && mouse_x <= actual_x + half_width
-           && mouse_y >= actual_y - half_height
-           && mouse_y <= actual_y + half_height;
-}
+										 const Button & button, const Transform & transform) {
+	int actual_x = transform.position.x + button.offset.x;
+	int actual_y = transform.position.y + button.offset.y;
 
+	int half_width = button.dimensions.x / 2;
+	int half_height = button.dimensions.y / 2;
+
+	// Check if the mouse is within the button's boundaries
+	return mouse_x >= actual_x - half_width && mouse_x <= actual_x + half_width
+		   && mouse_y >= actual_y - half_height && mouse_y <= actual_y + half_height;
+}
 
 void InputSystem::handle_button_press(Button & button) {
 	//checks if the button is a toggle button
diff --git a/src/crepe/system/InputSystem.h b/src/crepe/system/InputSystem.h
index 557ba47..eafeb91 100644
--- a/src/crepe/system/InputSystem.h
+++ b/src/crepe/system/InputSystem.h
@@ -31,15 +31,15 @@ public:
 
 private:
 	//! Stores the last position of the mouse when the button was pressed.
-	ivec2 last_mouse_down_position{std::numeric_limits<int>::max(), std::numeric_limits<int>::max()};
+	ivec2 last_mouse_down_position{std::numeric_limits<int>::max(),
+								   std::numeric_limits<int>::max()};
 
 	//! 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.
 	const int click_tolerance = 5;
 
-
 	/**
 	* \brief Handles the mouse click event.
 	* \param mouse_button The mouse button involved in the click.
diff --git a/src/example/button.cpp b/src/example/button.cpp
index 7efd889..00bdc28 100644
--- a/src/example/button.cpp
+++ b/src/example/button.cpp
@@ -36,7 +36,8 @@ int main(int argc, char * argv[]) {
 	std::function<void()> on_click = [&]() { std::cout << "button clicked" << std::endl; };
 	std::function<void()> on_enter = [&]() { std::cout << "enter" << std::endl; };
 	std::function<void()> on_exit = [&]() { std::cout << "exit" << std::endl; };
-	auto & button = button_obj.add_component<Button>(vec2{100,100},vec2{0,0}, on_click, false);
+	auto & button
+		= button_obj.add_component<Button>(vec2{100, 100}, vec2{0, 0}, on_click, false);
 	button.on_mouse_enter = on_enter;
 	button.on_mouse_exit = on_exit;
 	button.is_toggle = true;
diff --git a/src/test/InputTest.cpp b/src/test/InputTest.cpp
index f7d1059..f9b2fe7 100644
--- a/src/test/InputTest.cpp
+++ b/src/test/InputTest.cpp
@@ -119,8 +119,8 @@ TEST_F(InputTest, MouseMove) {
 		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);
+		EXPECT_EQ(e.delta_x, 10);
+		EXPECT_EQ(e.delta_y, 10);
 		return false;
 	};
 	event_manager.subscribe<MouseMoveEvent>(on_mouse_move);
@@ -223,7 +223,8 @@ TEST_F(InputTest, testButtonClick) {
 	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);
+	auto & button
+		= button_obj.add_component<Button>(vec2{100, 100}, vec2{0, 0}, on_click, false);
 
 	bool hover = false;
 	button.active = true;
@@ -249,7 +250,8 @@ TEST_F(InputTest, testButtonHover) {
 	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);
+	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;
-- 
cgit v1.2.3


From 69634f05b00e0e01ab84ab14b6293c7a88c5fbe0 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Wed, 4 Dec 2024 20:48:38 +0100
Subject: added collision layers to example and unit test

---
 src/example/game.cpp       | 14 ++++++++------
 src/test/CollisionTest.cpp |  2 ++
 2 files changed, 10 insertions(+), 6 deletions(-)

(limited to 'src/example')

diff --git a/src/example/game.cpp b/src/example/game.cpp
index 70c562e..a8d6d1b 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -44,12 +44,13 @@ public:
 		//define playable world
 		GameObject world = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
-		world.add_component<Rigidbody>(
-			Rigidbody::Data{.mass = 0,
-							.gravity_scale = 0,
-							.body_type = Rigidbody::BodyType::STATIC,
-							.constraints = {0, 0, 0},
-							.offset = {0, 0}});
+		world.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 0,
+			.gravity_scale = 0,
+			.body_type = Rigidbody::BodyType::STATIC,
+			.offset = {0, 0},
+			.collision_layers = {0},
+		});
 		world.add_component<BoxCollider>(
 			vec2{0, 0 - (screen_size_height / 2 + world_collider / 2)},
 			vec2{world_collider, world_collider});
@@ -73,6 +74,7 @@ public:
 			.constraints = {0, 0, 0},
 			.elastisity_coefficient = 1,
 			.offset = {0, 0},
+			.collision_layers = {0},
 		});
 		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
 		game_object1.add_component<BehaviorScript>().set_script<MyScript>();
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index 74edaf7..3da04b5 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -78,6 +78,7 @@ public:
 			.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
@@ -93,6 +94,7 @@ public:
 			.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
-- 
cgit v1.2.3


From 453aeafda1503aeafa54b8f6e293936c1a3db5ea Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Thu, 5 Dec 2024 22:15:38 +0100
Subject: dynamic and static bug fixes

---
 asset/texture/circle.png             | Bin 0 -> 509 bytes
 asset/texture/green_square.png       | Bin 135 -> 0 bytes
 asset/texture/red_square.png         | Bin 135 -> 0 bytes
 asset/texture/square.png             | Bin 0 -> 162 bytes
 src/crepe/system/CollisionSystem.cpp |  15 ++--
 src/crepe/system/CollisionSystem.h   |   5 +-
 src/example/game.cpp                 | 143 +++++++++++++++++++++++++++++++++--
 7 files changed, 147 insertions(+), 16 deletions(-)
 create mode 100755 asset/texture/circle.png
 delete mode 100755 asset/texture/green_square.png
 delete mode 100755 asset/texture/red_square.png
 create mode 100755 asset/texture/square.png

(limited to 'src/example')

diff --git a/asset/texture/circle.png b/asset/texture/circle.png
new file mode 100755
index 0000000..0a92ac7
Binary files /dev/null and b/asset/texture/circle.png differ
diff --git a/asset/texture/green_square.png b/asset/texture/green_square.png
deleted file mode 100755
index 7772c87..0000000
Binary files a/asset/texture/green_square.png and /dev/null differ
diff --git a/asset/texture/red_square.png b/asset/texture/red_square.png
deleted file mode 100755
index 6ffbbec..0000000
Binary files a/asset/texture/red_square.png and /dev/null differ
diff --git a/asset/texture/square.png b/asset/texture/square.png
new file mode 100755
index 0000000..d07ec98
Binary files /dev/null and b/asset/texture/square.png differ
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index 86eafc0..f75d0ad 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -159,7 +159,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
 			resolution = this->get_circle_box_resolution(collider2, collider1, collider_pos2,
-														 collider_pos1);
+														 collider_pos1,true);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE: {
@@ -185,7 +185,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
 			resolution = this->get_circle_box_resolution(collider1, collider2, collider_pos1,
-														 collider_pos2);
+														 collider_pos2,false);
 			break;
 		}
 	}
@@ -261,9 +261,10 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle
 
 	// Normalize the delta vector to get the collision direction
 	vec2 collision_normal = delta / distance;
+	
 
 	// Compute the resolution vector
-	vec2 resolution = collision_normal * penetration_depth;
+	vec2 resolution = -collision_normal * penetration_depth;
 
 	return resolution;
 }
@@ -271,7 +272,7 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle
 vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_collider,
 												const BoxCollider & box_collider,
 												const vec2 & circle_position,
-												const vec2 & box_position) const {
+												const vec2 & box_position,bool inverse) const {
 	vec2 delta = circle_position - box_position;
 
 	// Compute half-dimensions of the box
@@ -293,7 +294,7 @@ vec2 CollisionSystem::get_circle_box_resolution(const CircleCollider & circle_co
 
 	// Compute penetration depth
 	float penetration_depth = circle_collider.radius - distance;
-
+	if(inverse) collision_normal = -collision_normal;
 	// Compute the resolution vector
 	vec2 resolution = collision_normal * penetration_depth;
 
@@ -511,7 +512,7 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1,
 	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Compare distance squared with the square of the circle's radius
-	return distance_squared <= circle2.radius * circle2.radius;
+	return distance_squared <= circle2.radius * circle2.radius-1;
 }
 
 bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1,
@@ -532,7 +533,7 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1
 	float radius_sum = circle1.radius + circle2.radius;
 
 	// Check if the distance between the centers is less than or equal to the sum of the radii
-	return distance_squared <= radius_sum * radius_sum;
+	return distance_squared <= radius_sum * radius_sum - 1;
 }
 
 vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 6995bb5..b978dbb 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -177,13 +177,14 @@ private:
 		* \param circle_collider The first CircleCollider.
 		* \param box_collider The second CircleCollider.
 		* \param circle_position The position of the CircleCollider.
-		* \param box_position The position of the BocCollider.
+		* \param box_position The position of the BoxCollider.
+		* \param inverse Inverted true if box circle collision, false if circle box collision (inverts the direction).
 		* \return The resolution vector for the collision.
 		*/
 	vec2 get_circle_box_resolution(const CircleCollider & circle_collider,
 								   const BoxCollider & box_collider,
 								   const vec2 & circle_position,
-								   const vec2 & box_position) const;
+								   const vec2 & box_position,bool inverse) const;
 
 	/**
 		* \brief Determines the appropriate collision handler for a collision.
diff --git a/src/example/game.cpp b/src/example/game.cpp
index ade90c9..be756bd 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -1,3 +1,4 @@
+#include "api/CircleCollider.h"
 #include "manager/ComponentManager.h"
 #include "api/Scene.h"
 #include "manager/Mediator.h"
@@ -18,7 +19,8 @@ using namespace crepe;
 
 using namespace std;
 
-class MyScript : public Script {
+class MyScript1 : public Script {
+	bool flip = false;
 	bool oncollision(const CollisionEvent & test) {
 		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
 		return true;
@@ -50,6 +52,98 @@ class MyScript : public Script {
 				tf.position.x += 1;
 				break;
 			}
+			case Keycode::E:
+			{
+				if(flip){
+					flip = false;
+					this->get_component<BoxCollider>().active = true;
+					this->get_components<Sprite>()[0].get().active = true;
+					this->get_component<CircleCollider>().active = false;
+					this->get_components<Sprite>()[1].get().active = false;
+				}
+				else {
+					flip = true;
+					this->get_component<BoxCollider>().active = false;
+					this->get_components<Sprite>()[0].get().active = false;
+					this->get_component<CircleCollider>().active = true;
+					this->get_components<Sprite>()[1].get().active = true;
+				}
+				
+				
+				//add collider switch
+				break;
+			}
+			default:
+			break;
+		}
+		return false;
+	} 
+
+	void init() {
+		Log::logf("init");
+		subscribe<CollisionEvent>([this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+		subscribe<KeyPressEvent>([this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
+	}
+	void update() {
+		// Retrieve component from the same GameObject this script is on
+	}
+	
+};
+
+class MyScript2 : public Script {
+	bool flip = false;
+	bool oncollision(const CollisionEvent & test) {
+		Log::logf("Box {} script on_collision()", test.info.this_collider.game_object_id);
+		return true;
+	}
+	bool keypressed(const KeyPressEvent & test) {
+		Log::logf("Box script keypressed()");
+		switch (test.key) {
+			case Keycode::LEFT:
+			{
+				Transform & tf = this->get_component<Transform>();
+				tf.position.x -= 1;
+				break;
+			}
+			case Keycode::UP:
+			{
+				Transform & tf = this->get_component<Transform>();
+				tf.position.y -= 1;
+				break;
+			}
+			case Keycode::DOWN:
+			{
+				Transform & tf = this->get_component<Transform>();
+				tf.position.y += 1;
+				break;
+			}
+			case Keycode::RIGHT:
+			{
+				Transform & tf = this->get_component<Transform>();
+				tf.position.x += 1;
+				break;
+			}
+			case Keycode::PAUSE:
+			{
+				if(flip){
+					flip = false;
+					this->get_component<BoxCollider>().active = true;
+					this->get_components<Sprite>()[0].get().active = true;
+					this->get_component<CircleCollider>().active = false;
+					this->get_components<Sprite>()[1].get().active = false;
+				}
+				else {
+					flip = true;
+					this->get_component<BoxCollider>().active = false;
+					this->get_components<Sprite>()[0].get().active = false;
+					this->get_component<CircleCollider>().active = true;
+					this->get_components<Sprite>()[1].get().active = true;
+				}
+				
+				
+				//add collider switch
+				break;
+			}
 			default:
 			break;
 		}
@@ -77,8 +171,8 @@ public:
 		ComponentManager & mgr = m.component_manager;
 		Color color(0, 0, 0, 255);
 
-		float screen_size_width = 640;
-		float screen_size_height = 480;
+		float screen_size_width = 320;
+		float screen_size_height = 240;
 		float world_collider = 1000;
 		//define playable world
 		GameObject world = mgr.new_object(
@@ -101,7 +195,7 @@ public:
 			vec2{world_collider, world_collider}); // Left
 		world.add_component<BoxCollider>(vec2{screen_size_width / 2 + world_collider / 2, 0},
 										 vec2{world_collider, world_collider}); // right
-		world.add_component<Camera>(Color::WHITE, ivec2{640, 480}, vec2{640, 480}, 1.0f);
+		world.add_component<Camera>(Color::WHITE, ivec2{static_cast<int>(screen_size_width), static_cast<int>(screen_size_height)}, vec2{screen_size_width, screen_size_height}, 1.0f);
 
 		GameObject game_object1 = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
@@ -115,11 +209,46 @@ public:
 			.offset = {0, 0},
 			.collision_layers = {0},
 		});
+		// add box with boxcollider
 		game_object1.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
-		game_object1.add_component<BehaviorScript>().set_script<MyScript>();
-		auto img = Texture("asset/texture/green_square.png");
-		game_object1.add_component<Sprite>(img, color, Sprite::FlipSettings{false, false}, 1,
+		game_object1.add_component<BehaviorScript>().set_script<MyScript1>();
+		auto img1 = Texture("asset/texture/square.png");
+		game_object1.add_component<Sprite>(img1, color, Sprite::FlipSettings{false, false}, 1,
 										   1, 20);
+
+		//add circle with cirlcecollider deactiveated
+		game_object1.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
+		auto img2 = Texture("asset/texture/circle.png");
+		game_object1.add_component<Sprite>(img2, color, Sprite::FlipSettings{false, false}, 1,
+										   1, 20).active = false;
+
+
+
+		GameObject game_object2 = mgr.new_object(
+			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
+		game_object2.add_component<Rigidbody>(Rigidbody::Data{
+			.mass = 1,
+			.gravity_scale = 0,
+			.body_type = Rigidbody::BodyType::STATIC,
+			.linear_velocity = {0, 0},
+			.constraints = {0, 0, 0},
+			.elastisity_coefficient = 1,
+			.offset = {0, 0},
+			.collision_layers = {0},
+		});
+		// add box with boxcollider
+		game_object2.add_component<BoxCollider>(vec2{0, 0}, vec2{20, 20});
+		game_object2.add_component<BehaviorScript>().set_script<MyScript2>();
+		auto img3 = Texture("asset/texture/square.png");
+		game_object2.add_component<Sprite>(img3, color, Sprite::FlipSettings{false, false}, 1,
+										   1, 20);
+
+		//add circle with cirlcecollider deactiveated
+		game_object2.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
+		auto img4 = Texture("asset/texture/circle.png");
+		game_object2.add_component<Sprite>(img4, color, Sprite::FlipSettings{false, false}, 1,
+										   1, 20).active = false;
+
 	}
 
 	string get_name() const { return "scene1"; }
-- 
cgit v1.2.3


From 0c1cd46d22d9006ab46442c92bc7bd8858079ea8 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 11:13:01 +0100
Subject: merged master

---
 src/crepe/facade/SDLContext.cpp       |  4 +---
 src/crepe/system/InputSystem.cpp      |  4 ++--
 src/doc/feature/animator_creation.dox |  0
 src/example/rendering_particle.cpp    | 28 +++++++---------------------
 4 files changed, 10 insertions(+), 26 deletions(-)
 create mode 100644 src/doc/feature/animator_creation.dox

(limited to 'src/example')

diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 72b4e42..0097070 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -11,7 +11,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <functional>
-#include <iostream>
 #include <memory>
 #include <stdexcept>
 
@@ -19,7 +18,6 @@
 #include "../api/Config.h"
 #include "../api/Sprite.h"
 #include "../api/Texture.h"
-#include "../manager/EventManager.h"
 #include "../util/Log.h"
 
 #include "SDLContext.h"
@@ -273,7 +271,7 @@ void SDLContext::draw(const RenderContext & ctx) {
 
 	double angle = ctx.angle + data.angle_offset;
 
-	this->set_color_texture(ctx.sprite.sprite_image, ctx.sprite.color);
+	this->set_color_texture(ctx.sprite.texture, ctx.sprite.data.color);
 	SDL_RenderCopyExF(this->game_renderer.get(), ctx.sprite.texture.texture.get(), &srcrect,
 					  &dstrect, angle, NULL, render_flip);
 }
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 7cc8d30..56a40b7 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -25,9 +25,9 @@ void InputSystem::update() {
 		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
 	Transform & cam_transform = transform_vec.front().get();
 	int camera_origin_x
-		= cam_transform.position.x + current_cam.offset.x - (current_cam.viewport_size.x / 2);
+		= cam_transform.position.x + current_cam.data.offset.x - (current_cam.viewport_size.x / 2);
 	int camera_origin_y
-		= cam_transform.position.y + current_cam.offset.y - (current_cam.viewport_size.y / 2);
+		= cam_transform.position.y + current_cam.data.offset.y - (current_cam.viewport_size.y / 2);
 
 	for (const SDLContext::EventData & event : event_list) {
 		int world_mouse_x = event.mouse_position.x + camera_origin_x;
diff --git a/src/doc/feature/animator_creation.dox b/src/doc/feature/animator_creation.dox
new file mode 100644
index 0000000..e69de29
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 07e43a1..9d6b537 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -1,21 +1,16 @@
-#include "api/Animator.h"
-#include "api/Camera.h"
-#include "api/LoopManager.h"
-#include "api/LoopTimer.h"
-#include "system/AnimatorSystem.h"
-#include "system/ParticleSystem.h"
-#include <SDL2/SDL_timer.h>
-#include <crepe/ComponentManager.h>
-
 #include <crepe/Component.h>
+#include <crepe/api/Animator.h>
+#include <crepe/api/Camera.h>
 #include <crepe/api/Color.h>
 #include <crepe/api/GameObject.h>
+#include <crepe/api/LoopManager.hpp>
 #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/system/RenderSystem.h>
+#include <crepe/manager/ComponentManager.h>
+#include <crepe/manager/Mediator.h>
 #include <crepe/types.h>
 
 using namespace crepe;
@@ -46,7 +41,8 @@ using namespace std;
 class TestScene : public Scene {
 public:
 	void load_scene() {
-		ComponentManager & mgr = this->component_manager;
+		Mediator & mediator = this->mediator;
+		ComponentManager & mgr = mediator.component_manager;
 		GameObject game_object = mgr.new_object("", "", vec2{0, 0}, 0, 1);
 
 		Color color(255, 255, 255, 255);
@@ -84,15 +80,5 @@ int main(int argc, char * argv[]) {
 	LoopManager engine;
 	engine.add_scene<TestScene>();
 	engine.start();
-
-	/*
-	game_object
-		.add_component<Sprite>(make_shared<Texture>("asset/texture/img.png"), color,
-		.add_component<Sprite>(make_shared<Texture>("asset/texture/img.png"), color,
-							   FlipSettings{false, false})
-		.order_in_layer
-		= 6;
-	*/
-
 	return 0;
 }
-- 
cgit v1.2.3


From d0130b79680ffb873b56eafbb689aaaafa1ac2b3 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 6 Dec 2024 11:42:31 +0100
Subject: bug fox

---
 src/crepe/system/CollisionSystem.cpp | 4 ++--
 src/example/game.cpp                 | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index f75d0ad..fe2d669 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -191,7 +191,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 	}
 
 	Direction resolution_direction = Direction::NONE;
-	if (resolution.x != 0 && resolution.y > 0) {
+	if (resolution.x != 0 && resolution.y != 0) {
 		resolution_direction = Direction::BOTH;
 	} else if (resolution.x != 0) {
 		resolution_direction = Direction::X_DIRECTION;
@@ -306,7 +306,7 @@ void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
 	if (info.this_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) return;
 	// If second body is static perform the static collision handler in this system
 	if (info.other_rigidbody.data.body_type == Rigidbody::BodyType::STATIC) {
-		static_collision_handler(info);
+		this->static_collision_handler(info);
 	};
 	// Call collision event for user
 	CollisionEvent data(info);
diff --git a/src/example/game.cpp b/src/example/game.cpp
index be756bd..af99097 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -201,7 +201,7 @@ public:
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
 		game_object1.add_component<Rigidbody>(Rigidbody::Data{
 			.mass = 1,
-			.gravity_scale = 0,
+			.gravity_scale = 0.05,
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
-- 
cgit v1.2.3


From cc320c87372dfbcce5f1cee66397466d90a9ba0a Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 6 Dec 2024 12:31:38 +0100
Subject: removed minus one from calculation

---
 src/crepe/system/CollisionSystem.cpp | 4 ++--
 src/example/game.cpp                 | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index fe2d669..bde217f 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -512,7 +512,7 @@ bool CollisionSystem::get_box_circle_collision(const BoxCollider & box1,
 	float distance_squared = distance_x * distance_x + distance_y * distance_y;
 
 	// Compare distance squared with the square of the circle's radius
-	return distance_squared <= circle2.radius * circle2.radius-1;
+	return distance_squared <= circle2.radius * circle2.radius;
 }
 
 bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1,
@@ -533,7 +533,7 @@ bool CollisionSystem::get_circle_circle_collision(const CircleCollider & circle1
 	float radius_sum = circle1.radius + circle2.radius;
 
 	// Check if the distance between the centers is less than or equal to the sum of the radii
-	return distance_squared <= radius_sum * radius_sum - 1;
+	return distance_squared <= radius_sum * radius_sum;
 }
 
 vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
diff --git a/src/example/game.cpp b/src/example/game.cpp
index af99097..be756bd 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -201,7 +201,7 @@ public:
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
 		game_object1.add_component<Rigidbody>(Rigidbody::Data{
 			.mass = 1,
-			.gravity_scale = 0.05,
+			.gravity_scale = 0,
 			.body_type = Rigidbody::BodyType::DYNAMIC,
 			.linear_velocity = {0, 0},
 			.constraints = {0, 0, 0},
-- 
cgit v1.2.3


From 7ec1fcfcff0c01d204ccbf1bac9919ba610b8606 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 15:42:25 +0100
Subject: implemented final max feedback

---
 src/crepe/api/Animator.cpp         |  2 +-
 src/crepe/api/Animator.h           | 26 ++++++++++++++------------
 src/crepe/api/Camera.h             |  2 +-
 src/crepe/api/Sprite.h             | 12 +++++++++---
 src/crepe/facade/SDLContext.cpp    |  2 +-
 src/crepe/manager/Mediator.h       |  2 ++
 src/crepe/system/InputSystem.cpp   |  4 ++--
 src/crepe/system/RenderSystem.cpp  |  2 +-
 src/crepe/system/RenderSystem.h    |  3 +--
 src/example/rendering_particle.cpp |  1 +
 10 files changed, 33 insertions(+), 23 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.cpp b/src/crepe/api/Animator.cpp
index dc99fd4..8b91859 100644
--- a/src/crepe/api/Animator.cpp
+++ b/src/crepe/api/Animator.cpp
@@ -7,7 +7,7 @@
 
 using namespace crepe;
 
-Animator::Animator(uint32_t id, Sprite & ss, int max_row, int max_col,
+Animator::Animator(uint32_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
 				   const Animator::Data & ctx)
 	: Component(id),
 	  spritesheet(ss),
diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index dab6697..e0399a8 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -2,6 +2,8 @@
 
 #include "Component.h"
 #include "Sprite.h"
+#include "types.h"
+#include <sys/types.h>
 
 namespace crepe {
 
@@ -20,26 +22,26 @@ public:
 	struct Data {
 
 		//! frames per second for animation
-		int fps = 1;
+		unsigned int fps = 1;
 
 		//! The current col being animated.
-		int curr_col = 0;
+		unsigned int curr_col = 0;
 
 		//! The current row being animated.
-		int curr_row = 0;
+		unsigned int curr_row = 0;
 
 		//! should the animation loop
 		bool looping = false;
 
 		//! starting frame for cycling
-		int cycle_start = 0;
+		unsigned int cycle_start = 0;
 
 		//! end frame for cycling (-1 --> use last frame)
 		int cycle_end = -1;
 
 		//! offset in pixels.
 		// TODO implement
-		int offset_x = 0;
+		unsigned int white_space = 0;
 	};
 
 public:
@@ -100,12 +102,15 @@ public:
 	 * \brief Constructs an Animator object that will control animations for a sprite sheet.
 	 *
 	 * \param id The unique identifier for the component, typically assigned automatically.
-	 * \param ctx animator data
+	 * \param ss the reference to the spritesheet
+	 * \param max_row maximum of rows inside the given spritesheet
+	 * \param max_col maximum of columns inside the given spritesheet
+	 * \param ctx extra animation data for more control
 	 *
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(uint32_t id, Sprite & ss, int max_row, int max_col, const Animator::Data & ctx);
+	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col, const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
@@ -113,16 +118,13 @@ public:
 	Sprite & spritesheet;
 
 	//! The maximum number of columns in the sprite sheet.
-	const int col;
+	const unsigned int col;
 
 	//! The maximum number of rows in the sprite sheet.
-	const int row;
+	const unsigned int row;
 
 	Animator::Data data;
 
-private:
-	//! AnimatorSystem adjust the private member parameters of Animator;
-	friend class AnimatorSystem;
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/Camera.h b/src/crepe/api/Camera.h
index f626379..84ca9e1 100644
--- a/src/crepe/api/Camera.h
+++ b/src/crepe/api/Camera.h
@@ -23,7 +23,7 @@ public:
 		double zoom = 1;
 
 		//! offset postion from the game object transform component
-		vec2 offset;
+		vec2 postion_offset;
 	};
 
 public:
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index a1230db..0ccc296 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -20,11 +20,14 @@ class AnimatorSystem;
  */
 class Sprite : public Component {
 public:
+	//! settings to flip the image
 	struct FlipSettings {
+		//! horizantal flip
 		bool flip_x = false;
+		//! vertical flip
 		bool flip_y = false;
 	};
-
+	
 	struct Data {
 		//! Color tint of the sprite
 		Color color = Color::WHITE;
@@ -50,10 +53,13 @@ public:
 		vec2 size;
 
 		//! independent sprite angle. rotating clockwise direction in degrees
-		double angle_offset = 0;
+		float angle_offset = 0;
 
 		//! independent sprite scale multiplier
-		double scale_offset = 1;
+		float scale_offset = 1;
+
+		//! independent sprite offset position 
+		vec2 position_offset;
 	};
 
 public:
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 0097070..9533b8a 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -243,7 +243,7 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
-	vec2 screen_pos = (ctx.pos - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
+	vec2 screen_pos = (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
 					  - size / 2 + cam.bar_size;
 
 	return SDL_FRect{
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index 71bd1c9..5b53bcc 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -5,6 +5,7 @@
 // TODO: remove these singletons:
 #include "EventManager.h"
 #include "SaveManager.h"
+#include "../facade/SDLContext.h"
 
 namespace crepe {
 
@@ -28,6 +29,7 @@ struct Mediator {
 	OptionalRef<SceneManager> scene_manager;
 	OptionalRef<SaveManager> save_manager = SaveManager::get_instance();
 	OptionalRef<EventManager> event_manager = EventManager::get_instance();
+	OptionalRef<SDLContext> sdl_context = SDLContext::get_instance();
 };
 
 } // namespace crepe
diff --git a/src/crepe/system/InputSystem.cpp b/src/crepe/system/InputSystem.cpp
index 20da644..aaa8bdf 100644
--- a/src/crepe/system/InputSystem.cpp
+++ b/src/crepe/system/InputSystem.cpp
@@ -24,9 +24,9 @@ void InputSystem::update() {
 	RefVector<Transform> transform_vec
 		= mgr.get_components_by_id<Transform>(current_cam.game_object_id);
 	Transform & cam_transform = transform_vec.front().get();
-	int camera_origin_x = cam_transform.position.x + current_cam.data.offset.x
+	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.offset.y
+	int camera_origin_y = cam_transform.position.y + current_cam.data.postion_offset.y
 						  - (current_cam.viewport_size.y / 2);
 
 	for (const SDLContext::EventData & event : event_list) {
diff --git a/src/crepe/system/RenderSystem.cpp b/src/crepe/system/RenderSystem.cpp
index 111ad7d..0ba71ec 100644
--- a/src/crepe/system/RenderSystem.cpp
+++ b/src/crepe/system/RenderSystem.cpp
@@ -33,7 +33,7 @@ SDLContext::CameraValues RenderSystem::update_camera() {
 		const Transform & transform
 			= mgr.get_components_by_id<Transform>(cam.game_object_id).front().get();
 		SDLContext::CameraValues cam_val = this->context.set_camera(cam);
-		cam_val.cam_pos = transform.position + cam.data.offset;
+		cam_val.cam_pos = transform.position + cam.data.postion_offset;
 		return cam_val;
 	}
 	throw std::runtime_error("No active cameras in current scene");
diff --git a/src/crepe/system/RenderSystem.h b/src/crepe/system/RenderSystem.h
index eaf1213..91b386f 100644
--- a/src/crepe/system/RenderSystem.h
+++ b/src/crepe/system/RenderSystem.h
@@ -79,8 +79,7 @@ private:
 	 */
 
 private:
-	// FIXME: retrieve sdlcontext via mediator after #PR57
-	SDLContext & context = SDLContext::get_instance();
+	SDLContext & context = this->mediator.sdl_context;
 };
 
 } // namespace crepe
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 9d6b537..145bc5e 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -57,6 +57,7 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
+					 .position_offset = {100,0},
 				 });
 
 		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
-- 
cgit v1.2.3


From 70c1cd14ec4c4aca185d5a7e4a3749169f6425f4 Mon Sep 17 00:00:00 2001
From: JAROWMR <jarorutjes07@gmail.com>
Date: Fri, 6 Dec 2024 15:42:52 +0100
Subject: make format

---
 src/crepe/api/LoopManager.cpp        |  4 +-
 src/crepe/api/Rigidbody.h            |  1 -
 src/crepe/api/Script.h               |  2 +-
 src/crepe/system/CollisionSystem.cpp | 33 +++++--------
 src/crepe/system/CollisionSystem.h   |  2 +-
 src/example/game.cpp                 | 94 +++++++++++++++++-------------------
 src/test/CollisionTest.cpp           |  6 +--
 src/test/Profiling.cpp               |  6 +--
 8 files changed, 66 insertions(+), 82 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/LoopManager.cpp b/src/crepe/api/LoopManager.cpp
index 2c12895..a76c167 100644
--- a/src/crepe/api/LoopManager.cpp
+++ b/src/crepe/api/LoopManager.cpp
@@ -48,13 +48,13 @@ void LoopManager::loop() {
 
 	while (game_running) {
 		timer.update();
-		
+
 		while (timer.get_lag() >= timer.get_fixed_delta_time()) {
 			this->process_input();
 			this->fixed_update();
 			timer.advance_fixed_update();
 		}
-		
+
 		this->update();
 		this->render();
 
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index a6aab26..8265ba5 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -7,7 +7,6 @@
 
 #include "types.h"
 
-
 namespace crepe {
 
 /**
diff --git a/src/crepe/api/Script.h b/src/crepe/api/Script.h
index 3d416a1..d1be1dc 100644
--- a/src/crepe/api/Script.h
+++ b/src/crepe/api/Script.h
@@ -3,8 +3,8 @@
 #include <vector>
 
 #include "../manager/EventManager.h"
-#include "../system/CollisionSystem.h"
 #include "../manager/Mediator.h"
+#include "../system/CollisionSystem.h"
 #include "../types.h"
 #include "../util/OptionalRef.h"
 
diff --git a/src/crepe/system/CollisionSystem.cpp b/src/crepe/system/CollisionSystem.cpp
index e196e10..44a0431 100644
--- a/src/crepe/system/CollisionSystem.cpp
+++ b/src/crepe/system/CollisionSystem.cpp
@@ -6,6 +6,8 @@
 #include <utility>
 #include <variant>
 
+#include "../manager/ComponentManager.h"
+#include "../manager/EventManager.h"
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
 #include "api/Event.h"
@@ -13,8 +15,6 @@
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/Vector2.h"
-#include "../manager/ComponentManager.h"
-#include "../manager/EventManager.h"
 
 #include "Collider.h"
 #include "CollisionSystem.h"
@@ -27,17 +27,14 @@ void CollisionSystem::update() {
 	std::vector<CollisionInternal> all_colliders;
 	game_object_id_t id = 0;
 	ComponentManager & mgr = this->mediator.component_manager;
-	RefVector<Rigidbody> rigidbodies
-		= mgr.get_components_by_type<Rigidbody>();
+	RefVector<Rigidbody> rigidbodies = mgr.get_components_by_type<Rigidbody>();
 	// Collisions can only happen on object with a rigidbody
 	for (Rigidbody & rigidbody : rigidbodies) {
 		if (!rigidbody.active) continue;
 		id = rigidbody.game_object_id;
-		Transform & transform
-			= mgr.get_components_by_id<Transform>(id).front().get();
+		Transform & transform = mgr.get_components_by_id<Transform>(id).front().get();
 		// Check if the boxcollider is active and has the same id as the rigidbody.
-		RefVector<BoxCollider> boxcolliders
-			= mgr.get_components_by_type<BoxCollider>();
+		RefVector<BoxCollider> boxcolliders = mgr.get_components_by_type<BoxCollider>();
 		for (BoxCollider & boxcollider : boxcolliders) {
 			if (boxcollider.game_object_id != id) continue;
 			if (!boxcollider.active) continue;
@@ -159,7 +156,7 @@ CollisionSystem::collision_handler(CollisionInternal & data1, CollisionInternal
 			vec2 collider_pos2 = this->get_current_position(collider2.offset, data2.transform,
 															data2.rigidbody);
 			resolution = -this->get_circle_box_resolution(collider2, collider1, collider_pos2,
-														 collider_pos1);
+														  collider_pos1);
 			break;
 		}
 		case CollisionInternalType::CIRCLE_CIRCLE: {
@@ -261,7 +258,6 @@ vec2 CollisionSystem::get_circle_circle_resolution(const CircleCollider & circle
 
 	// Normalize the delta vector to get the collision direction
 	vec2 collision_normal = delta / distance;
-	
 
 	// Compute the resolution vector
 	vec2 resolution = -collision_normal * penetration_depth;
@@ -311,8 +307,7 @@ void CollisionSystem::determine_collision_handler(CollisionInfo & info) {
 	// Call collision event for user
 	CollisionEvent data(info);
 	EventManager & emgr = this->mediator.event_manager;
-	emgr.trigger_event<CollisionEvent>(
-		data, info.this_collider.game_object_id);
+	emgr.trigger_event<CollisionEvent>(data, info.this_collider.game_object_id);
 }
 
 void CollisionSystem::static_collision_handler(CollisionInfo & info) {
@@ -389,14 +384,14 @@ CollisionSystem::gather_collisions(std::vector<CollisionInternal> & colliders) {
 
 bool CollisionSystem::have_common_layer(const std::set<int> & layers1,
 										const std::set<int> & layers2) {
-	
+
 	// Check if any number is equal in the layers
 	for (int num : layers1) {
-			if (layers2.contains(num)) {
-					// Common layer found
-					return true;
-					break;
-			}
+		if (layers2.contains(num)) {
+			// Common layer found
+			return true;
+			break;
+		}
 	}
 	// No common layer found
 	return false;
@@ -554,5 +549,3 @@ vec2 CollisionSystem::get_current_position(const vec2 & collider_offset,
 	// Final positions considering scaling and rotation
 	return (transform.position + vec2(rotated_total_offset_x1, rotated_total_offset_y1));
 }
-
-
diff --git a/src/crepe/system/CollisionSystem.h b/src/crepe/system/CollisionSystem.h
index 6216af9..7e893c8 100644
--- a/src/crepe/system/CollisionSystem.h
+++ b/src/crepe/system/CollisionSystem.h
@@ -6,11 +6,11 @@
 
 #include "api/BoxCollider.h"
 #include "api/CircleCollider.h"
+#include "api/Event.h"
 #include "api/Metadata.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
 #include "api/Vector2.h"
-#include "api/Event.h"
 
 #include "Collider.h"
 #include "System.h"
diff --git a/src/example/game.cpp b/src/example/game.cpp
index be756bd..4239c15 100644
--- a/src/example/game.cpp
+++ b/src/example/game.cpp
@@ -1,6 +1,6 @@
 #include "api/CircleCollider.h"
-#include "manager/ComponentManager.h"
 #include "api/Scene.h"
+#include "manager/ComponentManager.h"
 #include "manager/Mediator.h"
 #include <crepe/api/BoxCollider.h>
 #include <crepe/api/Camera.h>
@@ -28,66 +28,60 @@ class MyScript1 : public Script {
 	bool keypressed(const KeyPressEvent & test) {
 		Log::logf("Box script keypressed()");
 		switch (test.key) {
-			case Keycode::A:
-			{
+			case Keycode::A: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x -= 1;
 				break;
 			}
-			case Keycode::W:
-			{
+			case Keycode::W: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y -= 1;
 				break;
 			}
-			case Keycode::S:
-			{
+			case Keycode::S: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y += 1;
 				break;
 			}
-			case Keycode::D:
-			{
+			case Keycode::D: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x += 1;
 				break;
 			}
-			case Keycode::E:
-			{
-				if(flip){
+			case Keycode::E: {
+				if (flip) {
 					flip = false;
 					this->get_component<BoxCollider>().active = true;
 					this->get_components<Sprite>()[0].get().active = true;
 					this->get_component<CircleCollider>().active = false;
 					this->get_components<Sprite>()[1].get().active = false;
-				}
-				else {
+				} else {
 					flip = true;
 					this->get_component<BoxCollider>().active = false;
 					this->get_components<Sprite>()[0].get().active = false;
 					this->get_component<CircleCollider>().active = true;
 					this->get_components<Sprite>()[1].get().active = true;
 				}
-				
-				
+
 				//add collider switch
 				break;
 			}
 			default:
-			break;
+				break;
 		}
 		return false;
-	} 
+	}
 
 	void init() {
 		Log::logf("init");
-		subscribe<CollisionEvent>([this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
-		subscribe<KeyPressEvent>([this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+		subscribe<KeyPressEvent>(
+			[this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
-	
 };
 
 class MyScript2 : public Script {
@@ -99,74 +93,68 @@ class MyScript2 : public Script {
 	bool keypressed(const KeyPressEvent & test) {
 		Log::logf("Box script keypressed()");
 		switch (test.key) {
-			case Keycode::LEFT:
-			{
+			case Keycode::LEFT: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x -= 1;
 				break;
 			}
-			case Keycode::UP:
-			{
+			case Keycode::UP: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y -= 1;
 				break;
 			}
-			case Keycode::DOWN:
-			{
+			case Keycode::DOWN: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.y += 1;
 				break;
 			}
-			case Keycode::RIGHT:
-			{
+			case Keycode::RIGHT: {
 				Transform & tf = this->get_component<Transform>();
 				tf.position.x += 1;
 				break;
 			}
-			case Keycode::PAUSE:
-			{
-				if(flip){
+			case Keycode::PAUSE: {
+				if (flip) {
 					flip = false;
 					this->get_component<BoxCollider>().active = true;
 					this->get_components<Sprite>()[0].get().active = true;
 					this->get_component<CircleCollider>().active = false;
 					this->get_components<Sprite>()[1].get().active = false;
-				}
-				else {
+				} else {
 					flip = true;
 					this->get_component<BoxCollider>().active = false;
 					this->get_components<Sprite>()[0].get().active = false;
 					this->get_component<CircleCollider>().active = true;
 					this->get_components<Sprite>()[1].get().active = true;
 				}
-				
-				
+
 				//add collider switch
 				break;
 			}
 			default:
-			break;
+				break;
 		}
 		return false;
-	} 
+	}
 
 	void init() {
 		Log::logf("init");
-		subscribe<CollisionEvent>([this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
-		subscribe<KeyPressEvent>([this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
+		subscribe<CollisionEvent>(
+			[this](const CollisionEvent & ev) -> bool { return this->oncollision(ev); });
+		subscribe<KeyPressEvent>(
+			[this](const KeyPressEvent & ev) -> bool { return this->keypressed(ev); });
 	}
 	void update() {
 		// Retrieve component from the same GameObject this script is on
 	}
-	
 };
 
 class ConcreteScene1 : public Scene {
 public:
 	using Scene::Scene;
-	
+
 	void load_scene() {
-		
+
 		Mediator & m = this->mediator;
 		ComponentManager & mgr = m.component_manager;
 		Color color(0, 0, 0, 255);
@@ -195,7 +183,10 @@ public:
 			vec2{world_collider, world_collider}); // Left
 		world.add_component<BoxCollider>(vec2{screen_size_width / 2 + world_collider / 2, 0},
 										 vec2{world_collider, world_collider}); // right
-		world.add_component<Camera>(Color::WHITE, ivec2{static_cast<int>(screen_size_width), static_cast<int>(screen_size_height)}, vec2{screen_size_width, screen_size_height}, 1.0f);
+		world.add_component<Camera>(
+			Color::WHITE,
+			ivec2{static_cast<int>(screen_size_width), static_cast<int>(screen_size_height)},
+			vec2{screen_size_width, screen_size_height}, 1.0f);
 
 		GameObject game_object1 = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
@@ -219,10 +210,10 @@ public:
 		//add circle with cirlcecollider deactiveated
 		game_object1.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
 		auto img2 = Texture("asset/texture/circle.png");
-		game_object1.add_component<Sprite>(img2, color, Sprite::FlipSettings{false, false}, 1,
-										   1, 20).active = false;
-
-
+		game_object1
+			.add_component<Sprite>(img2, color, Sprite::FlipSettings{false, false}, 1, 1, 20)
+			.active
+			= false;
 
 		GameObject game_object2 = mgr.new_object(
 			"Name", "Tag", vec2{screen_size_width / 2, screen_size_height / 2}, 0, 1);
@@ -246,9 +237,10 @@ public:
 		//add circle with cirlcecollider deactiveated
 		game_object2.add_component<CircleCollider>(vec2{0, 0}, 10).active = false;
 		auto img4 = Texture("asset/texture/circle.png");
-		game_object2.add_component<Sprite>(img4, color, Sprite::FlipSettings{false, false}, 1,
-										   1, 20).active = false;
-
+		game_object2
+			.add_component<Sprite>(img4, color, Sprite::FlipSettings{false, false}, 1, 1, 20)
+			.active
+			= false;
 	}
 
 	string get_name() const { return "scene1"; }
diff --git a/src/test/CollisionTest.cpp b/src/test/CollisionTest.cpp
index a683b1f..dd45eb6 100644
--- a/src/test/CollisionTest.cpp
+++ b/src/test/CollisionTest.cpp
@@ -7,14 +7,14 @@
 #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/manager/ComponentManager.h>
+#include <crepe/manager/EventManager.h>
+#include <crepe/manager/Mediator.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
diff --git a/src/test/Profiling.cpp b/src/test/Profiling.cpp
index 6a6c29f..24ac494 100644
--- a/src/test/Profiling.cpp
+++ b/src/test/Profiling.cpp
@@ -9,14 +9,14 @@
 #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/manager/ComponentManager.h>
+#include <crepe/manager/EventManager.h>
 #include <crepe/system/CollisionSystem.h>
 #include <crepe/system/ScriptSystem.h>
 #include <crepe/types.h>
@@ -162,7 +162,7 @@ TEST_F(Profiling, Profiling_2) {
 				.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/square.png");
-- 
cgit v1.2.3


From 83ee80ea439fc6a9042307a25b214b3efcf28d91 Mon Sep 17 00:00:00 2001
From: heavydemon21 <nielsstunnebrink1@gmail.com>
Date: Fri, 6 Dec 2024 15:42:52 +0100
Subject: make format

---
 src/crepe/api/Animator.h           | 4 ++--
 src/crepe/api/Sprite.h             | 4 ++--
 src/crepe/facade/SDLContext.cpp    | 6 ++++--
 src/crepe/manager/Mediator.h       | 2 +-
 src/example/rendering_particle.cpp | 2 +-
 5 files changed, 10 insertions(+), 8 deletions(-)

(limited to 'src/example')

diff --git a/src/crepe/api/Animator.h b/src/crepe/api/Animator.h
index e0399a8..2a0a889 100644
--- a/src/crepe/api/Animator.h
+++ b/src/crepe/api/Animator.h
@@ -110,7 +110,8 @@ public:
 	 * This constructor sets up the Animator with the given parameters, and initializes the
 	 * animation system.
 	 */
-	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col, const Animator::Data & ctx);
+	Animator(game_object_id_t id, Sprite & ss, unsigned int max_row, unsigned int max_col,
+			 const Animator::Data & ctx);
 	~Animator(); // dbg_trace
 
 public:
@@ -124,7 +125,6 @@ public:
 	const unsigned int row;
 
 	Animator::Data data;
-
 };
 } // namespace crepe
 //
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 0ccc296..78ed7ad 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -27,7 +27,7 @@ public:
 		//! vertical flip
 		bool flip_y = false;
 	};
-	
+
 	struct Data {
 		//! Color tint of the sprite
 		Color color = Color::WHITE;
@@ -58,7 +58,7 @@ public:
 		//! independent sprite scale multiplier
 		float scale_offset = 1;
 
-		//! independent sprite offset position 
+		//! independent sprite offset position
 		vec2 position_offset;
 	};
 
diff --git a/src/crepe/facade/SDLContext.cpp b/src/crepe/facade/SDLContext.cpp
index 9533b8a..cf9f7d5 100644
--- a/src/crepe/facade/SDLContext.cpp
+++ b/src/crepe/facade/SDLContext.cpp
@@ -243,8 +243,10 @@ SDL_FRect SDLContext::get_dst_rect(const DstRect & ctx) const {
 
 	size *= cam.render_scale * ctx.img_scale * data.scale_offset;
 
-	vec2 screen_pos = (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2) * cam.render_scale
-					  - size / 2 + cam.bar_size;
+	vec2 screen_pos
+		= (ctx.pos + data.position_offset - cam.cam_pos + (cam.zoomed_viewport) / 2)
+			  * cam.render_scale
+		  - size / 2 + cam.bar_size;
 
 	return SDL_FRect{
 		.x = screen_pos.x,
diff --git a/src/crepe/manager/Mediator.h b/src/crepe/manager/Mediator.h
index 5b53bcc..f8517a3 100644
--- a/src/crepe/manager/Mediator.h
+++ b/src/crepe/manager/Mediator.h
@@ -3,9 +3,9 @@
 #include "../util/OptionalRef.h"
 
 // TODO: remove these singletons:
+#include "../facade/SDLContext.h"
 #include "EventManager.h"
 #include "SaveManager.h"
-#include "../facade/SDLContext.h"
 
 namespace crepe {
 
diff --git a/src/example/rendering_particle.cpp b/src/example/rendering_particle.cpp
index 145bc5e..29d475d 100644
--- a/src/example/rendering_particle.cpp
+++ b/src/example/rendering_particle.cpp
@@ -57,7 +57,7 @@ public:
 					 .order_in_layer = 2,
 					 .size = {0, 100},
 					 .angle_offset = 0,
-					 .position_offset = {100,0},
+					 .position_offset = {100, 0},
 				 });
 
 		auto & anim = game_object.add_component<Animator>(test_sprite, 4, 4,
-- 
cgit v1.2.3