Merge branch 'master' of https://github.com/lonkaars/crepe into wouter/events-poc

19 files changed, 336 insertions, 334 deletions

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 1ea4738..9a9b1ea 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,71 +1,4 @@
 {
 	"cmake.sourceDirectory": "${workspaceFolder}/src",
-	"files.associations": {
-		"functional": "cpp",
-		"array": "cpp",
-		"atomic": "cpp",
-		"bit": "cpp",
-		"*.tcc": "cpp",
-		"cctype": "cpp",
-		"charconv": "cpp",
-		"chrono": "cpp",
-		"clocale": "cpp",
-		"cmath": "cpp",
-		"compare": "cpp",
-		"concepts": "cpp",
-		"cstdarg": "cpp",
-		"cstddef": "cpp",
-		"cstdint": "cpp",
-		"cstdio": "cpp",
-		"cstdlib": "cpp",
-		"cstring": "cpp",
-		"ctime": "cpp",
-		"cwchar": "cpp",
-		"cwctype": "cpp",
-		"deque": "cpp",
-		"list": "cpp",
-		"map": "cpp",
-		"string": "cpp",
-		"unordered_map": "cpp",
-		"vector": "cpp",
-		"exception": "cpp",
-		"algorithm": "cpp",
-		"iterator": "cpp",
-		"memory": "cpp",
-		"memory_resource": "cpp",
-		"numeric": "cpp",
-		"optional": "cpp",
-		"random": "cpp",
-		"ratio": "cpp",
-		"string_view": "cpp",
-		"system_error": "cpp",
-		"tuple": "cpp",
-		"type_traits": "cpp",
-		"utility": "cpp",
-		"format": "cpp",
-		"initializer_list": "cpp",
-		"iomanip": "cpp",
-		"iosfwd": "cpp",
-		"iostream": "cpp",
-		"istream": "cpp",
-		"limits": "cpp",
-		"new": "cpp",
-		"numbers": "cpp",
-		"ostream": "cpp",
-		"semaphore": "cpp",
-		"span": "cpp",
-		"sstream": "cpp",
-		"stdexcept": "cpp",
-		"stop_token": "cpp",
-		"streambuf": "cpp",
-		"thread": "cpp",
-		"cinttypes": "cpp",
-		"typeinfo": "cpp",
-		"valarray": "cpp",
-		"variant": "cpp",
-		"forward_list": "cpp",
-		"codecvt": "cpp",
-		"fstream": "cpp",
-		"typeindex": "cpp"
-	}
+	"C_Cpp.autoAddFileAssociations": false
 }
diff --git a/mwe/.vscode/settings.json b/mwe/.vscode/settings.json
deleted file mode 100644
index c7913ab..0000000
--- a/mwe/.vscode/settings.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-    "files.associations": {
-        "variant": "cpp",
-        "*.tcc": "cpp",
-        "string": "cpp",
-        "unordered_map": "cpp",
-        "string_view": "cpp",
-        "ostream": "cpp",
-        "iostream": "cpp"
-    }
-}
diff --git a/mwe/audio/miniaudio/CMakeLists.txt b/mwe/audio/miniaudio/CMakeLists.txt
new file mode 100644
index 0000000..6dd0191
--- /dev/null
+++ b/mwe/audio/miniaudio/CMakeLists.txt
@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 3.28)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
+set(CMAKE_BUILD_TYPE Debug)
+
+add_subdirectory(../../../lib/miniaudio miniaudio)
+
+project(poc C CXX)
+
+add_executable(main
+	main.cpp
+)
+
+target_link_libraries(main
+	miniaudio
+)
+
diff --git a/mwe/audio/miniaudio/main.cpp b/mwe/audio/miniaudio/main.cpp
new file mode 100644
index 0000000..bf31898
--- /dev/null
+++ b/mwe/audio/miniaudio/main.cpp
@@ -0,0 +1,46 @@
+#include <miniaudio.h>
+
+#include <chrono>
+#include <thread>
+
+using namespace std;
+using namespace std::chrono_literals;
+
+int main() {
+	ma_engine engine;
+	ma_engine_init(NULL, &engine);
+
+	// 1. load background track (ogg vorbis)
+	ma_sound bgm;
+	ma_sound_init_from_file(&engine, "../bgm.ogg", 0, NULL, NULL, &bgm);
+
+	// 2. load samples (wav)
+	ma_sound sfx[3];
+	ma_sound_init_from_file(&engine, "../sfx1.wav", 0, NULL, NULL, &sfx[0]);
+	ma_sound_init_from_file(&engine, "../sfx2.wav", 0, NULL, NULL, &sfx[1]);
+	ma_sound_init_from_file(&engine, "../sfx3.wav", 0, NULL, NULL, &sfx[2]);
+
+	// 3. start the background track
+	ma_sound_start(&bgm);
+
+	// 4. play samples sequentially while controlling the background track
+	this_thread::sleep_for(500ms);
+	ma_sound_start(&sfx[0]);
+	this_thread::sleep_for(500ms);
+	ma_sound_start(&sfx[1]);
+	ma_sound_stop(&bgm);
+	this_thread::sleep_for(500ms);
+	ma_sound_start(&sfx[2]);
+	ma_sound_start(&bgm); // this actually resumes now
+	this_thread::sleep_for(500ms);
+	for (unsigned i = 0; i < 3; i++)
+		ma_sound_seek_to_pcm_frame(&sfx[i], 0);
+
+	// 5. play all samples simultaniously
+	for (unsigned i = 0; i < 3; i++)
+		ma_sound_start(&sfx[i]);
+	this_thread::sleep_for(1000ms);
+
+	ma_engine_uninit(&engine);
+	return 0;
+}
diff --git a/mwe/events/.vscode/settings.json b/mwe/events/.vscode/settings.json
deleted file mode 100644
index 2b1a397..0000000
--- a/mwe/events/.vscode/settings.json
+++ /dev/null
@@ -1,68 +0,0 @@
-{
-	"files.associations": {
-		"iostream": "cpp",
-		"array": "cpp",
-		"atomic": "cpp",
-		"bit": "cpp",
-		"*.tcc": "cpp",
-		"cctype": "cpp",
-		"clocale": "cpp",
-		"cmath": "cpp",
-		"compare": "cpp",
-		"concepts": "cpp",
-		"cstdarg": "cpp",
-		"cstddef": "cpp",
-		"cstdint": "cpp",
-		"cstdio": "cpp",
-		"cstdlib": "cpp",
-		"cwchar": "cpp",
-		"cwctype": "cpp",
-		"deque": "cpp",
-		"list": "cpp",
-		"map": "cpp",
-		"string": "cpp",
-		"unordered_map": "cpp",
-		"vector": "cpp",
-		"exception": "cpp",
-		"algorithm": "cpp",
-		"functional": "cpp",
-		"iterator": "cpp",
-		"memory": "cpp",
-		"memory_resource": "cpp",
-		"numeric": "cpp",
-		"optional": "cpp",
-		"random": "cpp",
-		"string_view": "cpp",
-		"system_error": "cpp",
-		"tuple": "cpp",
-		"type_traits": "cpp",
-		"utility": "cpp",
-		"initializer_list": "cpp",
-		"iosfwd": "cpp",
-		"istream": "cpp",
-		"limits": "cpp",
-		"new": "cpp",
-		"numbers": "cpp",
-		"ostream": "cpp",
-		"sstream": "cpp",
-		"stdexcept": "cpp",
-		"streambuf": "cpp",
-		"cinttypes": "cpp",
-		"typeinfo": "cpp",
-		"valarray": "cpp",
-		"variant": "cpp",
-		"condition_variable": "cpp",
-		"ctime": "cpp",
-		"forward_list": "cpp",
-		"executor": "cpp",
-		"io_context": "cpp",
-		"netfwd": "cpp",
-		"ratio": "cpp",
-		"timer": "cpp",
-		"future": "cpp",
-		"mutex": "cpp",
-		"semaphore": "cpp",
-		"stop_token": "cpp",
-		"thread": "cpp"
-	}
-}
diff --git a/mwe/events/include/customTypes.h b/mwe/events/include/customTypes.h
index 7217f8a..a5d8dc9 100644
--- a/mwe/events/include/customTypes.h
+++ b/mwe/events/include/customTypes.h
@@ -1,39 +1,38 @@
 #pragma once
 #include <cmath>
 struct Vector2 {
-    float x; // X component of the vector
-    float y; // Y component of the vector
+	float x; // X component of the vector
+	float y; // Y component of the vector
 
-    // Vector subtraction
-    Vector2 operator-(const Vector2& other) const {
-        return {x - other.x, y - other.y};
-    }
+	// Vector subtraction
+	Vector2 operator-(const Vector2 & other) const {
+		return {x - other.x, y - other.y};
+	}
 
-    // Vector addition
-    Vector2 operator+(const Vector2& other) const {
-        return {x + other.x, y + other.y};
-    }
+	// Vector addition
+	Vector2 operator+(const Vector2 & other) const {
+		return {x + other.x, y + other.y};
+	}
 
-    // Scalar multiplication
-    Vector2 operator*(float scalar) const {
-        return {x * scalar, y * scalar};
-    }
+	// Scalar multiplication
+	Vector2 operator*(float scalar) const { return {x * scalar, y * scalar}; }
 
-    // Normalize the vector
-    Vector2 normalize() const {
-        float length = std::sqrt(x * x + y * y);
-        if (length == 0) return {0, 0}; // Prevent division by zero
-        return {x / length, y / length};
-    }
+	// Normalize the vector
+	Vector2 normalize() const {
+		float length = std::sqrt(x * x + y * y);
+		if (length == 0) return {0, 0}; // Prevent division by zero
+		return {x / length, y / length};
+	}
 };
 struct Collision {
-    int objectIdA;          // ID of the first object
-    int objectIdB;          // ID of the second object
-    Vector2 contactPoint;   // Point of contact
-    Vector2 contactNormal;  // Normal vector at the contact point
-
-    // Constructor to initialize a Collision
-    Collision(int idA, int idB, const Vector2& point, const Vector2& normal, float depth)
-        : objectIdA(idA), objectIdB(idB), contactPoint(point), contactNormal(normal) {}
+	int objectIdA; // ID of the first object
+	int objectIdB; // ID of the second object
+	Vector2 contactPoint; // Point of contact
+	Vector2 contactNormal; // Normal vector at the contact point
 
+	// Constructor to initialize a Collision
+	Collision(int idA, int idB, const Vector2 & point, const Vector2 & normal,
+			  float depth)
+		: objectIdA(idA), objectIdB(idB), contactPoint(point),
+		  contactNormal(normal) {}
 };
diff --git a/mwe/events/include/event.h b/mwe/events/include/event.h
index b1b6867..62d8974 100644
--- a/mwe/events/include/event.h
+++ b/mwe/events/include/event.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "customTypes.h"
 #include "keyCodes.h"
 #include <cstdint>
 #include <iostream>
@@ -129,15 +130,14 @@ private:
 };
 class CollisionEvent : public Event {
 public:
-    CollisionEvent(Collision);
+	CollisionEvent(Collision);
 
-    REGISTER_EVENT_TYPE(CollisionEvent)
+	REGISTER_EVENT_TYPE(CollisionEvent)
 
-    Collision getCollisionData() const;
+	Collision getCollisionData() const;
 
 private:
-   	Collision collisionData;
-    
+	Collision collisionData;
 };
 class TextSubmitEvent : public Event {
 public:
diff --git a/mwe/events/include/eventManager.h b/mwe/events/include/eventManager.h
index 61e8c01..508a5e2 100644
--- a/mwe/events/include/eventManager.h
+++ b/mwe/events/include/eventManager.h
@@ -28,10 +28,14 @@ public:
 	void dispatchEvents();
 
 private:
-    EventManager() = default;
-    std::vector<std::pair<std::unique_ptr<Event>, int>> eventsQueue;
-    std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> subscribers;
-    std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>> subscribersByEventId;
+	EventManager() = default;
+	std::vector<std::pair<std::unique_ptr<Event>, int>> eventsQueue;
+	std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>
+		subscribers;
+	std::unordered_map<
+		int, std::unordered_map<
+				 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>
+		subscribersByEventId;
 };
 
 template <typename EventType>
diff --git a/mwe/events/src/event.cpp b/mwe/events/src/event.cpp
index 0a7454d..eae4d14 100644
--- a/mwe/events/src/event.cpp
+++ b/mwe/events/src/event.cpp
@@ -44,12 +44,10 @@ std::pair<int, int> MousePressedEvent::getMousePosition() const {
 }
 
 //Collision event
-CollisionEvent::CollisionEvent(Collision collision) : collisionData(collision), Event("CollisionEvent") {
+CollisionEvent::CollisionEvent(Collision collision)
+	: collisionData(collision), Event("CollisionEvent") {}
 
-}
-
-Collision CollisionEvent::getCollisionData() const
-{
+Collision CollisionEvent::getCollisionData() const {
 	return this->collisionData;
 }
 
diff --git a/mwe/events/src/eventManager.cpp b/mwe/events/src/eventManager.cpp
index c37dcb0..34a093d 100644
--- a/mwe/events/src/eventManager.cpp
+++ b/mwe/events/src/eventManager.cpp
@@ -1,98 +1,130 @@
 #include "eventManager.h"
 
-void EventManager::shutdown()
-{
-    subscribers.clear();
-}
+void EventManager::shutdown() { subscribers.clear(); }
 
-void EventManager::subscribe(int eventType, std::unique_ptr<IEventHandlerWrapper>&& handler, int eventId)
-{
-    if (eventId) {
-        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscribers = subscribersByEventId.find(eventType);
+void EventManager::subscribe(int eventType,
+							 std::unique_ptr<IEventHandlerWrapper> && handler,
+							 int eventId) {
+	if (eventId) {
+		std::unordered_map<
+			int, std::unordered_map<
+					 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
+			iterator subscribers
+			= subscribersByEventId.find(eventType);
 
-        if (subscribers != subscribersByEventId.end()) {
-            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscribers->second;
-            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
-            if (handlers != handlersMap.end()) {
-                handlers->second.emplace_back(std::move(handler));
-                return;
-            }
-        }
-        subscribersByEventId[eventType][eventId].emplace_back(std::move(handler));
+		if (subscribers != subscribersByEventId.end()) {
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+				handlersMap
+				= subscribers->second;
+			std::unordered_map<
+				int,
+				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+				handlers
+				= handlersMap.find(eventId);
+			if (handlers != handlersMap.end()) {
+				handlers->second.emplace_back(std::move(handler));
+				return;
+			}
+		}
+		subscribersByEventId[eventType][eventId].emplace_back(
+			std::move(handler));
 
-    } else {
-        auto& handlers = subscribers[eventType];
-    	handlers.emplace_back(std::move(handler));
-    }
+	} else {
+		auto & handlers = subscribers[eventType];
+		handlers.emplace_back(std::move(handler));
+	}
 }
 
-void EventManager::unsubscribe(int eventType, const std::string& handlerName, int eventId)
-{
-    if (eventId) {
-        std::unordered_map<int, std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::iterator subscriberList = subscribersByEventId.find(eventType);
-        if (subscriberList != subscribersByEventId.end()) {
-            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>& handlersMap = subscriberList->second;
-            std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlers = handlersMap.find(eventId);
-            if (handlers != handlersMap.end()) {
-                std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlers->second;
-                for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = callbacks.begin(); it != callbacks.end(); ++it) {
-                    if (it->get()->getType() == handlerName) {
-                        it = callbacks.erase(it);
-                        return;
-                    }
-                }
-            }
-        }
-    } else {
-        std::unordered_map<int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator handlersIt = subscribers.find(eventType);
-        if (handlersIt != subscribers.end()) {
-            std::vector<std::unique_ptr<IEventHandlerWrapper>>& handlers = handlersIt->second;
-            for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it = handlers.begin(); it != handlers.end(); ++it) {
-                if (it->get()->getType() == handlerName) {
-                    it = handlers.erase(it);
-                    return;
-                }
-            }
-        }
-    }
+void EventManager::unsubscribe(int eventType, const std::string & handlerName,
+							   int eventId) {
+	if (eventId) {
+		std::unordered_map<
+			int, std::unordered_map<
+					 int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>>::
+			iterator subscriberList
+			= subscribersByEventId.find(eventType);
+		if (subscriberList != subscribersByEventId.end()) {
+			std::unordered_map<
+				int, std::vector<std::unique_ptr<IEventHandlerWrapper>>> &
+				handlersMap
+				= subscriberList->second;
+			std::unordered_map<
+				int,
+				std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+				handlers
+				= handlersMap.find(eventId);
+			if (handlers != handlersMap.end()) {
+				std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
+					= handlers->second;
+				for (std::vector<
+						 std::unique_ptr<IEventHandlerWrapper>>::iterator it
+					 = callbacks.begin();
+					 it != callbacks.end(); ++it) {
+					if (it->get()->getType() == handlerName) {
+						it = callbacks.erase(it);
+						return;
+					}
+				}
+			}
+		}
+	} else {
+		std::unordered_map<
+			int, std::vector<std::unique_ptr<IEventHandlerWrapper>>>::iterator
+			handlersIt
+			= subscribers.find(eventType);
+		if (handlersIt != subscribers.end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & handlers
+				= handlersIt->second;
+			for (std::vector<std::unique_ptr<IEventHandlerWrapper>>::iterator it
+				 = handlers.begin();
+				 it != handlers.end(); ++it) {
+				if (it->get()->getType() == handlerName) {
+					it = handlers.erase(it);
+					return;
+				}
+			}
+		}
+	}
 }
 
-void EventManager::triggerEvent(const Event& event_, int eventId)
-{
-    if (eventId > 0) {
-        auto handlersIt = subscribersByEventId[event_.getEventType()].find(eventId);
-        if (handlersIt != subscribersByEventId[event_.getEventType()].end()) {
-            std::vector<std::unique_ptr<IEventHandlerWrapper>>& callbacks = handlersIt->second;
-            for (auto it = callbacks.begin(); it != callbacks.end();) {
-                (*it)->exec(event_);
-                if ((*it)->isDestroyOnSuccess()) {
-                    it = callbacks.erase(it);
-                } else {
-                    ++it;
-                }
-            }
-        }
-    } else {
-        auto& handlers = subscribers[event_.getEventType()];
-        for (std::unique_ptr<IEventHandlerWrapper>& handler : handlers) {
-            handler->exec(event_);
-        }
-    }
+void EventManager::triggerEvent(const Event & event_, int eventId) {
+	if (eventId > 0) {
+		auto handlersIt
+			= subscribersByEventId[event_.getEventType()].find(eventId);
+		if (handlersIt != subscribersByEventId[event_.getEventType()].end()) {
+			std::vector<std::unique_ptr<IEventHandlerWrapper>> & callbacks
+				= handlersIt->second;
+			for (auto it = callbacks.begin(); it != callbacks.end();) {
+				(*it)->exec(event_);
+				if ((*it)->isDestroyOnSuccess()) {
+					it = callbacks.erase(it);
+				} else {
+					++it;
+				}
+			}
+		}
+	} else {
+		auto & handlers = subscribers[event_.getEventType()];
+		for (std::unique_ptr<IEventHandlerWrapper> & handler : handlers) {
+			handler->exec(event_);
+		}
+	}
 }
 
-void EventManager::queueEvent(std::unique_ptr<Event>&& event_, int eventId)
-{
-    eventsQueue.emplace_back(std::move(event_), eventId);
+void EventManager::queueEvent(std::unique_ptr<Event> && event_, int eventId) {
+	eventsQueue.emplace_back(std::move(event_), eventId);
 }
 
-void EventManager::dispatchEvents()
-{
-    for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt = eventsQueue.begin(); eventIt != eventsQueue.end();) {
-        if (!eventIt->first.get()->getHandled()) {
-            triggerEvent(*eventIt->first.get(), eventIt->second);
-            eventIt = eventsQueue.erase(eventIt);
-        } else {
-            ++eventIt;
-        }
-    }
+void EventManager::dispatchEvents() {
+	for (std::vector<std::pair<std::unique_ptr<Event>, int>>::iterator eventIt
+		 = eventsQueue.begin();
+		 eventIt != eventsQueue.end();) {
+		if (!eventIt->first.get()->getHandled()) {
+			triggerEvent(*eventIt->first.get(), eventIt->second);
+			eventIt = eventsQueue.erase(eventIt);
+		} else {
+			++eventIt;
+		}
+	}
 }
diff --git a/mwe/events/src/main.cpp b/mwe/events/src/main.cpp
index 8fd6d10..972fc70 100644
--- a/mwe/events/src/main.cpp
+++ b/mwe/events/src/main.cpp
@@ -1,3 +1,4 @@
+#include "customTypes.h"
 #include "event.h"
 #include "loopManager.h"
 #include <SDL2/SDL.h>
@@ -17,9 +18,9 @@ public:
 
 	REGISTER_EVENT_TYPE(PlayerDamagedEvent);
 
-    int getDamage() const { return damage; }
-    int getPlayerID() const { return playerID; }
-	
+	int getDamage() const { return damage; }
+	int getPlayerID() const { return playerID; }
+
 private:
 	int damage;
 	int playerID;
@@ -29,22 +30,22 @@ void onPlayerDamaged(const PlayerDamagedEvent & e) {
 			  << " damage." << std::endl;
 }
 
-void onKeyPressed1(const KeyPressedEvent& e)
-{
-   int keyCode = e.getKeyCode();
-	fprintf(stderr,"first function KeyCode %d\n",keyCode);
+void onKeyPressed1(const KeyPressedEvent & e) {
+	int keyCode = e.getKeyCode();
+	fprintf(stderr, "first function KeyCode %d\n", keyCode);
 }
-void onKeyPressed(const KeyPressedEvent& e)
-{
-   int keyCode = e.getKeyCode();
-	fprintf(stderr,"second function KeyCode %d\n",keyCode);
+void onKeyPressed(const KeyPressedEvent & e) {
+	int keyCode = e.getKeyCode();
+	fprintf(stderr, "second function KeyCode %d\n", keyCode);
 }
-void CollisionHandler(const CollisionEvent& e){
-	std::cout << "collision between object id: "<< e.getCollisionData().objectIdA << " and id: " << e.getCollisionData().objectIdB << std::endl;
+void CollisionHandler(const CollisionEvent & e) {
+	std::cout << "collision betwee object id: "
+			  << e.getCollisionData().objectIdA
+			  << " and id: " << e.getCollisionData().objectIdB << std::endl;
 }
 void testCollisionEvent() {
 	Collision testCollision(1, 2, {3, 4}, {5, 6}, 7.8f);
-	subscribe<CollisionEvent>(CollisionHandler,1);
+	subscribe<CollisionEvent>(CollisionHandler, 1);
 	// EventHandler<PlayerDamagedEvent>
 	triggerEvent(CollisionEvent(testCollision), 1);
 }
@@ -56,16 +57,32 @@ int main(int argc, char * args[]) {
 	// custom event class poc
 	subscribe<PlayerDamagedEvent>(onPlayerDamaged);
 	triggerEvent(PlayerDamagedEvent(50, 1));
-    subscribe<KeyPressedEvent>(onKeyPressed,1,false);
-    subscribe<KeyPressedEvent>(onKeyPressed1,false);
-    // queueEvent(std::move(anotherKeyPressEvent));
-    triggerEvent(KeyPressedEvent(42), 1);
-	
+	subscribe<KeyPressedEvent>(onKeyPressed, 1, false);
+	subscribe<KeyPressedEvent>(onKeyPressed1, false);
+	// queueEvent(std::move(anotherKeyPressEvent));
+	triggerEvent(KeyPressedEvent(42), 1);
+
 	EventManager::getInstance().dispatchEvents();
 	//collision event call
 	testCollisionEvent();
-	
+
 	gameLoop.setup();
 	gameLoop.loop();
 	return 0;
 }
+// void collisionUpdate(){
+// 	int count;
+// 	//iedere collision
+// 	for (int i = 0; i < count; i++)
+// 	{
+// 		//trigger object 1
+// 		//triger object 2
+// 		triggerEvent(CollisionEvent(1,2),1);
+// 		triggerEvent(CollisionEvent(1,2),2);
+// 	}
+
+// }
+// int main(){
+
+// 	return 0;
+// }
diff --git a/readme.md b/readme.md
index f09c947..8ce6d78 100644
--- a/readme.md
+++ b/readme.md
@@ -19,28 +19,29 @@ building instructions.
 ## Installing libraries
 
 The expected library (source) versions are included in this repository as git
-submodules. Follow these steps for manually building one of the required
-libraries from source:
+submodules, which may be used if your distro's package manager does not provide
+(recent enough versions of) them. To build any of the dependencies, make sure
+the submodules are initialized by running:
 
-1. Ensure the git submodules are initialized:
-   ```
-   $ git submodule update --init --recursive --depth 1
-   ```
-2. `cd` into the library source folder:
+```
+$ git submodule update --init --recursive --depth 1
+```
+
+Then, follow these steps for each library you want to install:
+
+1. Change into the library folder (run **one** of these):
    ```
    $ cd lib/googletest
-   or
    $ cd lib/sdl2
-   or
    $ cd lib/soloud/contrib
-   or
    $ cd lib/sdl_image
    ```
-3. Configure the build, run the build and install:
+2. Use CMake to configure the build, run the build and install (run **all** of
+   these):
    ```
    $ cmake -B build -G Ninja
-   $ ninja -C build
-   # ninja -C build install
+   $ cmake --build build
+   # cmake --install build
    ```
 
 ## Documentation
diff --git a/src/crepe/ScriptSystem.cpp b/src/crepe/ScriptSystem.cpp
index d00d474..171b490 100644
--- a/src/crepe/ScriptSystem.cpp
+++ b/src/crepe/ScriptSystem.cpp
@@ -37,6 +37,7 @@ forward_list<Script *> ScriptSystem::get_scripts() {
 
 	for (auto behavior_script_ref : behavior_scripts) {
 		BehaviorScript & behavior_script = behavior_script_ref.get();
+		if (!behavior_script.active) continue;
 		Script * script = behavior_script.script.get();
 		if (script == nullptr) continue;
 		scripts.push_front(script);
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
index 626cd67..3b218bc 100644
--- a/src/crepe/api/Transform.cpp
+++ b/src/crepe/api/Transform.cpp
@@ -8,7 +8,7 @@
 
 using namespace crepe::api;
 
-Transform::Transform(uint32_t game_id, Point & point, double rot, double scale)
+Transform::Transform(uint32_t game_id, const Point & point, double rot, double scale)
 	: Component(game_id), position(point), rotation(rot), scale(scale) {
 	dbg_trace();
 }
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index c69ec61..c451c16 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -14,7 +14,7 @@ class Transform : public Component {
 	// works similar (or the same) as those found in GLSL?
 
 public:
-	Transform(uint32_t id, Point &, double, double);
+	Transform(uint32_t id, const Point &, double, double);
 	~Transform();
 	//! Translation (shift)
 	Point position;
diff --git a/src/example/audio_internal.cpp b/src/example/audio_internal.cpp
index 1199e2d..f35ad9d 100644
--- a/src/example/audio_internal.cpp
+++ b/src/example/audio_internal.cpp
@@ -5,26 +5,40 @@
 
 #include <crepe/Sound.h>
 #include <crepe/util/log.h>
+#include <crepe/api/Config.h>
 
-#include <chrono>
 #include <thread>
 
 using namespace crepe;
+using namespace crepe::api;
 using namespace std;
 using namespace std::chrono_literals;
 using std::make_unique;
 
-int main() {
-	dbg_trace();
+// Unrelated stuff that is not part of this POC
+int _ = [] () {
+	// Show dbg_trace() output
+	auto & cfg = api::Config::get_instance();
+	cfg.log.level = util::LogLevel::TRACE;
+
+	return 0; // satisfy compiler
+}();
+
 
+
+int main() {
+	// Load a background track (Ogg Vorbis)
 	auto bgm = Sound("../mwe/audio/bgm.ogg");
+	// Load three short samples (WAV)
 	auto sfx1 = Sound("../mwe/audio/sfx1.wav");
 	auto sfx2 = Sound("../mwe/audio/sfx2.wav");
 	auto sfx3 = Sound("../mwe/audio/sfx3.wav");
 
+	// Start the background track
 	bgm.play();
 
-	// play each sample sequentially
+	// Play each sample sequentially while pausing and resuming the background
+	// track
 	this_thread::sleep_for(500ms);
 	sfx1.play();
 	this_thread::sleep_for(500ms);
@@ -35,11 +49,12 @@ int main() {
 	bgm.play();
 	this_thread::sleep_for(500ms);
 
-	// play all samples simultaniously
+	// Play all samples simultaniously
 	sfx1.play();
 	sfx2.play();
 	sfx3.play();
 	this_thread::sleep_for(1000ms);
 
-	return 0;
+	// Stop all audio and exit
+	return EXIT_SUCCESS;
 }
diff --git a/src/example/log.cpp b/src/example/log.cpp
index 3bc6d80..04ab9cd 100644
--- a/src/example/log.cpp
+++ b/src/example/log.cpp
@@ -9,16 +9,21 @@
 using namespace crepe;
 using namespace crepe::util;
 
-int main() {
-	auto & cfg = api::Config::get_instance();
+// unrelated setup code
+int _ = [] () {
 	// make sure all log messages get printed
+	auto & cfg = api::Config::get_instance();
 	cfg.log.level = util::LogLevel::TRACE;
 
+	return 0; // satisfy compiler
+} ();
+
+int main() {
 	dbg_trace();
-	dbg_logf("cfg.log.color is equal to %d", cfg.log.color);
-	logf(LogLevel::INFO, "info message!");
-	logf(LogLevel::WARNING, "very scary warning");
-	logf(LogLevel::ERROR, "fatal error!!!");
+	dbg_logf("test printf parameters: %d", 3);
+	logf(LogLevel::INFO, "info message");
+	logf(LogLevel::WARNING, "warning");
+	logf(LogLevel::ERROR, "error");
 
 	return 0;
 }
diff --git a/src/example/script.cpp b/src/example/script.cpp
index 43f1c22..cda9591 100644
--- a/src/example/script.cpp
+++ b/src/example/script.cpp
@@ -17,27 +17,38 @@ using namespace crepe;
 using namespace crepe::api;
 using namespace std;
 
+// Unrelated stuff that is not part of this POC
+int _ = [] () {
+	// Show dbg_trace() output
+	auto & cfg = api::Config::get_instance();
+	cfg.log.level = util::LogLevel::TRACE;
+
+	return 0; // satisfy compiler
+}();
+
+
+
+// User-defined script:
 class MyScript : public Script {
 	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);
 	}
 };
 
 int main() {
-	auto & cfg = api::Config::get_instance();
-	cfg.log.level = util::LogLevel::TRACE;
-
+	// Create game object with Transform and BehaviorScript components
 	auto obj = GameObject(0, "name", "tag", 0);
-	Point point = {
-		.x = 1.2,
-		.y = 3.4,
-	};
-	obj.add_component<Transform>(point, 0, 0);
+	obj.add_component<Transform>(Point { .x = 1.2, .y = 3.4, }, 0, 0);
 	obj.add_component<BehaviorScript>().set_script<MyScript>();
 
+	// Get ScriptSystem singleton instance (this would normally be done from the
+	// game loop)
 	auto & sys = ScriptSystem::get_instance();
-	sys.update(); // -> MyScript::update
+	// Update all scripts. This should result in MyScript::update being called
+	sys.update();
 
-	return 0;
+	return EXIT_SUCCESS;
 }
+
diff --git a/src/readme.md b/src/readme.md
index a8ffc51..15fa6f3 100644
--- a/src/readme.md
+++ b/src/readme.md
@@ -8,27 +8,27 @@ Examples (using Ninja):
 
 ```
 $ cmake -B build -G Ninja
-$ ninja -C build
+$ cmake --build build
 ```
 
 Unit tests can be built by explicitly specifying the target `test_main` when
 running the build command:
 
 ```
-$ ninja -C build test_main
+$ cmake --build build --target test_main
 ```
 
 Each source file in the example/ folder corresponds to a CMake target as well
 (all examples can be built at once by specifying the `examples` target):
 
 ```
-$ ninja -C build audio_internal components_internal
+$ cmake --build build --target audio_internal script
 ```
 
 For installing crêpe system-wide after building (install must be run with
 elevated privileges):
 
 ```
-# ninja -C build install
+# cmake --install build
 ```