more nitpicking

35 files changed, 190 insertions, 179 deletions

diff --git a/src/crepe/Collider.h b/src/crepe/Collider.h
index cfc044c..68a7d1d 100644
--- a/src/crepe/Collider.h
+++ b/src/crepe/Collider.h
@@ -6,7 +6,7 @@ namespace crepe {
 
 class Collider : public Component {
 public:
-	Collider(uint32_t gameObjectId);
+	Collider(uint32_t game_object_id);
 
 	int size;
 };
diff --git a/src/crepe/CollisionSystem.cpp b/src/crepe/CollisionSystem.cpp
index 77110a2..55e0fdc 100644
--- a/src/crepe/CollisionSystem.cpp
+++ b/src/crepe/CollisionSystem.cpp
@@ -1,6 +1,4 @@
 #include "CollisionSystem.h"
-#include "ComponentManager.h"
-#include <iostream>
 
 using namespace crepe;
 
diff --git a/src/crepe/CollisionSystem.h b/src/crepe/CollisionSystem.h
index 4a222eb..1e9f1aa 100644
--- a/src/crepe/CollisionSystem.h
+++ b/src/crepe/CollisionSystem.h
@@ -3,11 +3,8 @@
 namespace crepe {
 
 class CollisionSystem {
-private:
-	/* data */
-
 public:
-	CollisionSystem(/* args */);
+	CollisionSystem();
 	void update();
 };
 
diff --git a/src/crepe/Component.h b/src/crepe/Component.h
index 9e10c42..bc44865 100644
--- a/src/crepe/Component.h
+++ b/src/crepe/Component.h
@@ -1,4 +1,5 @@
 #pragma once
+
 #include <cstdint>
 
 namespace crepe {
diff --git a/src/crepe/ComponentManager.h b/src/crepe/ComponentManager.h
index 38f32e4..2b5e1df 100644
--- a/src/crepe/ComponentManager.h
+++ b/src/crepe/ComponentManager.h
@@ -4,7 +4,6 @@
 #include <memory>
 #include <typeindex>
 #include <unordered_map>
-#include <utility>
 #include <vector>
 
 #include "Component.h"
diff --git a/src/crepe/ParticleSystem.cpp b/src/crepe/ParticleSystem.cpp
index f0220a1..af6c550 100644
--- a/src/crepe/ParticleSystem.cpp
+++ b/src/crepe/ParticleSystem.cpp
@@ -1,14 +1,14 @@
-#include "ParticleSystem.h"
-#include "ComponentManager.h"
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <cmath>
 #include <ctime>
 
+#include "api/ParticleEmitter.h"
+
+#include "ComponentManager.h"
+#include "ParticleSystem.h"
+
 using namespace crepe;
 
-ParticleSystem::ParticleSystem()
-	: m_elapsed_time(0.0f) {} // Initialize m_elapsedTime to 0
+ParticleSystem::ParticleSystem() : elapsed_time(0.0f) {}
 
 void ParticleSystem::update() {
 	ComponentManager & mgr = ComponentManager::get_instance();
@@ -16,7 +16,7 @@ void ParticleSystem::update() {
 		= mgr.get_components_by_type<ParticleEmitter>();
 	float delta_time = 0.10;
 	for (ParticleEmitter & emitter : emitters) {
-		float update_amount = 1 / static_cast<float>(emitter.m_emission_rate);
+		float update_amount = 1 / static_cast<float>(emitter.emission_rate);
 		for (float i = 0; i < delta_time; i += update_amount) {
 			emit_particle(emitter);
 		}
@@ -29,32 +29,32 @@ void ParticleSystem::update() {
 }
 
 void ParticleSystem::emit_particle(ParticleEmitter & emitter) {
-	Position initial_position = {emitter.m_position.x, emitter.m_position.y};
+	Position initial_position = {emitter.position.x, emitter.position.y};
 	float random_angle = 0.0f;
-	if (emitter.m_max_angle < emitter.m_min_angle) {
-		random_angle = ((emitter.m_min_angle
-						+ (std::rand()
-						   % (static_cast<uint32_t>(emitter.m_max_angle + 360
-													- emitter.m_min_angle + 1))))
-					   % 360);
+	if (emitter.max_angle < emitter.min_angle) {
+		random_angle = ((emitter.min_angle
+						 + (std::rand()
+							% (static_cast<uint32_t>(emitter.max_angle + 360
+													 - emitter.min_angle + 1))))
+						% 360);
 	} else {
-		random_angle = emitter.m_min_angle
-					  + (std::rand()
-						 % (static_cast<uint32_t>(emitter.m_max_angle
-												  - emitter.m_min_angle + 1)));
+		random_angle = emitter.min_angle
+					   + (std::rand()
+						  % (static_cast<uint32_t>(emitter.max_angle
+												   - emitter.min_angle + 1)));
 	}
 	float angle_in_radians = random_angle * (M_PI / 180.0f);
 	float random_speed_offset = (static_cast<float>(std::rand()) / RAND_MAX)
-								  * (2 * emitter.m_speed_offset)
-							  - emitter.m_speed_offset;
+									* (2 * emitter.speed_offset)
+								- emitter.speed_offset;
 	float velocity_x
-		= (emitter.m_speed + random_speed_offset) * std::cos(angle_in_radians);
+		= (emitter.speed + random_speed_offset) * std::cos(angle_in_radians);
 	float velocity_y
-		= (emitter.m_speed + random_speed_offset) * std::sin(angle_in_radians);
+		= (emitter.speed + random_speed_offset) * std::sin(angle_in_radians);
 	Position initial_velocity = {velocity_x, velocity_y};
 	for (size_t i = 0; i < emitter.particles.size(); i++) {
 		if (!emitter.particles[i].active) {
-			emitter.particles[i].reset(emitter.m_end_lifespan, initial_position,
+			emitter.particles[i].reset(emitter.end_lifespan, initial_position,
 									   initial_velocity);
 			break;
 		}
diff --git a/src/crepe/ParticleSystem.h b/src/crepe/ParticleSystem.h
index 071eec4..ad96eb0 100644
--- a/src/crepe/ParticleSystem.h
+++ b/src/crepe/ParticleSystem.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "api/ParticleEmitter.h"
-#include <vector>
 
 namespace crepe {
 
@@ -13,7 +12,7 @@ public:
 private:
 	void emit_particle(ParticleEmitter & emitter); //emits a new particle
 
-	float m_elapsed_time; //elapsed time since the last emission
+	float elapsed_time; //elapsed time since the last emission
 };
 
 } // namespace crepe
diff --git a/src/crepe/PhysicsSystem.cpp b/src/crepe/PhysicsSystem.cpp
index 4bb931d..16f4c10 100644
--- a/src/crepe/PhysicsSystem.cpp
+++ b/src/crepe/PhysicsSystem.cpp
@@ -1,9 +1,11 @@
-#include "PhysicsSystem.h"
-#include "ComponentManager.h"
+#include <iostream>
+
 #include "api/Force.h"
 #include "api/Rigidbody.h"
 #include "api/Transform.h"
-#include <iostream>
+
+#include "ComponentManager.h"
+#include "PhysicsSystem.h"
 
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/PhysicsSystem.h b/src/crepe/PhysicsSystem.h
index dd242c7..33b4072 100644
--- a/src/crepe/PhysicsSystem.h
+++ b/src/crepe/PhysicsSystem.h
@@ -3,11 +3,8 @@
 namespace crepe {
 
 class PhysicsSystem {
-private:
-	/* data */
-
 public:
-	PhysicsSystem(/* args */);
+	PhysicsSystem();
 	void update();
 };
 
diff --git a/src/crepe/RenderSystem.cpp b/src/crepe/RenderSystem.cpp
index b8789fc..1139359 100644
--- a/src/crepe/RenderSystem.cpp
+++ b/src/crepe/RenderSystem.cpp
@@ -1,13 +1,13 @@
+#include <functional>
+#include <vector>
 
-
-#include "RenderSystem.h"
-#include "ComponentManager.h"
-#include "SdlContext.h"
 #include "api/Sprite.h"
 #include "api/Transform.h"
 #include "util/log.h"
-#include <functional>
-#include <vector>
+
+#include "ComponentManager.h"
+#include "RenderSystem.h"
+#include "SdlContext.h"
 
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/RenderSystem.h b/src/crepe/RenderSystem.h
index 5e86dce..4b910a4 100644
--- a/src/crepe/RenderSystem.h
+++ b/src/crepe/RenderSystem.h
@@ -1,4 +1,3 @@
-
 #pragma once
 
 #include "System.h"
diff --git a/src/crepe/SDLApp.cpp b/src/crepe/SDLApp.cpp
index 198c0d0..f408595 100644
--- a/src/crepe/SDLApp.cpp
+++ b/src/crepe/SDLApp.cpp
@@ -1,8 +1,6 @@
-#include "SDLApp.h"
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <iostream>
-#include <vector>
+
+#include "SDLApp.h"
 
 SDLApp::SDLApp(int window_width, int window_height)
 	: window_width(window_width), window_height(window_height), window(nullptr),
@@ -18,8 +16,8 @@ bool SDLApp::initialize() {
 	}
 
 	window = SDL_CreateWindow("Particle System", SDL_WINDOWPOS_CENTERED,
-							  SDL_WINDOWPOS_CENTERED, window_width, window_height,
-							  SDL_WINDOW_SHOWN);
+							  SDL_WINDOWPOS_CENTERED, window_width,
+							  window_height, SDL_WINDOW_SHOWN);
 	if (!window) {
 		std::cerr << "Window Creation Error: " << SDL_GetError() << std::endl;
 		return false;
diff --git a/src/crepe/SDLApp.h b/src/crepe/SDLApp.h
index cdba4c3..e67947b 100644
--- a/src/crepe/SDLApp.h
+++ b/src/crepe/SDLApp.h
@@ -1,13 +1,12 @@
-#ifndef SDLAPP_HPP
-#define SDLAPP_HPP
+#pragma once
 
-#include "Particle.h"
-#include "api/ParticleEmitter.h"
 #include <SDL2/SDL.h>
 
+#include "api/ParticleEmitter.h"
+
 class SDLApp {
 public:
-	SDLApp(int windowWidth, int windowHeight);
+	SDLApp(int window_width, int window_height);
 	~SDLApp();
 
 	bool initialize();
@@ -25,5 +24,3 @@ private:
 	SDL_Window * window;
 	SDL_Renderer * renderer;
 };
-
-#endif
diff --git a/src/crepe/ScriptSystem.cpp b/src/crepe/ScriptSystem.cpp
index 5d882be..d00d474 100644
--- a/src/crepe/ScriptSystem.cpp
+++ b/src/crepe/ScriptSystem.cpp
@@ -2,12 +2,13 @@
 #include <functional>
 #include <vector>
 
-#include "ComponentManager.h"
-#include "ScriptSystem.h"
 #include "api/BehaviorScript.h"
 #include "api/Script.h"
 #include "util/log.h"
 
+#include "ComponentManager.h"
+#include "ScriptSystem.h"
+
 using namespace std;
 using namespace crepe;
 using namespace crepe::api;
diff --git a/src/crepe/SdlContext.cpp b/src/crepe/SdlContext.cpp
index f00dade..2b49283 100644
--- a/src/crepe/SdlContext.cpp
+++ b/src/crepe/SdlContext.cpp
@@ -1,11 +1,3 @@
-
-
-#include "SdlContext.h"
-
-#include "api/Sprite.h"
-#include "api/Texture.h"
-#include "api/Transform.h"
-#include "util/log.h"
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_image.h>
 #include <SDL2/SDL_render.h>
@@ -15,6 +7,13 @@
 #include <cstddef>
 #include <iostream>
 
+#include "api/Sprite.h"
+#include "api/Texture.h"
+#include "api/Transform.h"
+#include "util/log.h"
+
+#include "SdlContext.h"
+
 using namespace crepe;
 
 SdlContext & SdlContext::get_instance() {
@@ -34,17 +33,18 @@ void SdlContext::handle_events(bool & running) {
 SdlContext::~SdlContext() {
 	dbg_trace();
 
-	if (m_game_renderer != nullptr) SDL_DestroyRenderer(m_game_renderer);
+	if (this->game_renderer != nullptr)
+		SDL_DestroyRenderer(this->game_renderer);
 
-	if (m_game_window != nullptr) {
-		SDL_DestroyWindow(m_game_window);
+	if (this->game_window != nullptr) {
+		SDL_DestroyWindow(this->game_window);
 	}
 
 	IMG_Quit();
 	SDL_Quit();
 }
 
-void SdlContext::clear_screen() { SDL_RenderClear(this->m_game_renderer); }
+void SdlContext::clear_screen() { SDL_RenderClear(this->game_renderer); }
 
 SdlContext::SdlContext() {
 	dbg_trace();
@@ -55,20 +55,20 @@ SdlContext::SdlContext() {
 		return;
 	}
 
-	m_game_window = SDL_CreateWindow(
+	this->game_window = SDL_CreateWindow(
 		"Crepe Game Engine", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
 		1920, 1080, SDL_WINDOW_SHOWN);
-	if (!m_game_window) {
+	if (!this->game_window) {
 		std::cerr << "Window could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
 	}
 
-	m_game_renderer
-		= SDL_CreateRenderer(m_game_window, -1, SDL_RENDERER_ACCELERATED);
-	if (!m_game_renderer) {
+	this->game_renderer
+		= SDL_CreateRenderer(this->game_window, -1, SDL_RENDERER_ACCELERATED);
+	if (!this->game_renderer) {
 		std::cerr << "Renderer could not be created! SDL_Error: "
 				  << SDL_GetError() << std::endl;
-		SDL_DestroyWindow(m_game_window);
+		SDL_DestroyWindow(this->game_window);
 		return;
 	}
 
@@ -78,7 +78,8 @@ SdlContext::SdlContext() {
 				  << IMG_GetError() << std::endl;
 	}
 }
-void SdlContext::present_screen() { SDL_RenderPresent(this->m_game_renderer); }
+
+void SdlContext::present_screen() { SDL_RenderPresent(this->game_renderer); }
 
 void SdlContext::draw(const api::Sprite & sprite,
 					  const api::Transform & transform) {
@@ -88,7 +89,7 @@ void SdlContext::draw(const api::Sprite & sprite,
 							  | (SDL_FLIP_VERTICAL * sprite.flip.flip_y));
 
 	int w, h;
-	SDL_QueryTexture(sprite.sprite_image->m_texture, NULL, NULL, &w, &h);
+	SDL_QueryTexture(sprite.sprite_image->texture, NULL, NULL, &w, &h);
 	// needs maybe camera for position
 	SDL_Rect dstrect = {
 		.x = static_cast<int>(transform.position.x),
@@ -98,8 +99,8 @@ void SdlContext::draw(const api::Sprite & sprite,
 	};
 
 	double degrees = transform.rotation * 180 / M_PI;
-	SDL_RenderCopyEx(this->m_game_renderer, sprite.sprite_image->m_texture,
-					 NULL, &dstrect, degrees, NULL, render_flip);
+	SDL_RenderCopyEx(this->game_renderer, sprite.sprite_image->texture, NULL,
+					 &dstrect, degrees, NULL, render_flip);
 }
 
 /*
@@ -117,7 +118,7 @@ SDL_Texture * SdlContext::setTextureFromPath(const char * path, SDL_Rect & clip,
 	clip.h = tmp->h / row;
 
 	SDL_Texture * CreatedTexture
-		= SDL_CreateTextureFromSurface(m_game_renderer, tmp);
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
 
 	if (!CreatedTexture) {
 		std::cerr << "Error could not create texture " << IMG_GetError
@@ -137,7 +138,7 @@ SDL_Texture * SdlContext::texture_from_path(const char * path) {
 		std::cerr << "Error surface " << IMG_GetError << std::endl;
 	}
 	SDL_Texture * created_texture
-		= SDL_CreateTextureFromSurface(m_game_renderer, tmp);
+		= SDL_CreateTextureFromSurface(this->game_renderer, tmp);
 
 	if (!created_texture) {
 		std::cerr << "Error could not create texture " << IMG_GetError
diff --git a/src/crepe/SdlContext.h b/src/crepe/SdlContext.h
index 97adfa2..31ba3a6 100644
--- a/src/crepe/SdlContext.h
+++ b/src/crepe/SdlContext.h
@@ -1,11 +1,13 @@
 #pragma once
 
-#include "RenderSystem.h"
-#include "api/Sprite.h"
-#include "api/Transform.h"
 #include <SDL2/SDL_render.h>
 #include <SDL2/SDL_video.h>
 
+#include "api/Sprite.h"
+#include "api/Transform.h"
+
+#include "RenderSystem.h"
+
 namespace crepe::api {
 class Texture;
 }
@@ -43,8 +45,8 @@ private:
 	void present_screen();
 
 private:
-	SDL_Window * m_game_window = nullptr;
-	SDL_Renderer * m_game_renderer = nullptr;
+	SDL_Window * game_window = nullptr;
+	SDL_Renderer * game_renderer = nullptr;
 };
 
 } // namespace crepe
diff --git a/src/crepe/Sound.h b/src/crepe/Sound.h
index b7cfbb8..917b57e 100644
--- a/src/crepe/Sound.h
+++ b/src/crepe/Sound.h
@@ -1,10 +1,9 @@
 #pragma once
 
+#include <memory>
 #include <soloud/soloud.h>
 #include <soloud/soloud_wav.h>
 
-#include <memory>
-
 #include "Asset.h"
 
 namespace crepe {
diff --git a/src/crepe/api/AssetManager.cpp b/src/crepe/api/AssetManager.cpp
index bf4217f..560df6c 100644
--- a/src/crepe/api/AssetManager.cpp
+++ b/src/crepe/api/AssetManager.cpp
@@ -1,7 +1,6 @@
-
+#include "util/log.h"
 
 #include "AssetManager.h"
-#include "util/log.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/AssetManager.h b/src/crepe/api/AssetManager.h
index f3f1307..d9d9b44 100644
--- a/src/crepe/api/AssetManager.h
+++ b/src/crepe/api/AssetManager.h
@@ -43,4 +43,5 @@ public:
 		return new_asset;
 	}
 };
+
 } // namespace crepe::api
diff --git a/src/crepe/api/AudioSource.cpp b/src/crepe/api/AudioSource.cpp
index 10b3b49..35b8d83 100644
--- a/src/crepe/api/AudioSource.cpp
+++ b/src/crepe/api/AudioSource.cpp
@@ -1,9 +1,8 @@
 #include <memory>
 
-#include "AudioSource.h"
-
 #include "../Sound.h"
-#include <memory>
+
+#include "AudioSource.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/BehaviorScript.hpp b/src/crepe/api/BehaviorScript.hpp
index a6bd81c..6fdf605 100644
--- a/src/crepe/api/BehaviorScript.hpp
+++ b/src/crepe/api/BehaviorScript.hpp
@@ -3,6 +3,7 @@
 #include <type_traits>
 
 #include "../util/log.h"
+
 #include "BehaviorScript.h"
 
 namespace crepe::api {
diff --git a/src/crepe/api/CircleCollider.h b/src/crepe/api/CircleCollider.h
index 96d98ed..762574b 100644
--- a/src/crepe/api/CircleCollider.h
+++ b/src/crepe/api/CircleCollider.h
@@ -5,8 +5,8 @@ namespace crepe::api {
 
 class CircleCollider : public Collider {
 public:
-	CircleCollider(uint32_t gameObjectId, int radius)
-		: Collider(gameObjectId), radius(radius) {}
+	CircleCollider(uint32_t game_object_id, int radius)
+		: Collider(game_object_id), radius(radius) {}
 	int radius;
 };
 
diff --git a/src/crepe/api/Color.cpp b/src/crepe/api/Color.cpp
index 5c7d8cc..71592da 100644
--- a/src/crepe/api/Color.cpp
+++ b/src/crepe/api/Color.cpp
@@ -1,5 +1,3 @@
-
-
 #include "Color.h"
 
 using namespace crepe::api;
diff --git a/src/crepe/api/Force.cpp b/src/crepe/api/Force.cpp
index ff82afa..98649c1 100644
--- a/src/crepe/api/Force.cpp
+++ b/src/crepe/api/Force.cpp
@@ -1,16 +1,17 @@
-#include "Force.h"
 #include <cmath>
 
+#include "Force.h"
+
 namespace crepe::api {
 
-Force::Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction)
-	: Component(gameObjectId) {
+Force::Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction)
+	: Component(game_object_id) {
 	// Convert direction from degrees to radians
 	float radian_direction = static_cast<float>(direction) * (M_PI / 180.0f);
 	force_x = static_cast<int32_t>(
-		std::round(forceMagnitude * std::cos(radian_direction)));
+		std::round(magnitude * std::cos(radian_direction)));
 	force_y = static_cast<int32_t>(
-		std::round(forceMagnitude * std::sin(radian_direction)));
+		std::round(magnitude * std::sin(radian_direction)));
 }
 
 } // namespace crepe::api
diff --git a/src/crepe/api/Force.h b/src/crepe/api/Force.h
index 1d30af4..8da9a00 100644
--- a/src/crepe/api/Force.h
+++ b/src/crepe/api/Force.h
@@ -1,14 +1,14 @@
 #pragma once
 
-#include "../Component.h"
 #include <cstdint>
-#include <utility>
+
+#include "../Component.h"
 
 namespace crepe::api {
 
 class Force : public Component {
 public:
-	Force(uint32_t gameObjectId, uint32_t forceMagnitude, uint32_t direction);
+	Force(uint32_t game_object_id, uint32_t magnitude, uint32_t direction);
 
 	int32_t force_x;
 	int32_t force_y;
diff --git a/src/crepe/api/ParticleEmitter.cpp b/src/crepe/api/ParticleEmitter.cpp
index 298a5ec..2e07562 100644
--- a/src/crepe/api/ParticleEmitter.cpp
+++ b/src/crepe/api/ParticleEmitter.cpp
@@ -1,29 +1,28 @@
-#include "ParticleEmitter.h"
-#include "Particle.h"
 #include <ctime>
 #include <iostream>
 
+#include "Particle.h"
+#include "ParticleEmitter.h"
+
 using namespace crepe;
 
-ParticleEmitter::ParticleEmitter(uint32_t gameObjectId, uint32_t max_particles,
-								 uint32_t emission_rate, uint32_t speed,
-								 uint32_t speed_offset, uint32_t angle,
-								 uint32_t angleOffset, float m_begin_lifespan,
-								 float m_end_lifespan)
-	: Component(gameObjectId), m_max_particles(max_particles),
-	  m_emission_rate(emission_rate), m_speed(speed), m_speed_offset(speed_offset),
-	  m_position{0, 0}, m_begin_lifespan(m_begin_lifespan),
-	  m_end_lifespan(m_end_lifespan) {
+ParticleEmitter::ParticleEmitter(uint32_t game_object_id,
+								 uint32_t max_particles, uint32_t emission_rate,
+								 uint32_t speed, uint32_t speed_offset,
+								 uint32_t angle, uint32_t angleOffset,
+								 float begin_lifespan, float end_lifespan)
+	: Component(game_object_id), max_particles(max_particles),
+	  emission_rate(emission_rate), speed(speed), speed_offset(speed_offset),
+	  position{0, 0}, begin_lifespan(begin_lifespan),
+	  end_lifespan(end_lifespan) {
 	std::srand(
 		static_cast<uint32_t>(std::time(nullptr))); // initialize random seed
 	std::cout << "Create emitter" << std::endl;
-	m_min_angle
-		= (360 + angle - (angleOffset % 360)) % 360; // calculate minAngle
-	m_max_angle
-		= (360 + angle + (angleOffset % 360)) % 360; // calculate maxAngle
-	m_position.x = 400;
-	m_position.y = 400;
-	for (size_t i = 0; i < m_max_particles; i++) {
+	min_angle = (360 + angle - (angleOffset % 360)) % 360; // calculate minAngle
+	max_angle = (360 + angle + (angleOffset % 360)) % 360; // calculate maxAngle
+	position.x = 400;
+	position.y = 400;
+	for (size_t i = 0; i < max_particles; i++) {
 		this->particles.emplace_back();
 	}
 }
diff --git a/src/crepe/api/ParticleEmitter.h b/src/crepe/api/ParticleEmitter.h
index 23f02f6..2e2e95b 100644
--- a/src/crepe/api/ParticleEmitter.h
+++ b/src/crepe/api/ParticleEmitter.h
@@ -1,32 +1,42 @@
 #pragma once
 
-#include "Component.h"
-#include "Particle.h"
 #include <cstdint>
 #include <vector>
-#
+
+#include "Component.h"
+#include "Particle.h"
 
 namespace crepe {
 
 class ParticleEmitter : public Component {
 public:
-	ParticleEmitter(uint32_t gameObjectId, uint32_t maxParticles,
-					uint32_t emissionRate, uint32_t speed, uint32_t speedOffset,
-					uint32_t angle, uint32_t angleOffset, float m_beginLifespan,
-					float m_endLifespan);
+	ParticleEmitter(uint32_t game_object_id, uint32_t max_particles,
+					uint32_t emission_rate, uint32_t speed,
+					uint32_t speed_offset, uint32_t angle, uint32_t angleOffset,
+					float begin_lifespan, float end_lifespan);
 	~ParticleEmitter();
 
-	Position m_position; //position of the emitter
-	uint32_t m_max_particles; //maximum number of particles
-	uint32_t m_emission_rate; //rate of particle emission
-	uint32_t m_speed; //base speed of the particles
-	uint32_t m_speed_offset; //offset for random speed variation
-	uint32_t m_min_angle; //min angle of particle emission
-	uint32_t m_max_angle; //max angle of particle emission
-	float m_begin_lifespan; //begin Lifespan of particle (only visual)
-	float m_end_lifespan; //begin Lifespan of particle
+	//! position of the emitter
+	Position position;
+	//! maximum number of particles
+	uint32_t max_particles;
+	//! rate of particle emission
+	uint32_t emission_rate;
+	//! base speed of the particles
+	uint32_t speed;
+	//! offset for random speed variation
+	uint32_t speed_offset;
+	//! min angle of particle emission
+	uint32_t min_angle;
+	//! max angle of particle emission
+	uint32_t max_angle;
+	//! begin Lifespan of particle (only visual)
+	float begin_lifespan;
+	//! begin Lifespan of particle
+	float end_lifespan;
 
-	std::vector<Particle> particles; //collection of particles
+	//! collection of particles
+	std::vector<Particle> particles;
 };
 
 } // namespace crepe
diff --git a/src/crepe/api/Rigidbody.cpp b/src/crepe/api/Rigidbody.cpp
index b35d5b8..ebf9fb9 100644
--- a/src/crepe/api/Rigidbody.cpp
+++ b/src/crepe/api/Rigidbody.cpp
@@ -2,7 +2,7 @@
 
 using namespace crepe::api;
 
-Rigidbody::Rigidbody(uint32_t gameObjectId, int mass, int gravityScale,
+Rigidbody::Rigidbody(uint32_t game_object_id, int mass, int gravity_scale,
 					 BodyType bodyType)
-	: Component(gameObjectId), mass(mass), gravity_scale(gravityScale),
+	: Component(game_object_id), mass(mass), gravity_scale(gravity_scale),
 	  body_type(bodyType) {}
diff --git a/src/crepe/api/Rigidbody.h b/src/crepe/api/Rigidbody.h
index dc242c1..05cbb03 100644
--- a/src/crepe/api/Rigidbody.h
+++ b/src/crepe/api/Rigidbody.h
@@ -1,20 +1,24 @@
 #pragma once
 
-#include "../Component.h"
 #include <cstdint>
 
+#include "../Component.h"
+
 namespace crepe::api {
 
 enum class BodyType {
-	STATIC, // Does not move (e.g. walls, ground ...)
-	DYNAMIC, // Moves and responds to forces (e.g. player, physics objects ...)
-	KINEMATIC // Moves but does not respond to forces (e.g. moving platforms ...)
+	//! Does not move (e.g. walls, ground ...)
+	STATIC,
+	//! Moves and responds to forces (e.g. player, physics objects ...)
+	DYNAMIC,
+	//! Moves but does not respond to forces (e.g. moving platforms ...)
+	KINEMATIC,
 };
 
 class Rigidbody : public Component {
 public:
-	Rigidbody(uint32_t gameObjectId, int mass, int gravityScale,
-			  BodyType bodyType);
+	Rigidbody(uint32_t game_object_id, int mass, int gravity_scale,
+			  BodyType body_type);
 	int32_t velocity_x;
 	int32_t velocity_y;
 	int mass;
diff --git a/src/crepe/api/Sprite.cpp b/src/crepe/api/Sprite.cpp
index cdece28..806f147 100644
--- a/src/crepe/api/Sprite.cpp
+++ b/src/crepe/api/Sprite.cpp
@@ -1,12 +1,11 @@
+#include <cstdint>
+#include <memory>
 
-
-#include "Sprite.h"
-#include "Component.h"
 #include "api/Texture.h"
 #include "util/log.h"
-#include <cstdint>
-#include <memory>
-#include <utility>
+
+#include "Component.h"
+#include "Sprite.h"
 
 using namespace std;
 using namespace crepe;
diff --git a/src/crepe/api/Sprite.h b/src/crepe/api/Sprite.h
index 7a701e3..b06125e 100644
--- a/src/crepe/api/Sprite.h
+++ b/src/crepe/api/Sprite.h
@@ -1,18 +1,21 @@
 #pragma once
 
-#include "Component.h"
-#include "api/Color.h"
-#include "api/Texture.h"
 #include <SDL2/SDL_rect.h>
 #include <cstdint>
 #include <memory>
 
+#include "api/Color.h"
+#include "api/Texture.h"
+
+#include "Component.h"
+
 namespace crepe::api {
 
 struct FlipSettings {
 	bool flip_x = 1;
 	bool flip_y = 1;
 };
+
 class Sprite : public Component {
 
 public:
diff --git a/src/crepe/api/Texture.cpp b/src/crepe/api/Texture.cpp
index c755fa9..7791b5b 100644
--- a/src/crepe/api/Texture.cpp
+++ b/src/crepe/api/Texture.cpp
@@ -1,31 +1,32 @@
+#include <SDL2/SDL_render.h>
 
+#include "util/log.h"
 
 #include "Asset.h"
 #include "SdlContext.h"
-#include "util/log.h"
-
 #include "Texture.h"
-#include <SDL2/SDL_render.h>
 
 using namespace crepe::api;
+using namespace std;
 
-Texture::Texture(std::unique_ptr<Asset> res) {
+Texture::Texture(unique_ptr<Asset> res) {
 	dbg_trace();
 	this->load(std::move(res));
 }
 
 Texture::Texture(const char * src) {
 	dbg_trace();
-	this->load(std::make_unique<Asset>(src));
+	this->load(make_unique<Asset>(src));
 }
 
 Texture::~Texture() {
 	dbg_trace();
-	if (this->m_texture != nullptr) {
-		SDL_DestroyTexture(m_texture);
+	if (this->texture != nullptr) {
+		SDL_DestroyTexture(this->texture);
 	}
 }
-void Texture::load(std::unique_ptr<Asset> res) {
+
+void Texture::load(unique_ptr<Asset> res) {
 	SdlContext & ctx = SdlContext::get_instance();
-	m_texture = ctx.texture_from_path(res->canonical());
+	this->texture = ctx.texture_from_path(res->canonical());
 }
diff --git a/src/crepe/api/Texture.h b/src/crepe/api/Texture.h
index 6d3fb40..993f72b 100644
--- a/src/crepe/api/Texture.h
+++ b/src/crepe/api/Texture.h
@@ -1,9 +1,10 @@
 #pragma once
 
-#include "Asset.h"
 #include <SDL2/SDL_render.h>
 #include <memory>
 
+#include "Asset.h"
+
 namespace crepe {
 class SdlContext;
 }
@@ -21,7 +22,7 @@ private:
 	void load(std::unique_ptr<Asset> res);
 
 private:
-	SDL_Texture * m_texture = nullptr;
+	SDL_Texture * texture = nullptr;
 
 	friend class crepe::SdlContext;
 };
diff --git a/src/crepe/api/Transform.cpp b/src/crepe/api/Transform.cpp
index 4f22843..626cd67 100644
--- a/src/crepe/api/Transform.cpp
+++ b/src/crepe/api/Transform.cpp
@@ -1,10 +1,10 @@
+#include <cstdint>
 
-
-#include "Transform.h"
-#include "Component.h"
 #include "api/Point.h"
 #include "util/log.h"
-#include <cstdint>
+
+#include "Component.h"
+#include "Transform.h"
 
 using namespace crepe::api;
 
diff --git a/src/crepe/api/Transform.h b/src/crepe/api/Transform.h
index c9d46c5..7b74e43 100644
--- a/src/crepe/api/Transform.h
+++ b/src/crepe/api/Transform.h
@@ -1,11 +1,15 @@
 #pragma once
 
-#include "Component.h"
-#include "api/Point.h"
 #include <cstdint>
+
+#include "api/Point.h"
+
+#include "Component.h"
+
 namespace crepe::api {
 
 class Transform : public Component {
+
 public:
 	Transform(uint32_t id, Point &, double, double);
 	~Transform();
@@ -13,4 +17,5 @@ public:
 	double rotation; // Rotation, in radians
 	double scale; // Multiplication factoh
 };
+
 } // namespace crepe::api