Add mouse speed setting to BlitzConfig

Merge branch 'gui' of git.ale-pri.com:Blitz/Blitz into gui
Merge branch 'main' into gui
2024-03-29 22:08:18 +01:00 · 2024-03-26 12:51:49 +01:00 · 2024-03-26 12:51:08 +01:00 · 2024-03-26 12:38:20 +01:00 · 2024-03-26 10:42:18 +01:00 · 2024-03-26 10:40:32 +01:00
141 changed files with 779 additions and 4017 deletions
--- a/.gitea/workflows/ubuntu.yaml
+++ b/.gitea/workflows/ubuntu.yaml
@@ -10,7 +10,7 @@ jobs:
      - name: Install deps
        run : |
          apt update
-          apt install -y libsdl2-dev libassimp-dev libglew-dev          
+          apt install -y libsdl2-dev libassimp-dev libglew-dev

      - name: Check out repository code
        uses: actions/checkout@v3
@@ -22,19 +22,11 @@ jobs:
          actions-cache-folder: '.xmake-cache'
          actions-cache-key: 'ubuntu'

-      - name: Calc deps hash
-        uses: seepine/hash-files@v1
-        id: get-hash
-        with: 
-          patterns: |
-            **/xmake.lua
-            **/xmake/*.lua            
-
      - name: Packages cache
        uses: actions/cache@v4
        with:
          path: ~/.xmake
-          key: ${{ runner.os }}-${{ steps.get-hash.outputs.hash }}
+          key: 'ubuntu-packages'

      - name: XMake config
        run: xmake f -p linux -y --root
@@ -43,4 +35,4 @@ jobs:
        run: xmake --root

      - name: Test
-        run: xmake test --root       
+        run: xmake test --root          
--- a/assets/base_deambu.glb
+++ b/assets/base_deambu.glb
--- a/assets/laser.wav
+++ b/assets/laser.wav
--- a/assets/player.obj
+++ b/assets/player.obj
@@ -0,0 +1,40 @@
+# Blender 3.6.4
+# www.blender.org
+mtllib untitled.mtl
+o Cube
+v 1.000000 3.829521 -1.000000
+v 1.000000 -1.000000 -1.000000
+v 1.000000 3.829521 1.000000
+v 1.000000 -1.000000 1.000000
+v -1.000000 3.829521 -1.000000
+v -1.000000 -1.000000 -1.000000
+v -1.000000 3.829521 1.000000
+v -1.000000 -1.000000 1.000000
+vn -0.0000 1.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -1.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vt 0.625000 0.500000
+vt 0.875000 0.500000
+vt 0.875000 0.750000
+vt 0.625000 0.750000
+vt 0.375000 0.750000
+vt 0.625000 1.000000
+vt 0.375000 1.000000
+vt 0.375000 0.000000
+vt 0.625000 0.000000
+vt 0.625000 0.250000
+vt 0.375000 0.250000
+vt 0.125000 0.500000
+vt 0.375000 0.500000
+vt 0.125000 0.750000
+s 0
+usemtl Material
+f 1/1/1 5/2/1 7/3/1 3/4/1
+f 4/5/2 3/4/2 7/6/2 8/7/2
+f 8/8/3 7/9/3 5/10/3 6/11/3
+f 6/12/4 2/13/4 4/5/4 8/14/4
+f 2/13/5 1/1/5 3/4/5 4/5/5
+f 6/11/6 5/10/6 1/1/6 2/13/6
--- a/assets/sessionD.wav
+++ b/assets/sessionD.wav
--- a/assets/sol.glb
+++ b/assets/sol.glb
--- a/assets/void_map.obj
+++ b/assets/void_map.obj
@@ -0,0 +1,37 @@
+# Blender 3.6.4
+# www.blender.org
+mtllib void_map.mtl
+o Plane
+v -30.0 0.000000 30.0
+v 30.0 0.000000 30.0
+v -30.0 0.000000 -30.0
+v 30.0 0.000000 -30.0
+v -30.0 0.000000 30.0
+v -30.0 0.000000 -30.0
+v -30.0 0.000000 30.0
+v -30.0 0.000000 -30.0
+v -30.0 15.0 30.0
+v -30.0 15.0 -30.0
+v -30.0 15.0 -30.0
+v 30.0 15.0 -30.0
+v 30.0 15.0 30.0
+v 30.0 15.0 -30.0
+v -30.0 15.0 30.0
+v 30.0 15.0 30.0
+vn -0.0000 1.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vt 0.000000 0.000000
+vt 1.000000 0.000000
+vt 1.000000 1.000000
+vt 0.000000 1.000000
+s 0
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 1/1/1 3/4/1 6/4/1 5/1/1
+f 5/1/1 6/4/1 8/4/1 7/1/1
+f 7/1/2 8/4/2 10/4/2 9/1/2
+f 3/4/3 4/3/3 12/3/3 11/4/3
+f 4/3/4 2/2/4 13/2/4 14/3/4
+f 2/2/5 1/1/5 15/1/5 16/2/5
--- a/assets/void_map2.obj
+++ b/assets/void_map2.obj
@@ -0,0 +1,38 @@
+# Blender 3.6.4
+# www.blender.org
+mtllib void_map2.mtl
+o Plane
+v -31.562399 0.000000 31.562399
+v 31.562399 0.000000 31.562399
+v -31.562399 0.000000 -31.562399
+v 31.562399 0.000000 -31.562399
+v -31.562399 0.000000 31.562399
+v -31.562399 0.000000 -31.562399
+v -31.562399 0.000000 31.562399
+v -31.562399 0.000000 -31.562399
+v -31.562399 12.947957 31.562399
+v -31.562399 12.947957 -31.562399
+v -31.562399 12.885334 -31.562399
+v 31.562399 12.885334 -31.562399
+v 31.562399 12.806857 31.562399
+v 31.562399 12.806857 -31.562399
+v -31.562399 12.847334 31.562399
+v 31.562399 12.847334 31.562399
+vn -0.0000 1.0000 -0.0000
+vn 1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 1.0000
+vn -1.0000 -0.0000 -0.0000
+vn -0.0000 -0.0000 -1.0000
+vt 0.000000 0.000000
+vt 1.000000 0.000000
+vt 1.000000 1.000000
+vt 0.000000 1.000000
+s 0
+usemtl carrelage
+f 1/1/1 2/2/1 4/3/1 3/4/1
+f 1/1/1 3/4/1 6/4/1 5/1/1
+f 5/1/1 6/4/1 8/4/1 7/1/1
+f 7/1/2 8/4/2 10/4/2 9/1/2
+f 3/4/3 4/3/3 12/3/3 11/4/3
+f 4/3/4 2/2/4 13/2/4 14/3/4
+f 2/2/5 1/1/5 15/1/5 16/2/5
--- a/include/blitz/common/DataBuffer.h
+++ b/include/blitz/common/DataBuffer.h
@@ -7,10 +7,10 @@

 #include <algorithm>
 #include <cassert>
-#include <cstdint>
 #include <cstring>
 #include <string>
 #include <vector>
+#include <cstdint>

 namespace blitz {

@@ -40,31 +40,21 @@ class DataBuffer {
 	DataBuffer& operator=(const DataBuffer& other);
 	DataBuffer& operator=(DataBuffer&& other);

-	/**
-	 * \brief Append data to the buffer
-	 */
 	template <typename T>
 	void Append(const T& data) {
 		std::size_t size = sizeof(data);
 		std::size_t end_pos = m_Buffer.size();
 		m_Buffer.resize(m_Buffer.size() + size);
-		std::memcpy(&m_Buffer[end_pos], &data, size);
+		memcpy(&m_Buffer[end_pos], &data, size);
 	}

-	/**
-	 * \brief Append data to the buffer
-	 */
 	template <typename T>
 	DataBuffer& operator<<(const T& data) {
 		Append(data);
 		return *this;
 	}

-	/**
-	 * \brief Append a string to the buffer
-	 * \warning Don't use it for binary data !
-	 * \param str The string to append
-	 */
+	// don't use it for binary data !
 	DataBuffer& operator<<(const std::string& str) {
 		std::size_t strlen = str.length() + 1;	// including null character
 		Resize(GetSize() + strlen);
@@ -72,18 +62,16 @@ class DataBuffer {
 		return *this;
 	}

-	/**
-	 * \brief Append data to the buffer from another const buffer
-	 * \param data The buffer to append
-	 */
+	DataBuffer& operator<<(DataBuffer& data) {
+		m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
+		return *this;
+	}
+
 	DataBuffer& operator<<(const DataBuffer& data) {
 		m_Buffer.insert(m_Buffer.end(), data.begin(), data.end());
 		return *this;
 	}

-	/**
-	 * \brief Read some data from the buffer and assign to desired variable
-	 */
 	template <typename T>
 	DataBuffer& operator>>(T& data) {
 		assert(m_ReadOffset + sizeof(T) <= GetSize());
@@ -92,10 +80,6 @@ class DataBuffer {
 		return *this;
 	}

-	/**
-	 * \brief Read some data from the buffer and assign to the new buffer
-	 * \param data The buffer to assign
-	 */
 	DataBuffer& operator>>(DataBuffer& data) {
 		data.Resize(GetSize() - m_ReadOffset);
 		std::copy(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), m_Buffer.end(), data.begin());
@@ -103,11 +87,7 @@ class DataBuffer {
 		return *this;
 	}

-	/**
-	 * \brief Read a string from the buffer
-	 * \param str The string to assign in the new buffer
-	 * \warning Don't use it for binary data !
-	 */
+	// Don't use it for binary data !
 	DataBuffer& operator>>(std::string& str) {
 		std::size_t stringSize =
 			strlen(reinterpret_cast<const char*>(m_Buffer.data()) + m_ReadOffset) + 1;	// including null character
@@ -118,55 +98,30 @@ class DataBuffer {
 		return *this;
 	}

-	/**
-	 * \brief Write some data to the buffer
-	 * \param buffer The buffer to write
-	 * \param amount The amount of data to write
-	 */
 	void WriteSome(const char* buffer, std::size_t amount) {
 		std::size_t end_pos = m_Buffer.size();
 		m_Buffer.resize(m_Buffer.size() + amount);
-		std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
+		memcpy(m_Buffer.data() + end_pos, buffer, amount);
 	}

-	/**
-	 * \brief Write some data to the buffer
-	 * \param buffer The buffer to write
-	 * \param amount The amount of data to write
-	 */
 	void WriteSome(const std::uint8_t* buffer, std::size_t amount) {
 		std::size_t end_pos = m_Buffer.size();
 		m_Buffer.resize(m_Buffer.size() + amount);
-		std::memcpy(m_Buffer.data() + end_pos, buffer, amount);
+		memcpy(m_Buffer.data() + end_pos, buffer, amount);
 	}

-	/**
-	 * \brief Read some data from the buffer
-	 * \param buffer The buffer to Read
-	 * \param amount The amount of data from the buffer
-	 */
 	void ReadSome(char* buffer, std::size_t amount) {
 		assert(m_ReadOffset + amount <= GetSize());
 		std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
 		m_ReadOffset += amount;
 	}

-	/**
-	 * \brief Read some data from the buffer
-	 * \param buffer The buffer to Read
-	 * \param amount The amount of data from the buffer
-	 */
 	void ReadSome(std::uint8_t* buffer, std::size_t amount) {
 		assert(m_ReadOffset + amount <= GetSize());
 		std::copy_n(m_Buffer.begin() + static_cast<difference_type>(m_ReadOffset), amount, buffer);
 		m_ReadOffset += amount;
 	}

-	/**
-	 * \brief Read some data from the buffer
-	 * \param buffer The buffer to Read
-	 * \param amount The amount of data from the buffer
-	 */
 	void ReadSome(DataBuffer& buffer, std::size_t amount) {
 		assert(m_ReadOffset + amount <= GetSize());
 		buffer.Resize(amount);
@@ -174,113 +129,64 @@ class DataBuffer {
 		m_ReadOffset += amount;
 	}

-	/**
-	 * \brief Resize the buffer
-	 * \param size The new size of the buffer
-	 */
 	void Resize(std::size_t size) {
 		m_Buffer.resize(size);
 	}

-	/**
-	 * \brief Reserve some space in the buffer
-	 * \param amount The amount of space to reserve
-	 */
 	void Reserve(std::size_t amount) {
 		m_Buffer.reserve(amount);
 	}

+	void erase(iterator it) {
+		m_Buffer.erase(it);
+	}

-	/**
-	 * \brief Clear the buffer
-	 */
 	void Clear() {
 		m_Buffer.clear();
 		m_ReadOffset = 0;
 	}

-	/**
-	 * \brief When the buffer has been read entirely
-	 */
 	bool IsFinished() const {
 		return m_ReadOffset >= m_Buffer.size();
 	}

-	/**
-	 * \brief Get the buffer data
-	 */
 	std::uint8_t* data() {
 		return m_Buffer.data();
 	}

-	/**
-	 * \brief Get the buffer data
-	 */
 	const std::uint8_t* data() const {
 		return m_Buffer.data();
 	}

-	/**
-	 * \brief Get the read offset
-	 */
 	std::size_t GetReadOffset() const {
 		return m_ReadOffset;
 	}

-	/**
-	 * \brief Set the read offset
-	 * \param pos The new read offset
-	 */
 	void SetReadOffset(std::size_t pos);

-	/**
-	 * \brief Get the size of the buffer
-	 */
 	std::size_t GetSize() const;
-
-	/**
-	 * \brief Get the remaining size of the buffer
-	 */
 	std::size_t GetRemaining() const;

-	/**
-	 * \brief Read a file into the buffer
-	 * \param fileName The name of the file to read
-	 */
+	iterator begin();
+	iterator end();
+	const_iterator begin() const;
+	const_iterator end() const;
+
 	bool ReadFile(const std::string& fileName);
+	bool WriteFile(const std::string& fileName);

-	/**
-	 * \brief Write a file into the buffer
-	 * \param fileName The name of the file to write to
-	 */
-	bool WriteFile(const std::string& fileName) const;
-
-	/**
-	 * \brief Allocate the buffer on the heap
-	 * \warning Don't forget to free the data !
-	 */
+	// Don't forget to free the data !
 	std::uint8_t* HeapAllocatedData() const {
 		std::uint8_t* newBuffer = new std::uint8_t[GetSize()];
 		std::memcpy(newBuffer, data(), GetSize());
 		return newBuffer;
 	}

-	/**
-	 * \brief Operator == to compare two DataBuffer
-	 */
-	bool operator==(const DataBuffer& other) const {
+	bool operator==(const DataBuffer& other) const{
 		return m_Buffer == other.m_Buffer;
 	}
-
-	iterator begin();
-	iterator end();
-	const_iterator begin() const;
-	const_iterator end() const;
 };

-/**
- * \brief Operator << to write a DataBuffer to an ostream
- */
 std::ostream& operator<<(std::ostream& os, const DataBuffer& buffer);

 }  // namespace blitz
--- a/include/blitz/common/Defines.h
+++ b/include/blitz/common/Defines.h
@@ -3,7 +3,7 @@
 /**
 * \file Defines.h
 * \brief File containing constants and typedefs
- */
+*/

 #include <cstdint>

@@ -13,20 +13,8 @@ namespace game {
 /**
 * \typedef PlayerID
 * \brief Represents the identifier of a Player
- */
+*/
 typedef std::uint8_t PlayerID;

-/**
- * \enum GameState
- * \brief The states of the game
- */
-enum GameState : std::uint8_t {
-	gsNone = 0,	 /**< Default state */
-	gsWaiting,	 /**< Waiting state if the number of players is less than 2 */
-	gsPreparing, /**< Preparing state until the game start */
-	gsGame,		 /**< Game state during the players can shoot and kill ... */
-	gsEnd,		 /**< End state of the game : show the winner of the game and the leaderboard*/
-};
-
 }  // namespace game
 }  // namespace blitz
--- a/include/blitz/common/NonCopyable.h
+++ b/include/blitz/common/NonCopyable.h
@@ -1,17 +1,7 @@
 #pragma once

-/**
- * \file NonCopyable.h
- * \brief File containing the blitz::NonCopyable class
- */
-
 namespace blitz {

-/**
- * \class NonCopyable
- * \brief Class used to make a class non copyable
- * \note Inherit from this class privately to make a class non copyable
- */
 class NonCopyable {
  public:
 	NonCopyable(const NonCopyable&) = delete;
--- a/include/blitz/common/Smoothing.h
+++ b/include/blitz/common/Smoothing.h
@@ -2,38 +2,17 @@

 namespace blitz {

-/**
- * \struct An exponential moving average smoother, or one pole lowpass filter
- * smoothes incoming data by attenutating sharp/sudden changes
-*/
 class EMASmoother {
  private:
 	float Alpha;

-	float GetAlpha();
-	void SetAlpha(float alpha);
-
  public:
-	/**
-	 * \brief the current output value of the smoother 
-	*/
 	float Current;
 	EMASmoother();
-	/**
-	 * \brief behaves like `Tick(target, 1.0f)` but optimised
-	*/
 	void TickUnitT(float target);
-	/**
-	 * \brief feed in the next value to the filter, and update `Current` accordingly
-	 * \param target the value in question
-	 * \param delta the time that has passed sinced the last value has been provided
-	*/
 	void Tick(float target, float delta);
-
-	/**
-	 * \brief set the amount of time it should take to reacha certain value, the higher this is
-	 * the "smoother the output signal"
-	*/
+	float GetAlpha();
+	void SetAlpha(float alpha);
 	void SetSmoothingTime(float t);
 };

--- a/include/blitz/common/VarInt.h
+++ b/include/blitz/common/VarInt.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file VarInt.h
- * \brief File containing the blitz::VarInt class
- */
-
 #include <cstddef>
 #include <cstdint>

@@ -12,46 +7,21 @@ namespace blitz {

 class DataBuffer;

-/**
- * \class VarInt
- * \brief Variable-length format such that smaller numbers use fewer bytes.
- */
 class VarInt {
  private:
 	std::uint64_t m_Value;

  public:
 	VarInt() : m_Value(0) {}
-	/**
-	 * \brief Construct a variable integer from a value
-	 * \param value The value of the variable integer
-	 */
 	VarInt(std::uint64_t value) : m_Value(value) {}

-	/**
-	 * \brief Get the value of the variable integer
-	 */
 	std::uint64_t GetValue() const {
 		return m_Value;
 	}

-	/**
-	 * \brief Get the length of the serialized variable integer
-	 */
 	std::size_t GetSerializedLength() const;

-	/**
-	 * \brief Serialize the variable integer
-	 * \param out The buffer to write the serialized variable integer to
-	 * \param var The variable integer to serialize
-	 */
 	friend DataBuffer& operator<<(DataBuffer& out, const VarInt& var);
-
-	/**
-	 * \brief Deserialize the variable integer
-	 * \param in The buffer to read the serialized variable integer from
-	 * \param var The variable integer to deserialize
-	 */
 	friend DataBuffer& operator>>(DataBuffer& in, VarInt& var);
 };

--- a/include/blitz/game/Game.h
+++ b/include/blitz/game/Game.h
@@ -1,150 +1,35 @@
 #pragma once

-/**
- * \file Game.h
- * \brief File containing the blitz::game::Game class
- */
-
 #include "Player.h"
-#include "blitz/game/Listeners.h"
-#include "blitz/game/World.h"
-#include "blitz/misc/ObjectNotifier.h"
-#include "blitz/misc/Time.h"
 #include <map>
-#include <memory>

 namespace blitz {
 namespace game {

-/**
- * \typedef PlayerMap
- * \brief A map of players
- */
 typedef std::map<PlayerID, Player> PlayerMap;

-/**
- * \brief The game configuration
- * \struct GameConfig
- */
-struct GameConfig {
-	/**
-	 * \brief The gravity applied to players
-	 */
-	float Gravity;
-	/**
-	 * \brief The firing rate of the shoot in RPM (round per minute)
-	 */
-	int FiringRate;
-};
-
-/**
- * \class Game
- * \brief Class representing a game
- */
-class Game : public utils::ObjectNotifier<GameListener> {
-  protected:
+class Game {
+  private:
 	PlayerMap m_Players;
-	GameState m_GameState;
-	utils::Timer m_GameTimer;
-	GameConfig m_Config;
-	std::unique_ptr<World> m_World;

  public:
-	/** \brief Default constructor */
-	Game() : m_GameState(gsNone) {}
+	Game() {}

-	/**
-	 * \brief Update the game with a delta time
-	 * \param delta The time elapsed since the last update in milliseconds
-	 */
 	virtual void Tick(std::uint64_t delta) = 0;

-	/**
-	 * \brief Get a player by its identifier
-	 * \param id The identifier of the player
-	 * \return The player if found, nullptr otherwise
-	 */
 	Player* GetPlayerById(PlayerID id);
-
-	/**
-	 * \brief Get a player by its identifier (const version)
-	 * \param id The identifier of the player
-	 * \return The player if found, nullptr otherwise
-	 */
 	const Player* GetPlayerById(PlayerID id) const;

-	/**
-	 * \brief Get the players
-	 * \return The map of players
-	 */
 	PlayerMap& GetPlayers() {
 		return m_Players;
 	}

-	/**
-	 * \brief Get the players (const version)
-	 * \return The map of players
-	 */
 	const PlayerMap& GetPlayers() const {
 		return m_Players;
 	}

-	/**
-	 * \brief Get the game state
-	 * \return The game state
-	 */
-	GameState GetGameState() const {
-		return m_GameState;
-	}
-
-	/**
-	 * \brief Set the game state
-	 * \return The game state
-	 */
-	virtual void UpdateGameState(GameState newGameState, std::uint64_t timeRemaining);
-
-	/**
-	 * \brief Load the game configuration
-	 * \param config The game configuration to load
-	 */
-	void LoadConfig(const GameConfig& config) {
-		m_Config = config;
-	}
-
-	/**
-	 * \brief Get the game configuration
-	 * \return The game configuration
-	 */
-	const game::GameConfig& GetGameConfig() const {
-		return m_Config;
-	}
-
-	/**
-	 * \brief Add a player to the game
-	 * \param player The identifier of the player
-	 * \param name The name of the player
-	 */
 	virtual void AddPlayer(PlayerID player, const std::string& name);
-	/**
-	 * \brief Remove a player from the game
-	 * \param player The identifier of the player
-	 */
 	virtual void RemovePlayer(PlayerID player);
-
-	/**
-	 * \brief Get the remaining time of the game
-	 * \return The remaining time of the game in milliseconds
-	 */
-	std::uint64_t GetGameStateRemainingTime() const {
-		return m_GameTimer.GetTimeRemaining();
-	}
-
-	/**
-	 * \return The world associated with this game
-	 */
-	const World* GetWorld() const {
-		return m_World.get();
-	}
 };


--- a/include/blitz/game/LeaderBoard.h
+++ b/include/blitz/game/LeaderBoard.h
@@ -1,49 +0,0 @@
-#pragma once
-
-/**
- * \file LeaderBoard.h
- * \brief File containing the blitz::game::LeaderBoard class
- */
-
-#include "blitz/game/Player.h"
-#include <vector>
-
-namespace blitz {
-namespace game {
-
-/**
- * \class LeaderBoard
- * \brief The leaderboard of the game
- */
-class LeaderBoard {
-  private:
-	std::vector<Player*> m_Players;
-
-  public:
-	/**
-	 * \brief Add a player to the leaderboard
-	 * \param player The player to add
-	 */
-	void AddPlayer(Player* player);
-	/**
-	 * \brief Remove a player from the leaderboard
-	 * \param player The player to remove
-	 */
-	void RemovePlayer(PlayerID player);
-
-	/**
-	 * \brief Update the leaderboard
-	 */
-	void Update();
-
-	/**
-	 * \brief Get the players in the leaderboard ordered by kills
-	 * \return The players
-	 */
-	const std::vector<Player*>& GetPlayers() const {
-		return m_Players;
-	}
-};
-
-}  // namespace game
-}  // namespace blitz
--- a/include/blitz/game/Listeners.h
+++ b/include/blitz/game/Listeners.h
@@ -1,18 +1,8 @@
 #pragma once

-#include "blitz/common/Defines.h"
 #include "blitz/maths/Vector.h"
-#include <vector>

 namespace blitz {
-
-namespace protocol {
-
-struct ColoredPart;
-typedef std::vector<ColoredPart> ColoredText;
-
-}  // namespace protocol
-
 namespace game {

 class PlayerInputListener {
@@ -21,23 +11,5 @@ class PlayerInputListener {
 	virtual void OnLocalPlayerShoot(const Vec3f& position, float yaw, float pitch) {}
 };

-class GameListener {
-  public:
-	virtual void OnPlayerJoin(game::PlayerID player) {}
-	virtual void OnPlayerLeave(game::PlayerID player) {}
-	virtual void OnGameStateUpdate(game::GameState newState) {}
-};
-
-class ClientListener {
-  public:
-	virtual void OnTextChatReceived(const protocol::ColoredText& text) {}
-	virtual void OnSpectatorChange(game::PlayerID player) {}
-	virtual void OnPlayerShoot(PlayerID player, const Vec3f& position, float yaw, float pitch) {}
-	virtual void OnClientPlayerJoin() {}
-	virtual void OnGameConfigUpdate() {}
-	virtual void OnGameJoin() {}
-	virtual void OnGameLeave() {}
-};
-
 }  // namespace game
 }  // namespace blitz
--- a/include/blitz/game/Player.h
+++ b/include/blitz/game/Player.h
@@ -1,49 +1,22 @@
 #pragma once

-/**
- * \file Player.h
- * \brief File containing the blitz::game::Player class
- */
-
 #include "blitz/common/Defines.h"
 #include "blitz/maths/Vector.h"
-#include "blitz/maths/Physics.h"
 #include <cstdint>
 #include <string>

 namespace blitz {
 namespace game {

-/**
- * \struct PlayerStats
- * \brief The statistics of a player
- */
 struct PlayerStats {
-	/**
-	 * \brief The number of deaths
-	 */
 	std::uint16_t m_Deaths;
-	/**
-	 * \brief The number of kills
-	 */
 	std::uint16_t m_Kills;
-	/**
-	 * \brief The number of shots
-	 */
 	std::uint32_t m_ShootCount;
-	/**
-	 * \brief The number of successful shots
-	 */
 	std::uint32_t m_ShootSuccessCount;
 };

-/**
- * \class Player
- * \brief The player of the game
- */
 class Player {
  private:
-	maths::AABB m_Hitbox;
 	PlayerID m_ID;
 	std::string m_Name;
 	Vec3f m_Position;
@@ -52,186 +25,89 @@ class Player {
 	float m_Pitch;
 	float m_HP;
 	bool m_IsBot;
-	PlayerStats m_Stats{};

  public:
-	/**
-	 * \brief Default constructor
-	 * \param id The ID of the player
-	 */
 	Player(PlayerID id) : m_ID(id), m_Yaw(0), m_Pitch(0), m_HP(100), m_IsBot(false) {}
+	PlayerStats m_Stats{};

-	/**
-	 * \brief Get the ID of the player
-	 * \return The ID of the player
-	 */
 	PlayerID GetID() const {
 		return m_ID;
 	}

-	/**
-	 * \brief Get the name of the player
-	 * \return The name of the player
-	 */
 	const std::string& GetName() const {
 		return m_Name;
 	}

-	/**
-	 * \brief Set the name of the player
-	 * \param name The name of the player
-	 */
 	void SetName(const std::string& name) {
 		m_Name = name;
 	}

-	/**
-	 * \brief Get the player's hitbox
-	*/
-	maths::AABB GetHitBox() const {
-		return m_Hitbox + m_Position;
-	}
-
-	/**
-	 * \brief Sets the player's hitbox
-	*/
-	void SetHitBoxSize(const maths::AABB& aabb) {
-		m_Hitbox = aabb;
-	}
-
-	/**
-	 * \brief Get the position of the player
-	 * \return The position of the player
-	 */
 	const Vec3f& GetPosition() const {
 		return m_Position;
 	}

-	/**
-	 * \brief Set the position of the player
-	 * \param newPos The new position of the player
-	 */
 	void SetPosition(const Vec3f& newPos) {
 		m_Position = newPos;
 	}

-	/**
-	 * \brief Add a position to the player
-	 * \param dPos The position to add
-	 */
 	void AddPosition(const Vec3f& dPos) {
 		m_Position += dPos;
 	}

-	/**
-	 * \brief Get the velocity of the player
-	 * \return The velocity of the player
-	 */
 	const Vec3f& GetVelocity() const {
 		return m_Velocity;
 	}

-	/**
-	 * \brief Set the velocity of the player
-	 * \param newVelocity The new velocity of the player
-	 */
 	void SetVelocity(const Vec3f& newVelocity) {
 		m_Velocity = newVelocity;
 	}

-	/**
-	 * \brief Get the yaw of the player
-	 * \return The yaw of the player in radians
-	 */
 	float GetYaw() const {
 		return m_Yaw;
 	}

-	/**
-	 * \brief Set the yaw of the player
-	 * \param yaw The yaw of the player in radians
-	 */
 	void SetYaw(float yaw) {
 		m_Yaw = yaw;
 	}

-	/**
-	 * \brief Add a yaw to the player
-	 * \param dYaw The yaw to add in radians
-	 */
 	void AddYaw(float dYaw) {
 		m_Yaw += dYaw;
 	}

-	/**
-	 * \brief Get the pitch of the player
-	 * \return The pitch of the player in radians
-	 */
 	float GetPitch() const {
 		return m_Pitch;
 	}

-	/**
-	 * \brief Set the pitch of the player
-	 * \param pitch The pitch of the player in radians
-	 */
 	void SetPitch(float pitch) {
 		m_Pitch = pitch;
 	}

-	/**
-	 * \brief Add a pitch to the player
-	 * \param dPitch The pitch to add in radians
-	 */
 	void AddPitch(float dPitch) {
 		m_Pitch += dPitch;
 	}

-	/**
-	 * \brief Get the HP of the player
-	 * \return The HP of the player
-	 */
 	float GetHP() const {
 		return m_HP;
 	}

-	/**
-	 * \brief Set the HP of the player
-	 * \param hp The HP of the player
-	 */
 	void SetHP(float hp) {
 		m_HP = hp;
 	}

-	/**
-	 * \brief When the player is a bot
-	 * \return True if the player is a bot
-	 */
 	bool IsBot() const {
 		return m_IsBot;
 	}

-	/**
-	 * \brief Set the player as a bot
-	 */
 	void SetBot() {
 		m_IsBot = true;
 	}

-	/**
-	 * \brief Get the statistics of the player (const version)
-	 * \return The statistics of the player
-	 */
-	const PlayerStats& GetStats() const {
+	PlayerStats& GetStats() {
 		return m_Stats;
 	}

-	/**
-	 * \brief Get the statistics of the player
-	 * \return The statistics of the player
-	 */
-	PlayerStats& GetStats() {
-		return m_Stats;
+	void SetStats(const PlayerStats& stats) {
+		m_Stats = stats;
 	}
 };

--- a/include/blitz/game/World.h
+++ b/include/blitz/game/World.h
@@ -1,27 +0,0 @@
-#pragma once
-
-#include "blitz/game/Listeners.h"
-#include "blitz/maths/Physics.h"
-#include <vector>
-
-namespace blitz {
-namespace game {
-
-class Game;
-
-class World {
-  protected:
-	Game* m_Game;
-	std::vector<maths::AABB> m_AABBs;
-
-  public:
-	World(Game* game);
-	virtual ~World();
-
-	const std::vector<maths::AABB>& GetAABBs() const {
-		return m_AABBs;
-	}
-};
-
-}  // namespace game
-}  // namespace blitz
--- a/include/blitz/maths/Maths.h
+++ b/include/blitz/maths/Maths.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file Maths.h
- * \brief File containing mathematical functions and constants
- */
-
 #include "blitz/maths/Vector.h"
 #include <cmath>

@@ -13,19 +8,18 @@ namespace maths {

 static constexpr float PI = 3.141592653f;

-/**
- * \return the amount of overlap between the ranges [a1 ; b1] and [a2 ; b2]
- */
 template <typename T>
+/**
+ * @brief returns the amount of overlap between the ranges [a1 ; b1] and [a2 ; b2]
+*/
 T RangesOverlap(T& a1, T& b1, T& a2, T& b2) {
 	return std::min(std::max(a1, b1), std::max(a2, b2)) - std::max(std::min(a1, b1), std::min(a2, b2));
 }

-
-/**
- * \return whether the ranges [a1 ; b1] and [a2 ; b2] overlap
- */
 template <typename T>
+/**
+ * @brief returns whether the ranges [a1 ; b1] and [a2 ; b2] overlap
+*/
 bool RangesOverlapping(T& a1, T& b1, T& a2, T& b2) {
 	return RangesOverlap(a1, a2, b1, b2) >= 0;
 }
@@ -34,19 +28,11 @@ bool RangesOverlapping(T& a1, T& b1, T& a2, T& b2) {
 // 							Vectors								//
 //////////////////////////////////////////////////////////////////

-/**
- * \brief Returns the length of the vector
- * \return the length of the vector
- */
 template <typename T>
 T Length(const Vec3<T>& vect) {
 	return std::sqrt(vect.x * vect.x + vect.y * vect.y + vect.z * vect.z);
 }

-/**
- * \brief Normalizes the vector
- * \return the normalized vector
- */
 template <typename T>
 Vec3<T> Normalize(const Vec3<T>& vect) {
 	T length = Length(vect);
@@ -54,10 +40,6 @@ Vec3<T> Normalize(const Vec3<T>& vect) {
 	return {vect.x / length, vect.y / length, vect.z / length};
 }

-/**
- * \brief Normalizes the vector
- * \return the normalized vector
- */
 template <typename T>
 Vec4<T> Normalize(const Vec4<T>& vect) {
 	T length = std::sqrt(vect.x * vect.x + vect.y * vect.y + vect.z * vect.z + vect.w * vect.w);
@@ -65,19 +47,11 @@ Vec4<T> Normalize(const Vec4<T>& vect) {
 	return {vect.x / length, vect.y / length, vect.z / length, vect.w / length};
 }

-/**
- * \brief Returns the dot product of the two vectors
- * \return the dot product of the two vectors
- */
 template <typename T>
 T Dot(const Vec3<T>& vect, const Vec3<T>& other) {
 	return vect.x * other.x + vect.y * other.y + vect.z * other.z;
 }

-/**
- * \brief Returns the cross product of the two vectors
- * \return the cross product of the two vectors
- */
 template <typename T>
 Vec3<T> Cross(const Vec3<T>& vect, const Vec3<T>& other) {
 	return {
@@ -87,102 +61,82 @@ Vec3<T> Cross(const Vec3<T>& vect, const Vec3<T>& other) {
 	};
 }

-/**
- * \brief Returns the dot product of the two vectors
- * \return the dot product of the two vectors
- */
 template <typename T>
 T Dot(const Vec4<T>& vect, const Vec4<T>& other) {
 	return vect.x * other.x + vect.y * other.y + vect.z * other.z + vect.w * other.w;
 }

-/**
- * \brief Returns the distance between the two vectors
- * \return the distance between the two vectors
- */
 template <typename T>
 T Distance(const Vec3<T>& vect, const Vec3<T>& other) {
 	return Length(vect - other);
 }

-/**
- * \brief Returns the minimum of the three coordinates of the vector
- * \return the minimum between the three coordinates of the vector
- */
+// it seems that `std::{min, max}`'s behavior conflicts with that of `cmath`'s `f{min, max}[f]`
+// Why? Like I fucking know dude
+
+
 template <typename T>
 T ReduceMin(const Vec3<T>& vect) {
 	return std::min(std::min(vect.x, vect.y), vect.z);
 }

-/**
- * \brief Returns the maximum of the three coordinates of the vector
- * \return the maximum between the three coordinates of the vector
- */
 template <typename T>
 T ReduceMax(const Vec3<T>& vect) {
 	return std::max(std::max(vect.x, vect.y), vect.z);
 }

 /**
- * \brief Returns the (signed) minimal coordinate of the vector
- * \param v a vector
- * \return the (signed) minimal coordinate of the vector
+ * @brief returns the (signed) minimal coordinate of the vector
+ *
+ * @param v
+ * @return constexpr T
 */
-inline float ReduceFMinF(const Vec3f& v) {
+template <>
+inline float ReduceMin<float>(const Vec3f& v) {
 	return std::fminf(std::fminf(v.x, v.y), v.z);
 }

-inline Vec3f FmaF(const Vec3f& v, const Vec3f& a, const Vec3f& b) {
-	return {
-		std::fmaf(v.x, a.x, b.x),
-		std::fmaf(v.y, a.y, b.y),
-		std::fmaf(v.z, a.z, b.z),
-	};
-}
-
-inline Vec3d Fma(const Vec3d& v, const Vec3d& a, const Vec3d& b) {
-	return {
-		std::fma(v.x, a.x, b.x),
-		std::fma(v.y, a.y, b.y),
-		std::fma(v.z, a.z, b.z),
-	};
-}
-
 /**
- * \brief Returns the (signed) maximal coordinate of the vector
- * \param v a vector
- * \return the (signed) maximal coordinate of the vector
+ * @brief returns the (signed) maximal coordinate of the vector
+ *
+ * @param v
+ * @return constexpr T
 */
-inline float ReduceFMaxF(const Vec3f& v) {
+template <>
+inline float ReduceMax<float>(const Vec3f& v) {
 	return std::fmaxf(std::fmaxf(v.x, v.y), v.z);
 }

 /**
- * \brief returns the (signed) minimal coordinate of the vector
- * \param v a vector
- * \return the (signed) minimal coordinate of the vector
+ * @brief returns the (signed) minimal coordinate of the vector
+ *
+ * @param v
+ * @return constexpr T
 */
-inline double ReduceFMin(const Vec3d& v) {
+template <>
+inline double ReduceMin<double>(const Vec3d& v) {
 	return std::fmin(std::fmin(v.x, v.y), v.z);
 }

 /**
- * \brief returns the (signed) maximal coordinate of the vector
- * \param v a vector
- * \return the (signed) maximal coordinate of the vector
+ * @brief returns the (signed) maximal coordinate of the vector
+ *
+ * @param v
+ * @return constexpr T
 */
-inline double ReduceFMax(const Vec3d& v) {
+template <>
+inline double ReduceMax<double>(const Vec3d& v) {
 	return std::fmax(std::fmax(v.x, v.y), v.z);
 }

 /**
- * \brief returns the coordinate-wise minimum of the given vectors, where a coordinate in the returned vector is NAN iff any of the two
- * compared ones are NAN
- * \tparam T
- * \param self a vector
- * \param other an other vector
- * \return the coordinate-wise minimum of the given vectors, where a coordinate in the returned vector is NAN iff any of the two
- * compared ones are NAN
+ * @brief returns the coordinate-wise minimum of the given vectors,
+ * where a coordinate in the returned vector is NAN iff any of the two compared ones are NAN
+ *
+ * @tparam T
+ * @param self
+ * @param other
+ * @return constexpr Vec3f
 */
 template <typename T>
 constexpr Vec3<T> Min(const Vec3<T>& self, const Vec3<T>& other) {
@@ -193,23 +147,6 @@ constexpr Vec3<T> Min(const Vec3<T>& self, const Vec3<T>& other) {
 	};
 }

-/**
- * @brief returns the coordinate-wise minimum of the given vectors,
- * where a coordinate in the returned vector is NAN iff both of the two compared ones are NAN
- *
- * @tparam T
- * @param self
- * @param other
- * @return constexpr Vec3f
- */
-constexpr Vec3f FMinF(const Vec3f& self, const Vec3f& other) {
-	return {
-		std::fminf(self.x, other.x),
-		std::fminf(self.y, other.y),
-		std::fminf(self.z, other.z),
-	};
-}
-
 /**
 * @brief returns the coordinate-wise maximum of the given vectors,
 * where a coordinate in the returned vector is NAN iff any of the two compared ones are NAN
@@ -217,7 +154,7 @@ constexpr Vec3f FMinF(const Vec3f& self, const Vec3f& other) {
 * @tparam T
 * @param self
 * @param other
- * @return constexpr Vec3
+ * @return constexpr Vec3f
 */
 template <typename T>
 constexpr Vec3<T> Max(const Vec3<T>& self, const Vec3<T>& other) {
@@ -228,53 +165,10 @@ constexpr Vec3<T> Max(const Vec3<T>& self, const Vec3<T>& other) {
 	};
 }

-/**
- * @brief returns the coordinate-wise maximum of the given vectors,
- * where a coordinate in the returned vector is NAN iff both of the two compared ones are NAN
- *
- * @tparam T
- * @param self
- * @param other
- * @return constexpr Vec3
- */
-constexpr Vec3f FMaxF(const Vec3f& self, const Vec3f& other) {
-	return {
-		std::fmaxf(self.x, other.x),
-		std::fmaxf(self.y, other.y),
-		std::fmaxf(self.z, other.z),
-	};
-}
-
-/**
- * @brief lane-wise copysign
-*/
-constexpr Vec3f CopysignF(const Vec3f& v, const Vec3f& signs) {
-	return {
-		std::copysignf(v.x, signs.x),
-		std::copysignf(v.y, signs.y),
-		std::copysignf(v.z, signs.z),
-	};
-}
-
-/**
- * @brief lane-wise copysign
-*/
-constexpr Vec3d Copysign(const Vec3d& v, const Vec3d& signs) {
-	return {
-		std::copysign(v.x, signs.x),
-		std::copysign(v.y, signs.y),
-		std::copysign(v.z, signs.z),
-	};
-}
-
 //////////////////////////////////////////////////////////////////
-// 						    Matrices							//
+// 						    Matricies							//
 //////////////////////////////////////////////////////////////////

-/**
- * \brief Returns the dot product of the matrix and the vector
- * \return the dot product of the matrix and the vector
- */
 template <typename T>
 Vec4<T> Dot(const Mat4<T>& mat, const Vec4<T>& vect) {
 	return {mat.x0 * vect.x + mat.x1 * vect.y + mat.x2 * vect.z + mat.x3 * vect.w,
@@ -283,10 +177,6 @@ Vec4<T> Dot(const Mat4<T>& mat, const Vec4<T>& vect) {
 		mat.w0 * vect.x + mat.w1 * vect.y + mat.w2 * vect.z + mat.w3 * vect.w};
 }

-/**
- * \brief Returns the dot product of the matrix and an other matrix
- * \return the dot product of the matrix and the other matrix
- */
 template <typename T>
 Mat4<T> Dot(const Mat4<T>& mat, const Mat4<T>& other) {
 	Mat4<T> result{};
@@ -302,10 +192,6 @@ Mat4<T> Dot(const Mat4<T>& mat, const Mat4<T>& other) {
 	return result;
 }

-/**
- * \brief Returns the identity matrix
- * \return the identity matrix
- */
 template <typename T>
 Mat4<T> Identity() {
 	Mat4<T> result{};
@@ -318,10 +204,6 @@ Mat4<T> Identity() {
 	return result;
 }

-/**
- * \brief Returns the transposed matrix
- * \return the transposed matrix
- */
 template <typename T>
 Mat4<T> Transpose(const Mat4<T>& mat) {
 	Mat4<T> result;
@@ -346,88 +228,22 @@ Mat4<T> Transpose(const Mat4<T>& mat) {
 	return result;
 }

-/**
- * \brief Returns the perspective matrix
- * \param fovY The field of view in the y direction
- * \param aspectRatio The aspect ratio of the screen
- * \param zNear The near clipping plane
- * \param zFar The far clipping plane
- * \return the perspective matrix
- */
 Mat4f Perspective(float fovY, float aspectRatio, float zNear, float zFar);
-/**
- * \brief Returns the look matrix
- * \param eyePos The position of the camera
- * \param front The front vector of the camera
- * \param up The up vector of the camera
- * \return the look matrix
- */
 Mat4f Look(const Vec3f& eyePos, const Vec3f& front, const Vec3f& up);

-/**
- * \brief Returns the inverse of the matrix
- * \return the inverse of the matrix
- */
 Mat4f Inverse(const Mat4f& mat);

-/**
- * \brief Returns the translation matrix
- * \param translation The translation vector
- * \return the translation matrix
- */
 Mat4f Translate(const Vec3f& translation);

-/**
- * \brief Returns the scale matrix
- * \param axisFactor The scaling factor for each axis
- * \return the scale matrix
- */
 Mat4f Scale(const Vec3f& axisFactor);

-/**
- * \brief Returns the rotation matrix around the x axis
- * \param angle The angle of rotation
- * \return the rotation matrix
- */
 Mat4f RotateX(float angle);
-/**
- * \brief Returns the rotation matrix around the y axis
- * \param angle The angle of rotation
- * \return the rotation matrix
- */
 Mat4f RotateY(float angle);
-/**
- * \brief Returns the rotation matrix around the z axis
- * \param angle The angle of rotation
- * \return the rotation matrix
- */
 Mat4f RotateZ(float angle);

-/**
- * \brief Returns the rotation matrix
- * \param angles The angles of rotation
- * \return the rotation matrix
- */
 Mat4f Rotate(const Vec3f& angles);

-/**
- * \brief Returns the rotation matrix
- * \param angle The angle of rotation
- * \param axis The axis of rotation
- * \return the rotation matrix
- */
 Mat4f Rotate(float angle, Vec3f axis);

-
-
-
-
-/**
- * \brief Returns the unit vector correspond to the yaw and pitch
- * \param yaw Angle in radians
- * \param pitch Angle in radians
- */
-Vec3f GetDirectionVectorFromRotation(float yaw, float pitch);
-
 }  // namespace maths
 }  // namespace blitz
--- a/include/blitz/maths/Physics.h
+++ b/include/blitz/maths/Physics.h
@@ -1,149 +1,30 @@
 #pragma once

-/**
- * \file Physics.h
- * \brief Physics logic
- */
-
-#include "blitz/maths/Maths.h"
-#include <optional>
+#include "blitz/maths/Vector.h"

 namespace blitz {
 namespace maths {

-/**
- * \enum Axis
- * \brief represents an axis in 3-dimensional space
-*/
-enum Axis : std::size_t { aX = 0, aY, aZ };
-
-/**
- * \brief encodes the movement an entity must perform, in an environment containing other
- * entitis it may collide with
- */
-struct CollisionData {
-	/**
-	 * \brief the effective movement the entity can/should perform, immediately
-	 */
-	Vec3f delta;
-	/**
-	 * \brief the direction of "slide" along a side of a bounding
-	 * box, this is 0 if no collisions occured
-	 */
-	Vec3f slide;
+struct Ray {
+	Vec3f origin;
+	Vec3f direction;
 };

-/**
- * \struct IntersectionData
- * \brief Intermediate data encoding an intersection between a Ray/AABB and an AABB
- */
-struct IntersectionData {
-	/**
-	 * \brief by how much to translate before intersecting with the AABB
-	 */
-	float distance;
-	/**
-	 * \brief the axis along which the collision happens, used to solve sliding requirements
-	 */
-	Axis axis;
-
-	/**
-	 * \brief Returns the movements that the entity must perform. It is advised to make sure
-	 *  `0.0f <= distance <= 1.0f` as this would return incoherent data
-	 * \pre `0.0f <= distance <= 1.0f`
-	 * \param dir
-	 * \return
-	 */
-	CollisionData ToCollision(const Vec3f& dir) const;
-};
-
-/**
- * \struct AABB
- * \brief an Axis Aligned Bounding Box, see wikipedia for more
- */
 struct AABB {
 	Vec3f from;
 	Vec3f to;
-
-	/**
-	 * \return A vector representing the center of mass of the box
-	 */
-	inline Vec3f Center() const;
-
-	/**
-	 * \return The same box but all the coordinates in `from` are less than their
-	 * counterparts in `to`.
-	 */
-	AABB Direct() const;
-
-	/**
-	 * \brief Enlarges this box along each axis by the length of the box along said axis
-	 * \param with
-	 * \return The new, big, box
-	 *
-	 */
-	AABB Enlarge(const AABB& with) const;
-
-	AABB operator+(const Vec3f& offset) const;
-
-	AABB operator+=(const Vec3f& offset);
-
-	/**
-	 * \brief checks if this box overlaps with another one
-	 * \param aabb
-	 * \return whether this box overlaps with another one
-	 */
-	bool OverlapsWith(const AABB& aabb) const;
-
-	/**
-	 * \brief Given this box is to be offset by some vector colinear to dir,
-	 * this function behave exactly like Ray::Intersection
-	 * \param aabb
-	 * \param dir
-	 * \return
-	 */
-	std::optional<IntersectionData> Intersection(const AABB& aabb, const Vec3f& dir) const;
 };

-/**
- * \struct Ray
- * \brief represents a (half-)line
- */
-struct Ray {
-	/**
-	 * \brief the origin/start/initial point of the line
-	 */
-	Vec3f origin;
-	/**
-	 * \brief the direction of the line
-	 */
-	Vec3f direction;
+inline AABB operator+(const AABB& aabb, const Vec3f& offset) {
+	AABB result = aabb;
+	result.from += offset;
+	result.to += offset;
+	return result;
+}

-	/**
-	 * \brief Note that t isn't necessarily positive
-	 * \param t
-	 *  \return `origin` + `direction` * `t`
-	 */
-	Vec3f operator()(float t) const;
+float Distance(const Ray& ray, const AABB& aabb);

-	/**
-	 * \brief Is essentially Intersection(aabb).distance >= 0.0f
-	 * \returns `true` if the half-line `ray` _strictly_ intersects with `aabb`,
-	 *  and `false` if it _strictly_ doesn't intersect.
-	 *  Note that if it only intersects with corners, edges, or sides of the box,
-	 *  or if any coordinate in `ray` is `NAN` or `inf` or if any coordinate in
-	 *  `aabb` is `NAN` the result is unspecified.
-	 */
-	bool Intersects(const AABB& aabb) const;
-
-	/**
-	 * \brief The `distance` field of the returned value is smallest number t
-	 * (in absolute value), if it exists, such that `ray(t)` is in `aabb`. otherwise
-	 * a quiet `NaN` is returned. The `axis` field is the axis to along
-	 * which `ray` intersects/collides with `aabb`
-	 */
-	std::optional<IntersectionData> Intersection(const AABB& aabb) const;
-};
+bool Intersects(const Ray& ray, const AABB& aabb);

 }  // namespace maths
 }  // namespace blitz
--- a/include/blitz/maths/Vector.h
+++ b/include/blitz/maths/Vector.h
@@ -1,11 +1,7 @@
 #pragma once

-/**
- * \file Vector.h
- * \brief File containing the Vector structs and 4x4 matrix
- */
-
 #include <algorithm>
+#include <cmath>
 #include <cstddef>

 namespace blitz {
@@ -47,34 +43,6 @@ struct Vec3 {
 	};

 	constexpr Vec3(T X = 0, T Y = 0, T Z = 0) : x(X), y(Y), z(Z) {}
-
-	static Vec3 splat(T val) {
-		return Vec3(val, val, val);
-	}
-
-	const T* data() const {
-		return reinterpret_cast<const T*>(this);
-	}
-
-	T* data() {
-		return reinterpret_cast<T*>(this);
-	}
-
-	const T& at(std::size_t index) const {
-		return data()[index];
-	}
-
-	T& at(std::size_t index) {
-		return data()[index];
-	}
-
-	const T& operator[](std::size_t index) const {
-		return at(index);
-	}
-
-	T& operator[](std::size_t index) {
-		return at(index);
-	}
 };

 template <typename T>
@@ -123,6 +91,10 @@ using Vec4d = Vec4<double>;

 using Color = Vec3uc;

+
+
+
+
 // Vec2

 template <typename T>
@@ -148,7 +120,7 @@ constexpr Vec2<T> operator-(const Vec2<T>& vect) {

 template <typename T>
 constexpr Vec2<T> operator-(const Vec2<T>& vect, const Vec2<T>& other) {
-	return {vect.x - other.x, vect.y - other.y};
+	return vect + (-other);
 }

 template <typename T>
@@ -167,6 +139,10 @@ constexpr Vec2<T> operator*(T mult, const Vec2<T>& vect) {
 	return vect * mult;
 }

+
+
+
+
 // Vec3

 template <typename T>
@@ -245,6 +221,11 @@ Vec3<T>& operator/=(Vec3<T>& vect, const Vec3<T>& other) {
 	return vect;
 }

+template <typename T>
+constexpr bool operator<(const Vec3<T>& vec3, const Vec3<T>& other) {
+	return vec3.x < other.x && vec3.y < other.y && vec3.z < other.z;
+}
+
 // Vec4

 template <typename T>
@@ -270,7 +251,7 @@ Vec4<T>& operator+=(Vec4<T>& vect, const Vec4<T>& other) {

 template <typename T>
 constexpr Vec4<T> operator-(const Vec4<T>& vect, const Vec4<T>& other) {
-	return {vect.x - other.x, vect.y - other.y, vect.z - other.z, vect.w - other.w};
+	return vect + (-other);
 }

 template <typename T>
--- a/include/blitz/misc/Easing.h
+++ b/include/blitz/misc/Easing.h
@@ -1,88 +1,63 @@
 #pragma once

-/**
- * \file Easing.h
- * \brief File containing mathematical functions and constants
- */
-
 namespace blitz {
 namespace utils {

-/**
- * \brief Sine functions
- */
+/* Sine functions */

 float EaseInSine(float x);
 float EaseOutSine(float x);
 float EaseInOutSine(float x);

-/**
- * \brief Cubic functions
- */
+/* Cubic functions */

 float EaseInCubic(float x);
 float EaseOutCubic(float x);
 float EaseInOutCubic(float x);

-/**
- * \brief Quint functions
- */
+/* Quint functions */

 float EaseInQuint(float x);
 float EaseOutQuint(float x);
 float EaseInOutQuint(float x);

-/**
- * \brief Circ functions
- */
+/* Circ functions */

 float EaseInCirc(float x);
 float EaseOutCirc(float x);
 float EaseInOutCirc(float x);

-/**
- * \brief Elastic functions
- */
+/* Elastic functions */

 float EaseInElastic(float x);
 float EaseOutElastic(float x);
 float EaseInOutElastic(float x);

-/**
- * \brief Quad functions
- */
+/* Quad functions */

 float EaseInQuad(float x);
 float EaseOutQuad(float x);
 float EaseInOutQuad(float x);

-/**
- * \brief Quart functions
- */
+/* Quart functions */

 float EaseInQuart(float x);
 float EaseOutQuart(float x);
 float EaseInOutQuart(float x);

-/**
- * \brief Expo functions
- */
+/* Expo functions */

 float EaseInExpo(float x);
 float EaseOutExpo(float x);
 float EaseInOutExpo(float x);

-/**
- * \brief Back functions
- */
+/* Back functions */

 float EaseInBack(float x);
 float EaseOutBack(float x);
 float EaseInOutBack(float x);

-/**
- * \brief Bounce functions
- */
+/* Bounce functions */

 float EaseInBounce(float x);
 float EaseOutBounce(float x);
--- a/include/blitz/misc/Format.h
+++ b/include/blitz/misc/Format.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file Format.h
- * \brief This file contains the definition of the `Format` function.
- */
-
 #include <memory>
 #include <stdexcept>
 #include <string>
@@ -12,17 +7,6 @@
 namespace blitz {
 namespace utils {

-/**
- * \brief Formats a string using a format string and variadic arguments.
- *
- * This function takes a format string and a variable number of arguments and returns a formatted string.
- * The format string can contain placeholders that will be replaced by the corresponding arguments.
- *
- * \param format The format string.
- * \param args The variadic arguments to be formatted.
- * \return The formatted string.
- * \throws std::runtime_error if an error occurs during formatting.
- */
 template <typename... Args>
 std::string Format(const std::string& format, Args... args) {
 	int size = snprintf(nullptr, 0, format.c_str(), args...) + 1;  // Extra space for '\0'
--- a/include/blitz/misc/Log.h
+++ b/include/blitz/misc/Log.h
@@ -1,32 +1,13 @@
 #pragma once

-/**
- * \file Log.h
- * \brief File defining log functions
- */
-
 #include <string>

 namespace blitz {
 namespace utils {

-/**
- * \brief Logs a normal message.
- * \param msg The message to be logged.
- */
-void LOG(const std::string& msg);
-
-/**
- * \brief Logs a normal message in debug mode.
- * \param msg The message to be logged.
- */
-void LOGD(const std::string& msg);
-
-/**
- * \brief Logs an error message.
- * \param err The error message to be logged.
- */
-void LOGE(const std::string& err);
+void LOG(const std::string& msg);	// Normal
+void LOGD(const std::string& msg);	// Normal en mode debug
+void LOGE(const std::string& err);	// Normal erreur

 }  // namespace utils
 }  // namespace blitz
--- a/include/blitz/misc/ObjectNotifier.h
+++ b/include/blitz/misc/ObjectNotifier.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file ObjectNotifier.h
- * \brief File containing the blitz::ObjectNotifier class
- */
-
 #include <algorithm>
 #include <functional>
 #include <vector>
@@ -12,26 +7,16 @@
 namespace blitz {
 namespace utils {

-/**
- * \class ObjectNotifier
- * \brief Class used to notify listeners
- */
 template <typename Listener>
 class ObjectNotifier {
  protected:
 	std::vector<Listener*> m_Listeners;

  public:
-	/**
-	 * \brief Binds a listener to notify later
-	 */
 	void BindListener(Listener* listener) {
 		m_Listeners.push_back(listener);
 	}

-	/**
-	 * \brief Unbinds a listener (in case the listener is destroyed for example)
-	 */
 	void UnbindListener(Listener* listener) {
 		auto iter = std::find(m_Listeners.begin(), m_Listeners.end(), listener);

@@ -41,11 +26,8 @@ class ObjectNotifier {
 		m_Listeners.erase(iter);
 	}

-	/**
-	 * \brief Notify listeners that were bound
-	 */
 	template <typename Func, typename... Args>
-	void NotifyListeners(Func function, Args... args) const {
+	void NotifyListeners(Func function, Args... args) {
 		for (Listener* listener : m_Listeners)
 			std::bind(function, listener, args...)();
 	}
--- a/include/blitz/misc/PrettyLog.h
+++ b/include/blitz/misc/PrettyLog.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file PrettyLog.h
- * \brief File defining log functions with colors
- */
-
 #include "blitz/maths/Vector.h"
 #include <string>

@@ -23,13 +18,7 @@ const static Vec3uc YELLOW = {255, 255, 0};

 }  // namespace TextColor

-/**
- * \brief Returns the color code for a given color.
- */
 std::string GetTextColor(Vec3uc color);
-/**
- * \brief Returns the color code for the reset color.
- */
 std::string GetTextColorReset();

 }  // namespace utils
--- a/include/blitz/misc/Random.h
+++ b/include/blitz/misc/Random.h
@@ -1,21 +1,10 @@
 #pragma once

-/**
- * \file Random.h
- * \brief Defines functions for generating random numbers.
- */
-
 #include <random>

 namespace blitz {
 namespace utils {

-/**
- * \brief Returns a random integer between min and max.
- * \param min The minimum value.
- * \param max The maximum value.
- * \return A random integer between min and max.
- */
 template <typename NumberType>
 NumberType GetRandomInt(NumberType min, NumberType max) {
 	std::random_device randomDevice;
@@ -24,12 +13,6 @@ NumberType GetRandomInt(NumberType min, NumberType max) {
 	return distrib(generator);
 }

-/**
- * \brief Returns a random real number between min and max.
- * \param min The minimum value.
- * \param max The maximum value.
- * \return A random real number between min and max.
- */
 template <typename NumberType>
 NumberType GetRandomReal(NumberType min, NumberType max) {
 	std::random_device randomDevice;
--- a/include/blitz/misc/Test.h
+++ b/include/blitz/misc/Test.h
@@ -10,16 +10,7 @@
 namespace blitz {
 namespace utils {

-/**
- * \def BLITZ_TEST_SUCCESSFUL
- * \brief Used in tests to indicate that a test was successful
- */
 #define BLITZ_TEST_SUCCESSFUL 0
-
-/**
- * \def BLITZ_TEST_FAILED
- * \brief Used in tests to indicate that a test failed
- */
 #define BLITZ_TEST_FAILED 1

 #ifndef __FUNCTION_NAME__
@@ -33,8 +24,7 @@ namespace utils {
 /**
 * \def blitz_test_assert
 * \param ... The expression to evaluate
- * \brief Evaluates the expression and exits the program if not valid.
- * \note It works like a basic assert() but also in release mode
+ * \brief Evaluates the expression and exits the program if not valid
 */
 #define blitz_test_assert(...)                                                                                                        \
 	if (!static_cast<bool>(__VA_ARGS__)) {                                                                                            \
@@ -47,7 +37,6 @@ namespace utils {
 * \def blitz_debug_assert
 * \param ... The expression to execute
 * \brief Assertion without checks in release mode
- * \note The expression is always executed. However, in release, no checks are made !
 */
 #ifdef NDEBUG
 #define blitz_debug_assert(...) __VA_ARGS__
--- a/include/blitz/misc/TickCounter.h
+++ b/include/blitz/misc/TickCounter.h
@@ -1,19 +1,10 @@
 #pragma once

-/**
- * \file TickCounter.h
- * \brief File containing the blitz::utils::TickCounter class
- */
-
 #include <cstdint>

 namespace blitz {
 namespace utils {

-/**
- * \class TickCounter
- * \brief Class used to count ticks
- */
 class TickCounter {
  private:
 	float m_TPS;
@@ -23,42 +14,19 @@ class TickCounter {
 	int m_TargetTPS;

  public:
-	/**
-	 * \brief Constructor
-	 * \param tps The target ticks per second
-	 */
 	TickCounter(int tps) : m_TargetTPS(tps) {}

-	/**
-	 * \brief Reset the tick counter
-	 */
 	void Reset();
-	/**
-	 * \brief Update the tick counter
-	 * \return True if the tick counter has been updated
-	 */
-	bool Update();
+	bool Update();	// return true when tps is updated

-	/**
-	 * \brief Get the ticks per second
-	 * \return The ticks per second
-	 */
 	float GetTPS() const {
 		return m_TPS;
 	}

-	/**
-	 * \brief Get the milliseconds per tick
-	 * \return The milliseconds per tick
-	 */
 	float GetMSPT() const {
 		return m_MSPT;
 	}

-	/**
-	 * \brief Set the ticks per second
-	 * \param mspt The ticks per second
-	 */
 	void SetMSPT(float mspt) {
 		m_MSPT = mspt;
 	}
--- a/include/blitz/misc/Time.h
+++ b/include/blitz/misc/Time.h
@@ -1,30 +1,16 @@
 #pragma once

-/**
- * \file Time.h
- * \brief File containing the blitz::utils::AutoTimer, blitz::utils::Timer, blitz::utils::CooldownTimer and blitz::utils::DelayTimer
- * classes
- */
-
-#include <algorithm>
 #include <cstdint>
 #include <functional>

 namespace blitz {
 namespace utils {

-/**
- * \brief Get current time
- * \return Time elapsed since epoch in milliseconds
- */
 std::uint64_t GetTime();

 typedef std::function<void()> TimerExecFunction;

-/**
- * \class AutoTimer
- * \brief Calls a function at regular period of time
- */
+// utililty class to call a function at regular period of time
 class AutoTimer {
  private:
 	std::uint64_t m_Interval;
@@ -34,136 +20,56 @@ class AutoTimer {
 	std::uint64_t m_InternalTime = 0;

  public:
-	/**
-	 * \brief Default constructor
-	 */
 	AutoTimer() : m_Interval(0), m_Function(nullptr) {}
-
-	/**
-	 * \param interval Time between each function call in milliseconds
-	 */
 	AutoTimer(std::uint64_t interval) : m_Interval(interval), m_Function(nullptr) {}
-
-	/**
-	 * \param interval Time between each function call in milliseconds
-	 * \param callback The function to call peridocally
-	 */
 	AutoTimer(std::uint64_t interval, TimerExecFunction callback) : m_Interval(interval), m_Function(callback) {}

-	/**
-	 * \brief Updates the timer
-	 */
 	void Update();
-
-	/**
-	 * \brief Updates the timer with the desired time step
-	 * \param delta The time step in milliseconds
-	 */
 	void Update(std::uint64_t delta);

-	/**
-	 * \brief Resets the internal cooldown
-	 */
 	void Reset();

-	/**
-	 * \brief Sets a new interval
-	 * \param newInterval the new interval in milliseconds
-	 */
 	void SetInterval(std::uint64_t newInterval) {
 		m_Interval = newInterval;
 	}

-	/**
-	 * \return The interval between each callback in milliseconds
-	 */
 	std::uint64_t GetInterval() const {
 		return m_Interval;
 	}

-	/**
-	 * \brief Set a new callback function
-	 * \param newCallback The function to call
-	 */
 	void SetCallbackFunction(TimerExecFunction newCallback) {
 		m_Function = newCallback;
 	}

-	/**
-	 * \return The callback function
-	 */
 	TimerExecFunction GetCallbackFunction() const {
 		return m_Function;
 	}
 };

-/**
- * \class Timer
- * \brief Utililty class to trigger update at regular period of time
- */
+// utililty class to trigger update at regular period of time
 class Timer {
  private:
 	std::uint64_t m_Interval;  // in millis
 	std::uint64_t m_InternalTime = 0;

  public:
-	/**
-	 * \brief Default constructor
-	 */
 	Timer() : m_Interval(0) {}
-
-	/**
-	 * \brief Construct a Timer with the desired interval
-	 * \param interval The interval between each update in milliseconds
-	 */
 	Timer(std::uint64_t interval) : m_Interval(interval) {}

-	/**
-	 * \brief Updates the timer
-	 * \param delta The time step in milliseconds
-	 * \return true every interval milliseconds
-	 */
 	bool Update(std::uint64_t delta);

-	/**
-	 * \brief Resets the timer to its original state
-	 */
 	void Reset();

-	/**
-	 * \return The time remaing before the next Update() call will return true (in milliseconds)
-	 */
-	std::uint64_t GetTimeRemaining() const {
-		return m_Interval - m_InternalTime;
-	}
-
-	/**
-	 * \return The time elapsed since the previous Update() call returned true (in milliseconds)
-	 */
-	std::uint64_t GetTimeElapsed() const {
-		return m_InternalTime;
-	}
-
-	/**
-	 * \brief Set a new value for the interval
-	 * \param newInterval the new interval to set
-	 */
 	void SetInterval(std::uint64_t newInterval) {
 		m_Interval = newInterval;
 	}

-	/**
-	 * \return The interval between each successful Update()
-	 */
 	std::uint64_t GetInterval() const {
 		return m_Interval;
 	}
 };

-/**
- * \class CooldownTimer
- * \brief Class to trigger update at regular period of time with a cooldown
- */
+// utililty class to trigger update at regular period of time with a cooldown
 template <typename T>
 class CooldownTimer {
  private:
@@ -171,20 +77,9 @@ class CooldownTimer {
 	T m_CooldownTime;

  public:
-	/**
-	 * \brief Default constructor
-	 */
 	CooldownTimer() : m_Cooldown(0), m_CooldownTime(0) {}
-
-	/**
-	 * \param cooldown The cooldown before Update() returns true again
-	 */
 	CooldownTimer(T cooldown) : m_Cooldown(0), m_CooldownTime(cooldown) {}

-	/**
-	 * \brief Update the timer
-	 * \param delta the time step
-	 */
 	bool Update(T delta) {
 		if (m_Cooldown > 0) {
 			m_Cooldown = std::max<T>(static_cast<T>(0), static_cast<T>(m_Cooldown - delta));
@@ -192,87 +87,22 @@ class CooldownTimer {
 		return m_Cooldown == 0;
 	}

-	/**
-	 * \brief Apply a cooldown for the timer
-	 */
 	void ApplyCooldown() {
 		m_Cooldown = m_CooldownTime;
 	}

-	/**
-	 * \brief Reset the cooldown. Update() will return true immediatly afterward.
-	 */
 	void Reset() {
 		m_Cooldown = 0;
 	}

-	/**
-	 * \brief Change the timer cooldown
-	 * \param newCooldown the new cooldown
-	 */
 	void SetCooldown(T newCooldown) {
 		m_CooldownTime = newCooldown;
 	}

-	/**
-	 * \return The cooldown of the timer
-	 */
 	T GetCooldown() const {
 		return m_CooldownTime;
 	}
 };

-/**
- * \class DelayTimer
- * \brief class to trigger an update after a period of time
- */
-template <typename T>
-class DelayTimer {
-  private:
-	T m_DelayTime;
-	T m_InternalTime;
-
-  public:
-	/**
-	 * \brief Default constructor
-	 */
-	DelayTimer() : m_DelayTime(0), m_InternalTime(0) {}
-
-	/**
-	 * \param delay The delay to set
-	 */
-	DelayTimer(T delay) : m_DelayTime(delay), m_InternalTime(delay) {}
-
-	/**
-	 * \brief Returns true whether the delay has been passed.
-	 */
-	bool Update(T delta) {
-		m_InternalTime = std::max<T>(static_cast<T>(0), static_cast<T>(m_InternalTime - delta));
-		return m_InternalTime == 0;
-	}
-
-	/**
-	 * \brief Resets the timer. Update() will immediatly return true
-	 */
-	void Reset() {
-		m_InternalTime = m_DelayTime;
-	}
-
-	/**
-	 * \brief Changes the delay of the timer
-	 * \param newDelay the new delay
-	 */
-	void SetDelay(T newDelay) {
-		m_DelayTime = newDelay;
-	}
-
-	/**
-	 * \return the delay of the timer
-	 */
-	T GetDelay() const {
-		return m_DelayTime;
-	}
-};
-
 }  // namespace utils
 }  // namespace blitz
--- a/include/blitz/network/Connexion.h
+++ b/include/blitz/network/Connexion.h
@@ -41,28 +41,28 @@ class Connexion : public protocol::PacketHandler, private NonCopyable {

 	/**
 	 * \brief Default destructor
-	 */
+	*/
 	virtual ~Connexion();

 	/**
-	 * \brief Reads socket and process a Packet, if any
-	 */
+	 * \brief Reads socket and process a Packet, if any 
+	*/
 	virtual bool UpdateSocket();
-
+	
 	/**
 	 * \brief Closes the connexion
-	 */
+	*/
 	void CloseConnection();

 	/**
 	 * \brief Tries to connect the socket at the specified address and port
-	 * \return Whether this action was succesfull
-	 */
-	bool Connect(const std::string& address, std::uint16_t port);
+	 * \return Wether this action was succesfull
+	*/
+	virtual bool Connect(const std::string& address, std::uint16_t port);

 	/**
 	 * \brief Returns the TCPSocket::Status of the internal socket
-	 */
+	*/
 	TCPSocket::Status GetSocketStatus() const {
 		return m_Socket.GetStatus();
 	}
@@ -70,7 +70,7 @@ class Connexion : public protocol::PacketHandler, private NonCopyable {
 	/**
 	 * \brief Sends the protocol::Packet over the network to the remote
 	 * \param packet The protocol::Packet to send
-	 */
+	*/
 	void SendPacket(const protocol::Packet* packet);
 };

--- a/include/blitz/network/TCPListener.h
+++ b/include/blitz/network/TCPListener.h
@@ -35,7 +35,7 @@ class TCPListener : private NonCopyable {
 	 * \param port The port to listen to
 	 * \param maxConnexions The maximum amount of connexion that can happen at the same time. \n
 	 * Every other guests will be kicked if this amount is reached.
-	 * \return Whether this action was succesfull
+	 * \return Wether this action was succesfull
 	 */
 	bool Listen(std::uint16_t port, int maxConnexions);

--- a/include/blitz/protocol/PacketDispatcher.h
+++ b/include/blitz/protocol/PacketDispatcher.h
@@ -1,11 +1,5 @@
 #pragma once

-/**
- * \file PacketDispatcher.h
- * \brief File containing the blitz::protocol::PacketDispatcher class
- */
-
-#include "blitz/common/NonCopyable.h"
 #include "blitz/protocol/Protocol.h"

 #include <map>
@@ -15,42 +9,22 @@ namespace protocol {

 class PacketHandler;

-/**
- * \class PacketDispatcher
- * \brief Class used to dispatch packets
- */
-class PacketDispatcher : private NonCopyable {
+class PacketDispatcher {
  private:
 	std::map<PacketType, std::vector<PacketHandler*>> m_Handlers;

  public:
-	/**
-	 * \brief Constructor
-	 */
-	PacketDispatcher() {}
+	PacketDispatcher() = default;
+
+	PacketDispatcher(const PacketDispatcher& rhs) = delete;
+	PacketDispatcher& operator=(const PacketDispatcher& rhs) = delete;
+	PacketDispatcher(PacketDispatcher&& rhs) = delete;
+	PacketDispatcher& operator=(PacketDispatcher&& rhs) = delete;

-	/**
-	 * \brief Dispatch a packet
-	 * \param packet The packet to dispatch
-	 */
 	void Dispatch(const Packet* packet);

-	/**
-	 * \brief Register a packet handler
-	 * \param type The packet type
-	 * \param handler The packet handler
-	 */
 	void RegisterHandler(PacketType type, PacketHandler* handler);
-	/**
-	 * \brief Unregister a packet handler
-	 * \param type The packet type
-	 * \param handler The packet handler
-	 */
 	void UnregisterHandler(PacketType type, PacketHandler* handler);
-	/**
-	 * \brief Unregister a packet handler
-	 * \param handler The packet handler
-	 */
 	void UnregisterHandler(PacketHandler* handler);
 };

--- a/include/blitz/protocol/PacketFactory.h
+++ b/include/blitz/protocol/PacketFactory.h
@@ -1,22 +1,13 @@
 #pragma once

-/**
- * \file PacketFactory.h
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {
 namespace PacketFactory {

-/**
- * \brief Creates a packet from a buffer.
- * \param buffer The buffer containing the packet data.
- * \return The created packet.
- */
 const Packet* CreatePacket(PacketType type, DataBuffer& buffer);

-}  // namespace PacketFactory
+}
 }  // namespace protocol
 }  // namespace blitz
--- a/include/blitz/protocol/PacketHandler.h
+++ b/include/blitz/protocol/PacketHandler.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file PacketHandler.h
- * \brief File containing the blitz::protocol::PacketHandler class
- */
-
 #include "blitz/protocol/PacketsForward.h"
 #include "blitz/protocol/Protocol.h"

@@ -13,26 +8,14 @@ namespace protocol {

 class PacketDispatcher;

-/**
- * \class PacketHandler
- * \brief Class used to handle packets
- */
 class PacketHandler {
  private:
 	PacketDispatcher* m_Dispatcher;

  public:
-	/**
-	 * \brief Constructor
-	 * \param dispatcher The packet dispatcher
-	 */
 	PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher) {}
 	virtual ~PacketHandler() {}

-	/**
-	 * \brief Get the packet dispatcher
-	 * \return The packet dispatcher
-	 */
 	PacketDispatcher* GetDispatcher() {
 		return m_Dispatcher;
 	}
@@ -48,9 +31,7 @@ class PacketHandler {
 	virtual void HandlePacket(const PlayerPositionAndRotationPacket* packet) {}
 	virtual void HandlePacket(const PlayerShootPacket* packet) {}
 	virtual void HandlePacket(const PlayerStatsPacket* packet) {}
-	virtual void HandlePacket(const ServerConfigPacket* packet) {}
 	virtual void HandlePacket(const ServerTpsPacket* packet) {}
-	virtual void HandlePacket(const UpdateGameStatePacket* packet) {}
 	virtual void HandlePacket(const UpdateHealthPacket* packet) {}
 };

--- a/include/blitz/protocol/Packets.h
+++ b/include/blitz/protocol/Packets.h
@@ -9,7 +9,5 @@
 #include "packets/PlayerPositionAndRotationPacket.h"
 #include "packets/PlayerShootPacket.h"
 #include "packets/PlayerStatsPacket.h"
-#include "packets/ServerConfigPacket.h"
 #include "packets/ServerTpsPacket.h"
-#include "packets/UpdateGameStatePacket.h"
 #include "packets/UpdateHealthPacket.h"
--- a/include/blitz/protocol/PacketsForward.h
+++ b/include/blitz/protocol/PacketsForward.h
@@ -14,9 +14,7 @@ class PlayerLoginPacket;
 class PlayerPositionAndRotationPacket;
 class PlayerShootPacket;
 class PlayerStatsPacket;
-class ServerConfigPacket;
 class ServerTpsPacket;
-class UpdateGameStatePacket;
 class UpdateHealthPacket;

 }  // namespace protocol
--- a/include/blitz/protocol/Protocol.h
+++ b/include/blitz/protocol/Protocol.h
@@ -2,7 +2,7 @@

 /**
 * \file Protocol.h
- * \brief File containing the blitz::protocol::Protocol class
+ * \brief File describing protocol
 */

 #include "blitz/common/DataBuffer.h"
@@ -24,14 +24,12 @@ enum class PacketType : std::uint8_t {

 	// client <-- server

-	ConnexionInfo,	 /**< Corresponds to ConnexionInfoPacket */
-	PlayerJoin,		 /**< Corresponds to PlayerJoinPacket */
-	PlayerLeave,	 /**< Corresponds to PlayerLeavePacket */
-	PlayerList,		 /**< Corresponds to PlayerListPacket */
-	PlayerStats,	 /**< Corresponds to PlayerStatsPacket */
-	ServerConfig,	 /**< Corresponds to ServerConfigPacket*/
-	ServerTps,		 /**< Corresponds to ServerTpsPacket */
-	UpdateGameState, /**< Corresponds to UpdateGameStatePacket */
+	ConnexionInfo, /**< Corresponds to ConnexionInfoPacket */
+	PlayerJoin,	   /**< Corresponds to PlayerJoinPacket */
+	PlayerLeave,   /**< Corresponds to PlayerLeavePacket */
+	PlayerList,	   /**< Corresponds to PlayerListPacket */
+	PlayerStats,   /**< Corresponds to PlayerStatsPacket */
+	ServerTps,	   /**< Corresponds to ServerTpsPacket */

 	// client <--> server

--- a/include/blitz/protocol/packets/ChatPacket.h
+++ b/include/blitz/protocol/packets/ChatPacket.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file ChatPacket.h
- * \brief File containing the blitz::protocol::ChatPacket class
- */
-
 #include "blitz/maths/Vector.h"
 #include "blitz/protocol/Protocol.h"
 #include <vector>
@@ -12,53 +7,20 @@
 namespace blitz {
 namespace protocol {

-/**
- * \struct ColoredPart
- * \brief Represents a part of a chat message with a specific color.
- */
 struct ColoredPart {
-	/**
-	 * \brief The color of the part.
-	 */
 	Vec4f color;
-	/**
-	 * \brief The text of the part.
-	 */
 	std::string text;
 };

 typedef std::vector<ColoredPart> ColoredText;

-/**
- * \class ChatPacket
- * \brief Packet for sending chat messages.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::Chat	|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	m_Message		|    ColoredText  	|  The message sent in the chat	|
- */
 class ChatPacket : public Packet {
  private:
 	ColoredText m_Message;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	ChatPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param msg The message to send.
-	 */
 	ChatPacket(const std::string& msg) : m_Message(ColorizeText(msg)) {}
-	/**
-	 * \brief Constructor.
-	 * \param msg The message to send.
-	 */
 	ChatPacket(const ColoredText& msg) : m_Message(msg) {}
 	virtual ~ChatPacket() {}

@@ -66,10 +28,6 @@ class ChatPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the message.
-	 * \return The message.
-	 */
 	const ColoredText& GetMessage() const {
 		return m_Message;
 	}
@@ -78,17 +36,8 @@ class ChatPacket : public Packet {
 		return PacketType::Chat;
 	}

-	/**
-	 * \brief Get the text color.
-	 */
 	static std::string GetTextColor(Vec3uc color);
-	/**
-	 * \brief Colorize a text.
-	 */
 	static ColoredText ColorizeText(const std::string& text);
-	/**
-	 * \brief Get the colored text string.
-	 */
 	static std::string GetColoredTextString(const ColoredText& text);
 };

--- a/include/blitz/protocol/packets/ConnexionInfoPacket.h
+++ b/include/blitz/protocol/packets/ConnexionInfoPacket.h
@@ -1,40 +1,16 @@
 #pragma once

-/**
- * \file ConnexionInfoPacket.h
- * \brief File containing the blitz::protocol::ConnexionInfoPacket class
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class ConnexionInfoPacket
- * \brief Packet for sending connection information.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::ConnexionInfo	|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	m_ConnectionID	|    std::uint8_t  	|     The connection ID			|
- */
 class ConnexionInfoPacket : public Packet {
  private:
 	std::uint8_t m_ConnectionID;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	ConnexionInfoPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param connectionID The ID of the connection.
-	 */
 	ConnexionInfoPacket(std::uint8_t connectionID) : m_ConnectionID(connectionID) {}
 	virtual ~ConnexionInfoPacket() {}

@@ -42,10 +18,6 @@ class ConnexionInfoPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the connection ID.
-	 * \return The connection ID.
-	 */
 	std::uint8_t GetConnectionID() const {
 		return m_ConnectionID;
 	}
--- a/include/blitz/protocol/packets/DisconnectPacket.h
+++ b/include/blitz/protocol/packets/DisconnectPacket.h
@@ -1,39 +1,15 @@
 #pragma once

-/**
- * \file DisconnectPacket.h
- * \brief File containing the blitz::protocol::DisconnectPacket class
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class DisconnectPacket
- * \brief Packet for disconnecting from the server.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::Disconnect	|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	m_Reason		|    std::string  	|  The reason for disconnection	|
- */
 class DisconnectPacket : public Packet {
  private:
 	std::string m_Reason;  // only when sent from server
  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	DisconnectPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param reason The reason for disconnection.
-	 */
 	DisconnectPacket(std::string reason) : m_Reason(reason) {}
 	virtual ~DisconnectPacket() {}

@@ -41,10 +17,6 @@ class DisconnectPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the reason for disconnection.
-	 * \return The reason for disconnection.
-	 */
 	const std::string& GetReason() const {
 		return m_Reason;
 	}
--- a/include/blitz/protocol/packets/KeepAlivePacket.h
+++ b/include/blitz/protocol/packets/KeepAlivePacket.h
@@ -13,14 +13,14 @@ namespace protocol {

 /**
 * \class KeepAlivePacket
- * \brief Packet sent to measure the health of a connexion. \n
+ * \brief %Packet sent to measure the health of a connexion. \n
 * The client must respond with the same alive ID. Else, the connexion will be closed. \n
- * %Packet structure :
+ * %Packet structure : 
 * |      PacketType 		|
 * |------------------------|
 * |  PacketType::KeepAlive	|
- *
- * |	 Field Name 	|  Field Type	|  			  						Notes 									|
+ * 
+ * |	 Field Name 	|  Field Type	|  			  						Notes 									|	
 * |--------------------|---------------|---------------------------------------------------------------------------|
 * |	Keep Alive ID	|    VarInt 	| The server generates a random ID, the client must respond with the same	|
 *
--- a/include/blitz/protocol/packets/PlayerJoinPacket.h
+++ b/include/blitz/protocol/packets/PlayerJoinPacket.h
@@ -13,7 +13,7 @@ namespace protocol {

 /**
 * \class PlayerJoinPacket
- * \brief Packet sent when a new player joins the game
+ * \brief %Packet sent when a new player joins the game \n
 * %Packet structure :
 * |      PacketType 		|
 * |------------------------|
--- a/include/blitz/protocol/packets/PlayerLeavePacket.h
+++ b/include/blitz/protocol/packets/PlayerLeavePacket.h
@@ -1,53 +1,24 @@
 #pragma once

-/**
- * \file PlayerLeavePacket.h
- * \brief File containing the blitz::protocol::PlayerLeavePacket class
- */
-
-#include "blitz/common/Defines.h"
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class PlayerLeavePacket
- * \brief Packet for when a player leaves the game.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::PlayerLeave|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	m_PlayerID		|     PlayerID		|The ID of the player that left |
- */
 class PlayerLeavePacket : public Packet {
  private:
-	game::PlayerID m_PlayerID;
+	std::uint8_t m_PlayerID;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerLeavePacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param playerID The ID of the player that left.
-	 */
-	PlayerLeavePacket(game::PlayerID playerID) : m_PlayerID(playerID) {}
+	PlayerLeavePacket(std::uint8_t playerID) : m_PlayerID(playerID) {}
 	virtual ~PlayerLeavePacket() {}

 	virtual DataBuffer Serialize(bool packetID = true) const;
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the ID of the player that left.
-	 * \return The ID of the player that left.
-	 */
-	game::PlayerID GetPlayerID() const {
+	std::uint8_t GetPlayerID() const {
 		return m_PlayerID;
 	}

--- a/include/blitz/protocol/packets/PlayerListPacket.h
+++ b/include/blitz/protocol/packets/PlayerListPacket.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file PlayerListPacket.h
- * \brief File containing the blitz::protocol::PlayerListPacket class
- */
-
 #include <map>

 #include "blitz/protocol/Protocol.h"
@@ -12,34 +7,18 @@
 namespace blitz {
 namespace protocol {

-/**
- * \struct PlayerInfo
- * \brief Represents information about a player.
- */
 struct PlayerInfo {
 	std::string name;
 };

 typedef std::map<std::uint8_t, PlayerInfo> PlayerList;

-/**
- * \class PlayerListPacket
- * \brief Packet for sending the list of players.
- * \todo PACKET STRUCTURE
- */
 class PlayerListPacket : public Packet {
  private:
 	PlayerList m_Players;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerListPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param players The list of players.
-	 */
 	PlayerListPacket(const PlayerList& players) : m_Players(players) {}
 	virtual ~PlayerListPacket() {}

@@ -47,11 +26,6 @@ class PlayerListPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-
-	/**
-	 * \brief Get the list of players.
-	 * \return The list of players.
-	 */
 	const PlayerList& GetPlayers() const {
 		return m_Players;
 	}
--- a/include/blitz/protocol/packets/PlayerLoginPacket.h
+++ b/include/blitz/protocol/packets/PlayerLoginPacket.h
@@ -1,40 +1,16 @@
 #pragma once

-/**
- * \file PlayerLoginPacket.h
- * \brief File containing the blitz::protocol::PlayerLoginPacket class
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class PlayerLoginPacket
- * \brief Packet for when a player logs in.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::PlayerLogin|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			   |
- * |--------------------|-------------------|----------------------------------|
- * |	Player Name		|   std::string 	| Name of the player that logged in|
- */
 class PlayerLoginPacket : public Packet {
  private:
 	std::string m_PlayerName;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerLoginPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param playerName The name of the player that logged in.
-	 */
 	PlayerLoginPacket(std::string playerName) : m_PlayerName(playerName) {}
 	virtual ~PlayerLoginPacket() {}

@@ -42,17 +18,13 @@ class PlayerLoginPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the name of the player that logged in.
-	 * \return The name of the player that logged in.
-	 */
-	const std::string& GetPlayerName() const {
-		return m_PlayerName;
-	}
-
 	virtual PacketType GetType() const {
 		return PacketType::PlayerLogin;
 	}
+
+	const std::string& GetPlayerName() const {
+		return m_PlayerName;
+	}
 };

 }  // namespace protocol
--- a/include/blitz/protocol/packets/PlayerPositionAndRotationPacket.h
+++ b/include/blitz/protocol/packets/PlayerPositionAndRotationPacket.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file PlayerPositionAndRotationPacket.h
- * \brief File containing the blitz::protocol::PlayerPositionAndRotationPacket class
- */
-
 #include "blitz/common/Defines.h"
 #include "blitz/maths/Vector.h"
 #include "blitz/protocol/Protocol.h"
@@ -12,21 +7,6 @@
 namespace blitz {
 namespace protocol {

-/**
- * \class PlayerPositionAndRotationPacket
- * \brief Packet for sending a player's position and rotation.
- * %Packet structure :
- * |      PacketType 				|
- * |--------------------------------|
- * | PacketType::PlayerPositionAndRotation	|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			   |
- * |--------------------|-------------------|----------------------------------|
- * |	Player ID		|     PlayerID  	|  	Id of the player who moved	   |
- * |	Position		|   Vec3f 			|     Position of the player	   |
- * |	Yaw				|    float			|       Yaw of the player		   |
- * |	Pitch			|    float			|      Pitch of the player		   |
- */
 class PlayerPositionAndRotationPacket : public Packet {
  private:
 	game::PlayerID m_Player;  // only used when sent to client
@@ -34,53 +14,28 @@ class PlayerPositionAndRotationPacket : public Packet {
 	float m_Yaw, m_Pitch;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerPositionAndRotationPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param position The position of the player.
-	 * \param yaw The yaw of the player.
-	 * \param pitch The pitch of the player.
-	 * \param player The ID of the player.
-	 */
 	PlayerPositionAndRotationPacket(const Vec3f& position, float yaw, float pitch, game::PlayerID player = 0) :
 		m_Player(player), m_Position(position), m_Yaw(yaw), m_Pitch(pitch) {}
+
 	virtual ~PlayerPositionAndRotationPacket() {}

 	virtual DataBuffer Serialize(bool packetID = true) const;
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the position of the player.
-	 * \return The position of the player.
-	 */
 	const Vec3f& GetPosition() const {
 		return m_Position;
 	}

-	/**
-	 * \brief Get the yaw of the player.
-	 * \return The yaw of the player.
-	 */
 	float GetYaw() const {
 		return m_Yaw;
 	}

-	/**
-	 * \brief Get the pitch of the player.
-	 * \return The pitch of the player.
-	 */
 	float GetPitch() const {
 		return m_Pitch;
 	}

-	/**
-	 * \brief Get the ID of the player.
-	 * \return The ID of the player.
-	 */
 	game::PlayerID GetPlayer() const {
 		return m_Player;
 	}
--- a/include/blitz/protocol/packets/PlayerShootPacket.h
+++ b/include/blitz/protocol/packets/PlayerShootPacket.h
@@ -1,31 +1,11 @@
 #pragma once

-/**
- * \file PlayerShootPacket.h
- * \brief File containing the blitz::protocol::PlayerShootPacket class
- */
-
 #include "blitz/game/Player.h"
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class PlayerShootPacket
- * \brief Packet for when a player shoots.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::PlayerShoot|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			   |
- * |--------------------|-------------------|----------------------------------|
- * |	Player ID		|     PlayerID	    |  The ID of the player that shot  |
- * |	Position		|   Vec3f 			|     Position of the player	   |
- * |	Yaw				|    float			|       Yaw of the player		   |
- * |	Pitch			|    float			|      Pitch of the player		   |
- */
 class PlayerShootPacket : public Packet {
  private:
 	game::PlayerID m_Player;  // only used when sent to client
@@ -33,17 +13,7 @@ class PlayerShootPacket : public Packet {
 	float m_Yaw, m_Pitch;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerShootPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param position The position of the player.
-	 * \param yaw The yaw of the player.
-	 * \param pitch The pitch of the player.
-	 * \param player The ID of the player.
-	 */
 	PlayerShootPacket(Vec3f position, float yaw, float pitch, game::PlayerID player = 0) :
 		m_Player(player), m_Position(position), m_Yaw(yaw), m_Pitch(pitch) {}
 	virtual ~PlayerShootPacket() {}
@@ -52,34 +22,18 @@ class PlayerShootPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the position of the player.
-	 * \return The position of the player.
-	 */
 	const Vec3f& GetPosition() const {
 		return m_Position;
 	}

-	/**
-	 * \brief Get the yaw of the player.
-	 * \return The yaw of the player.
-	 */
 	float GetYaw() const {
 		return m_Yaw;
 	}

-	/**
-	 * \brief Get the pitch of the player.
-	 * \return The pitch of the player.
-	 */
 	float GetPitch() const {
 		return m_Pitch;
 	}

-	/**
-	 * \brief Get the ID of the player.
-	 * \return The ID of the player.
-	 */
 	game::PlayerID GetPlayer() const {
 		return m_Player;
 	}
--- a/include/blitz/protocol/packets/PlayerStatsPacket.h
+++ b/include/blitz/protocol/packets/PlayerStatsPacket.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file PlayerStatsPacket.h
- * \brief File containing the blitz::protocol::PlayerStatsPacket class
- */
-
 #include "blitz/common/Defines.h"
 #include "blitz/game/Player.h"
 #include "blitz/protocol/Protocol.h"
@@ -12,34 +7,13 @@
 namespace blitz {
 namespace protocol {

-/**
- * \class PlayerStatsPacket
- * \brief Packet for sending player stats.
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::PlayerStats|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	Player ID		|  	  PlayerID	    |  		Id of the player		|
- * |	Player Stats	|    PlayerStats    | 		Stats of the player		|
- */
 class PlayerStatsPacket : public Packet {
  private:
 	game::PlayerID m_PlayerID;
 	game::PlayerStats m_PlayerStats;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	PlayerStatsPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param playerID The ID of the player.
-	 * \param stats The stats of the player.
-	 */
 	PlayerStatsPacket(game::PlayerID playerID, const game::PlayerStats& stats) : m_PlayerID(playerID), m_PlayerStats(stats) {}
 	virtual ~PlayerStatsPacket() {}

--- a/include/blitz/protocol/packets/ServerConfigPacket.h
+++ b/include/blitz/protocol/packets/ServerConfigPacket.h
@@ -1,60 +0,0 @@
-#pragma once
-
-/**
- * \file ServerConfigPacket.h
- * \brief File containing the blitz::protocol::ServerConfigPacket class
- */
-
-#include "blitz/game/Game.h"
-#include "blitz/protocol/Protocol.h"
-
-namespace blitz {
-namespace protocol {
-
-/**
- * \class ServerConfigPacket
- * \brief Packet for sending the server configuration.
- * %Packet structure :
- * |      PacketType 		 |
- * |-------------------------|
- * | PacketType::ServerConfig|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	Game Config		|    GameConfig		|    The game configuration		|
- */
-class ServerConfigPacket : public Packet {
-  private:
-	game::GameConfig m_GameConfig;
-
-  public:
-	/**
-	 * \brief Default constructor.
-	 */
-	ServerConfigPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param GameConfig The game configuration.
-	 */
-	ServerConfigPacket(const game::GameConfig& GameConfig) : m_GameConfig(GameConfig) {}
-	virtual ~ServerConfigPacket() {}
-
-	virtual DataBuffer Serialize(bool packetID = true) const;
-	virtual void Deserialize(DataBuffer& data);
-	virtual void Dispatch(PacketHandler* handler) const;
-
-	/**
-	 * \brief Getter of the game configuration
-	 * \return The game configuration
-	 */
-	game::GameConfig GetGameConfig() const {
-		return m_GameConfig;
-	}
-
-	virtual PacketType GetType() const {
-		return PacketType::ServerConfig;
-	}
-};
-
-}  // namespace protocol
-}  // namespace blitz
--- a/include/blitz/protocol/packets/ServerTpsPacket.h
+++ b/include/blitz/protocol/packets/ServerTpsPacket.h
@@ -1,45 +1,17 @@
 #pragma once

-/**
- * \file ServerTpsPacket.h
- * \brief File containing the blitz::protocol::ServerTpsPacket class
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class ServerTpsPacket
- * \brief Packet for sending server TPS (Tick per second) and MSPT (Milliseconds per tick).
- * %Packet structure :
- * |      PacketType 		|
- * |------------------------|
- * | PacketType::ServerTps	|
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |		Tps			|  		float		|  Server TPS					|
- * |		Mspt		|  		float		|  Server MSPT					|
- * | 	PacketSendTime  |     uint64_t		|  Time the packet was sent		|
- */
 class ServerTpsPacket : public Packet {
  private:
 	float m_TPS;
 	float m_MSPT;
 	std::uint64_t m_PacketSendTime;	 // used to calculate ping
  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	ServerTpsPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param tps The server TPS.
-	 * \param mspt The server MSPT.
-	 * \param sendTime The time the packet was sent.
-	 */
 	ServerTpsPacket(float tps, float mspt, std::uint64_t sendTime) : m_TPS(tps), m_MSPT(mspt), m_PacketSendTime(sendTime) {}
 	virtual ~ServerTpsPacket() {}

@@ -47,27 +19,14 @@ class ServerTpsPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the server TPS.
-	 * \return The server TPS.
-	 */
 	float GetTPS() const {
 		return m_TPS;
 	}

-	/**
-	 * \brief Get the server MSPT.
-	 * \return The server MSPT.
-	 */
 	float GetMSPT() const {
 		return m_MSPT;
 	}

-	/**
-	 * \brief Get the time the packet was sent.
-	 * \return The time the packet was sent.
-	 * \todo Calculate ping.
-	 */
 	std::uint64_t GetPacketSendTime() const {
 		return m_PacketSendTime;
 	}
--- a/include/blitz/protocol/packets/UpdateGameStatePacket.h
+++ b/include/blitz/protocol/packets/UpdateGameStatePacket.h
@@ -1,72 +0,0 @@
-#pragma once
-
-/**
- * \file UpdateGameStatePacket.h
- * \brief File containing the blitz::protocol::UpdateGameStatePacket class
- */
-
-#include "blitz/game/Game.h"
-#include "blitz/protocol/Protocol.h"
-
-namespace blitz {
-namespace protocol {
-
-/**
- * \class UpdateGameStatePacket
- * \brief Packet for updating the game state.
- * %Packet structure :
- * |      PacketType 		     |
- * |-----------------------------|
- * | PacketType::UpdateGameState |
- *
- * |	 Field Name 	|  	 Field Type		|  			          Notes 	               |
- * |--------------------|-------------------|----------------------------------------------|
- * |	Game State		|    GameState		|             The new game state               |
- * |	Time Remaining	|    std::uint64_t	| The time remaining in the current game state |
- */
-class UpdateGameStatePacket : public Packet {
-  private:
-	game::GameState m_GameState;
-	std::uint64_t m_TimeRemaining;
-
-  public:
-	/**
-	 * \brief Default constructor.
-	 */
-	UpdateGameStatePacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param a_GameState The new game state.
-	 * \param a_TimeRemaining The time remaining in the current game state.
-	 */
-	UpdateGameStatePacket(game::GameState a_GameState, std::uint64_t a_TimeRemaining = 0) :
-		m_GameState(a_GameState), m_TimeRemaining(a_TimeRemaining) {}
-	virtual ~UpdateGameStatePacket() {}
-
-	virtual DataBuffer Serialize(bool packetID = true) const;
-	virtual void Deserialize(DataBuffer& data);
-	virtual void Dispatch(PacketHandler* handler) const;
-
-	/**
-	 * \brief Get the new game state.
-	 * \return The new game state.
-	 */
-	game::GameState GetGameState() const {
-		return m_GameState;
-	}
-
-	/**
-	 * \brief Get the time remaining in the current game state.
-	 * \return The time remaining in the current game state.
-	 */
-	std::uint64_t GetTimeRemaining() const {
-		return m_TimeRemaining;
-	}
-
-	virtual PacketType GetType() const {
-		return PacketType::UpdateGameState;
-	}
-};
-
-}  // namespace protocol
-}  // namespace blitz
--- a/include/blitz/protocol/packets/UpdateHealthPacket.h
+++ b/include/blitz/protocol/packets/UpdateHealthPacket.h
@@ -1,40 +1,16 @@
 #pragma once

-/**
- * \file UpdateHealthPacket.h
- * \brief File containing the blitz::protocol::UpdateHealthPacket class
- */
-
 #include "blitz/protocol/Protocol.h"

 namespace blitz {
 namespace protocol {

-/**
- * \class UpdateHealthPacket
- * \brief Packet for updating the health of a player.
- * %Packet structure :
- * |      PacketType 		  |
- * |--------------------------|
- * | PacketType::UpdateHealth |
- *
- * |	 Field Name 	|  	 Field Type		|  			  Notes 			|
- * |--------------------|-------------------|-------------------------------|
- * |	m_NewHealth		|     float			|	The new health value		|
- */
 class UpdateHealthPacket : public Packet {
  private:
 	float m_NewHealth;

  public:
-	/**
-	 * \brief Default constructor.
-	 */
 	UpdateHealthPacket() {}
-	/**
-	 * \brief Constructor.
-	 * \param newHealth The new health value.
-	 */
 	UpdateHealthPacket(float newHealth) : m_NewHealth(newHealth) {}
 	virtual ~UpdateHealthPacket() {}

@@ -42,11 +18,7 @@ class UpdateHealthPacket : public Packet {
 	virtual void Deserialize(DataBuffer& data);
 	virtual void Dispatch(PacketHandler* handler) const;

-	/**
-	 * \brief Get the new health value.
-	 * \return The new health value.
-	 */
-	float GetNewHealth() const {
+	std::uint8_t GetNewHealth() const {
 		return m_NewHealth;
 	}

--- a/include/client/Client.h
+++ b/include/client/Client.h
@@ -23,10 +23,15 @@ namespace server {
 class Server;
 }  // namespace server

-
+class GuiListener {
+  public:
+	virtual void OnTextChatReceived(const protocol::ColoredText& text) {}
+	virtual void OnSpectatorChange(game::PlayerID player) {}
+	virtual void OnPlayerShoot(game::PlayerID player, const Vec3f& position, float yaw, float pitch) {}
+};

 // Singleton
-class Client : public utils::ObjectNotifier<game::ClientListener>, public game::PlayerInputListener {
+class Client : public utils::ObjectNotifier<GuiListener>, public game::PlayerInputListener {
  private:
 	std::unique_ptr<server::Server> m_Server;
 	std::unique_ptr<client::ClientConnexion> m_Connexion;
@@ -70,8 +75,6 @@ class Client : public utils::ObjectNotifier<game::ClientListener>, public game::
 		return m_Server.get();
 	}

-	void UpdateServerConfig();
-
  private:
 	void Reset();

--- a/include/client/ClientConnexion.h
+++ b/include/client/ClientConnexion.h
@@ -24,7 +24,7 @@ class ClientConnexion : public network::Connexion {
 	virtual void HandlePacket(const protocol::ChatPacket* packet) override;
 	virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet) override;

-	bool Connect(const std::string& pseudo, const std::string& address, std::uint16_t port);
+	virtual bool Connect(const std::string& pseudo, const std::string& address, std::uint16_t port);

 	game::PlayerID GetPlayerID() const {
 		return m_PlayerID;
--- a/include/client/audio/AudioBuffer.h
+++ b/include/client/audio/AudioBuffer.h
@@ -1,25 +0,0 @@
-#pragma once
-
-#include "blitz/common/DataBuffer.h"
-#include "blitz/common/NonCopyable.h"
-#include "blitz/maths/Vector.h"
-#include "client/audio/AudioLoader.h"
-
-namespace blitz {
-namespace audio {
-
-class AudioBuffer : private NonCopyable {
-  private:
-	unsigned int m_ID;
-
-  public:
-	AudioBuffer(AudioData&& audioData);
-	~AudioBuffer();
-
-	unsigned int GetID() const {
-		return m_ID;
-	}
-};
-
-}  // namespace audio
-}  // namespace blitz
--- a/include/client/audio/AudioListener.h
+++ b/include/client/audio/AudioListener.h
@@ -1,21 +0,0 @@
-#pragma once
-
-#include "blitz/common/NonCopyable.h"
-#include "blitz/maths/Vector.h"
-
-namespace blitz {
-namespace audio {
-
-class AudioListener : private NonCopyable {
-  public:
-	AudioListener();
-	~AudioListener();
-
-	void SetGain(float a_Gain);
-	void SetPosition(const Vec3f& a_Position);
-	void SetVelocity(const Vec3f& a_Velocity);
-	void SetOrientation(const Vec3f& a_Orientation, const Vec3f& a_Up);
-};
-
-}  // namespace audio
-}  // namespace blitz
--- a/include/client/audio/AudioLoader.h
+++ b/include/client/audio/AudioLoader.h
@@ -1,24 +0,0 @@
-#pragma once
-
-#include "blitz/common/DataBuffer.h"
-
-namespace blitz {
-namespace audio {
-
-enum AudioFormat { afMono8 = 0, afMono16, afStereo8, afStereo16 };
-
-struct AudioData {
-	DataBuffer m_Buffer;
-	AudioFormat m_Format;
-	std::uint32_t m_Frequency;
-};
-
-namespace AudioLoader {
-
-// files should be 8 or 16 bits wav
-AudioData LoadAudioFile(const std::string& filePath);
-
-};	// namespace AudioLoader
-
-}  // namespace audio
-}  // namespace blitz
--- a/include/client/audio/AudioManager.h
+++ b/include/client/audio/AudioManager.h
@@ -1,56 +0,0 @@
-#pragma once
-
-#include "blitz/game/Listeners.h"
-#include "client/audio/AudioListener.h"
-#include "client/audio/AudioSource.h"
-#include <map>
-
-namespace blitz {
-
-class Client;
-
-namespace game {
-class Player;
-}  // namespace game
-
-
-namespace audio {
-
-struct PlayerSound {
-	AudioSourcePtr m_Laser;
-};
-
-class AudioManager : public game::ClientListener, public game::GameListener {
-  private:
-	Client* m_Client;
-	game::Player* m_Player;
-	AudioListener m_Listener;
-	AudioSourcePtr m_MenuMusic;
-	AudioBufferPtr m_LaserSound;
-	std::map<game::PlayerID, PlayerSound> m_PlayerSources;
-
-  public:
-	AudioManager(Client* client);
-	~AudioManager();
-
-	virtual void OnGameJoin() override;
-	virtual void OnGameLeave() override;
-	virtual void OnClientPlayerJoin() override;
-	virtual void OnPlayerShoot(game::PlayerID player, const Vec3f& position, float yaw, float pitch) override;
-	virtual void OnPlayerJoin(game::PlayerID player) override;
-	virtual void OnPlayerLeave(game::PlayerID player) override;
-
-	void SetGlobalVolume(float volume);
-
-	void Update();
-
-  private:
-	void InitSounds();
-	AudioSourcePtr InitSourceFromFile(const std::string& fileName);
-	AudioSourcePtr InitSourceFromBuffer(const AudioBufferPtr& buffer);
-	AudioBufferPtr InitBufferFromFile(const std::string& fileName);
-};
-
-}  // namespace audio
-
-}  // namespace blitz
--- a/include/client/audio/AudioSource.h
+++ b/include/client/audio/AudioSource.h
@@ -1,43 +0,0 @@
-#pragma once
-
-#include "blitz/common/NonCopyable.h"
-#include "blitz/maths/Vector.h"
-#include "client/audio/AudioBuffer.h"
-#include <memory>
-
-namespace blitz {
-namespace audio {
-
-typedef std::shared_ptr<AudioBuffer> AudioBufferPtr;
-
-class AudioSource : NonCopyable {
-  private:
-	unsigned int m_ID;
-	AudioBufferPtr m_Buffer;
-
-  public:
-	enum SourceState { ssInitial = 0, ssPlaying, ssPaused, ssStopped };
-
-	AudioSource();
-	~AudioSource();
-
-	void SetGain(float a_Gain);
-	void SetPitch(float a_Pitch);
-	void SetPosition(const Vec3f& a_Position);
-	void SetDirection(const Vec3f& a_Direction);
-	void SetVelocity(const Vec3f& a_Velocity);
-	void SetLooping(bool a_Looping);
-	void SetRelative(bool a_Relative);
-	void SetBuffer(const AudioBufferPtr& a_Buffer);
-
-	SourceState GetSourceState() const;
-
-	void Play();
-	void Pause();
-	void Stop();
-};
-
-typedef std::unique_ptr<AudioSource> AudioSourcePtr;
-
-}  // namespace audio
-}  // namespace blitz
--- a/include/client/config/BlitzConfig.h
+++ b/include/client/config/BlitzConfig.h
@@ -1,114 +1,66 @@
 #pragma once

-/**
- * \file BlitzConfig.h
- * \brief File containing the blitz::BlitzConfig class
- */
-
-#include "blitz/game/Game.h"
 #include <array>
 #include <string>

 namespace blitz {

-/**
- * \enum KeyAction
- * \brief Enum containing the key actions
- */
 enum KeyAction {
 	kaAvancer = 0,
 	kaReculer,
 	kaDroite,
 	kaGauche,
-	kaFenetreAdmin,
 	kaMax,
 };

 typedef std::array<int, kaMax> Keybinds;

-/**
- * \class BlitzConfig
- * \brief Class used to manage the Blitz configuration
- */
 class BlitzConfig {
  private:
-	std::array<char, 20> m_Pseudo;
-	game::GameConfig m_ServerConfig;
+	std::array<char, 256> m_Pseudo;
 	bool m_VSync;
 	bool m_DisplayFps;
+	KeyAction m_CurrentAction;
 	Keybinds m_Keybinds{};
 	float m_MouseSpeed;

+
  public:
-	/**
-	 * \brief Default constructor
-	 */
 	BlitzConfig();
 	~BlitzConfig();

-	std::array<char, 20>& GetPseudo() {
+	std::array<char, 256>& GetPseudo() {
 		return m_Pseudo;
 	}

-	/**
-	 * \brief Return whether VSync is enabled
-	 */
 	bool IsVSyncEnabled() const {
 		return m_VSync;
 	}

-	/**
-	 * \brief Set whether VSync is enabled
-	 */
 	void SetVSync(bool vsync) {
 		m_VSync = vsync;
 	}

-	/**
-	 * \brief Return whether the FPS display is enabled
-	 */
 	bool IsFPSDisplayEnabled() const {
 		return m_DisplayFps;
 	}

-	/**
-	 * \brief Set whether the FPS display is enabled
-	 */
 	void SetFPSDisplay(bool display) {
 		m_DisplayFps = display;
 	}

-	/**
-	 * \brief Get the keybinds
-	 * \return The keybinds
-	 */
 	Keybinds& GetKeys() {
 		return m_Keybinds;
 	}

-	/**
-	 * \brief Get the mouse speed
-	 * \return The mouse speed
-	 */
-	float GetMouseSpeed() const {
+	float GetMouseSpeed() {
 		return m_MouseSpeed;
 	}

-	/**
-	 * \brief Set the mouse speed
-	 */
 	void SetMouseSpeed(float MouseSpeed) {
 		m_MouseSpeed = MouseSpeed;
 	}

-	/**
-	 * \brief Get the server configuration
-	 * \return The server configuration
-	 */
-	game::GameConfig& GetServerConfig() {
-		return m_ServerConfig;
-	}
-
  private:
 	void LoadConfig();
 	void LoadDefaultConfig();
--- a/include/client/display/Display.h
+++ b/include/client/display/Display.h
@@ -1,12 +1,5 @@
 #pragma once

-/**
- * \file Display.h
- * \brief File containing the blitz::Display class
- */
-
-#include "client/display/InputManager.h"
-#include "client/display/PlayerController.h"
 #include <memory>
 #include <string>

@@ -20,10 +13,7 @@ namespace gui {
 class BlitzGui;
 }  // namespace gui

-/**
- * \class Display
- * \brief Class used to manage the display
- */
+
 class Display {
  private:
 	SDL_Window* m_Window;
@@ -38,76 +28,24 @@ class Display {
 	bool m_FullScreen;

 	Client* m_Client;
-	input::InputManager& m_InputManager;
 	std::unique_ptr<gui::BlitzGui> m_BlitzGui;
-	input::PlayerController m_PlayerController;

  public:
-	/**
-	 * \brief Constructor
-	 * \param width The width of the window
-	 * \param height The height of the window
-	 * \param windowName The name of the window
-	 * \param client The client
-	 * \param inputManager The InputManager
-	 */
-	Display(int width, int height, const std::string& windowName, Client* client, input::InputManager& inputManager);
+	Display(int width, int height, const std::string& windowName, Client* client);
 	~Display();

-	/**
-	 * \brief Return whether the display has been created
-	 */
 	bool Create();
-
-	/**
-	 * \brief Poll the events
-	 * \note This function should be called at the beginning of the main loop
-	 */
 	void PollEvents();
-
-	/**
-	 * \brief Update the display
-	 * \note Swap the buffers
-	 */
 	void Update();
-
-	/**
-	 * \brief Render the display (ImGui)
-	 */
 	void Render();
-
-	/**
-	 * \brief Destroy the display (Not your mother's display)
-	 */
 	void Destroy();

-	/**
-	 * \brief Return whether the display should be closed
-	 */
 	bool IsCloseRequested();

-	/**
-	 * \brief Return widht/height ratio
-	 */
 	float GetAspectRatio();
-
-	/**
-	 * \brief Return the window width
-	 */
 	int GetWindowWidth();
-
-	/**
-	 * \brief Return the window height
-	 */
 	int GetWindowHeight();

-	/**
-	 * \brief Return the player controller
-	 */
-	input::PlayerController& GetPlayerController() {
-		return m_PlayerController;
-	}
-
  private:
 	void InitImGui();
 };
--- a/include/client/display/InputManager.h
+++ b/include/client/display/InputManager.h
@@ -1,30 +1,19 @@
 #pragma once

-#include "blitz/misc/ObjectNotifier.h"
 #include <SDL2/SDL_events.h>
 #include <functional>

 namespace blitz {
-namespace input {
+namespace InputManager {

-class InputListener {
-  public:
-	virtual void OnKeyDown(int imguiKey) {}
-	virtual void OnMouseMove(int deltaX, int deltaY) {}
-};
+typedef std::function<void(int)> KeyDownCallback;
+typedef std::function<void(int, int)> MouseMoveCallback;

-class InputManager : public utils::ObjectNotifier<InputListener> {
-  private:
-	bool m_MouseInputGrabbed;
+void BindKeyDownCallback(const KeyDownCallback&);
+void BindMouseMoveCallback(const MouseMoveCallback&);
+void ProcessEvent(SDL_Event& event);
+void GrabMouse(bool grabInput);
+bool MouseGrabbed();

-  public:
-	InputManager() : m_MouseInputGrabbed(false) {}
-	virtual ~InputManager() {}
-
-	void ProcessEvent(SDL_Event& event) const;
-	void GrabMouse(bool grabInput);
-	bool MouseGrabbed() const;
-};
-
-}  // namespace input
+}  // namespace InputManager
 }  // namespace blitz
--- a/include/client/display/PlayerController.h
+++ b/include/client/display/PlayerController.h
@@ -1,15 +1,9 @@
 #pragma once

-/**
- * \file PlayerController.h
- * \brief File containing the blitz::input::PlayerController class.
- */
-
 #include "blitz/common/Smoothing.h"
 #include "blitz/game/Listeners.h"
 #include "blitz/misc/ObjectNotifier.h"
 #include "blitz/misc/Time.h"
-#include "client/display/InputManager.h"

 namespace blitz {

@@ -23,49 +17,46 @@ class Player;

 namespace input {

-/**
- * \brief Class that handles player input and sends it to the client.
- * \details This class is responsible for handling player input and sending it to the server.
- * It also handles the player's velocity and position.
- */
-class PlayerController : public utils::ObjectNotifier<game::PlayerInputListener>, game::ClientListener, InputListener {
+class PlayerController : public utils::ObjectNotifier<game::PlayerInputListener> {
  private:
 	game::Player* m_Player;
 	Client* m_Client;
-	input::InputManager& m_InputManager;
 	utils::CooldownTimer<float> m_ShootTimer{1.0f};
 	EMASmoother m_DxSmoother;
 	EMASmoother m_DySmoother;
-	// current (target) velocity
-	Vec3f m_Velocity;
+	/// current (target) x-axis velocity
+	float m_Dx;
+	/// current (target) y-axis velocity
+	float m_Dy;
+	/// current z-axis velocity
+	float m_Dz;
 	/// maximum x-axis velocity
-	Vec3f m_MaxVelocity;
+	float m_MaxDx;
+	/// maximum (target) y-axis velocity
+	float m_MaxDy;
+	/// maximum z-axis velocity (velocity at initial keypress)
+	float m_MaxDz;
+	/// individual gravitational force
+	float m_G;
 	/// this is reset when the player touches the ground
 	bool m_OnGround;

  public:
-	/**
-	 * \brief Default constructor
-	 */
-	PlayerController(Client* client, input::InputManager& inputManager);
-	virtual ~PlayerController();
+	PlayerController(Client* client);

-	/**
-	 * \brief Update things like player position and velocity.
-	 */
 	void Update(float delta);

-	virtual void OnGameConfigUpdate() override;
-	virtual void OnClientPlayerJoin() override;
-	virtual void OnGameLeave() override;
+	void SetAttachedPlayer(game::Player* a_Player) {
+		m_Player = a_Player;
+	}

-	virtual void OnMouseMove(int, int) override;
+	game::Player* GetAttachedPlayer() {
+		return m_Player;
+	}

  private:
-	void UpdateShootTimer(int bpm);
+	void MouseMotionEvent(int, int);
 	void UpdatePosition(float delta);
-	void ApplyForce(const Vec3f& f, float delta);
-	void ApplyGravity(float delta);
 };

 }  // namespace input
--- a/include/client/game/ClientGame.h
+++ b/include/client/game/ClientGame.h
@@ -1,9 +1,7 @@
 #pragma once

 #include "blitz/game/Game.h"
-#include "blitz/game/LeaderBoard.h"
 #include "blitz/protocol/PacketHandler.h"
-#include <vector>

 namespace blitz {

@@ -14,7 +12,6 @@ namespace client {
 class ClientGame : public game::Game, public protocol::PacketHandler {
  private:
 	Client* m_Client;
-	game::LeaderBoard m_LeaderBoard;

  public:
 	ClientGame(Client* client, protocol::PacketDispatcher* dispatcher);
@@ -29,15 +26,6 @@ class ClientGame : public game::Game, public protocol::PacketHandler {
 	virtual void HandlePacket(const protocol::PlayerShootPacket* packet) override;
 	virtual void HandlePacket(const protocol::UpdateHealthPacket* packet) override;
 	virtual void HandlePacket(const protocol::PlayerStatsPacket* packet) override;
-	virtual void HandlePacket(const protocol::UpdateGameStatePacket* packet) override;
-	virtual void HandlePacket(const protocol::ServerConfigPacket* packet) override;
-
-	virtual void AddPlayer(game::PlayerID player, const std::string& name) override;
-	virtual void RemovePlayer(game::PlayerID player) override;
-
-	const game::LeaderBoard& GetLeaderBoard() const {
-		return m_LeaderBoard;
-	}

  private:
 	void RegisterHandlers();
--- a/include/client/game/ClientWorld.h
+++ b/include/client/game/ClientWorld.h
@@ -1,20 +0,0 @@
-#pragma once
-
-#include "blitz/game/World.h"
-
-namespace blitz {
-namespace client {
-
-class ClientGame;
-
-class ClientWorld : public game::World {
-  public:
-	ClientWorld(ClientGame* game);
-	virtual ~ClientWorld() {}
-
-  private:
-	void LoadAABBs();
-};
-
-}  // namespace client
-}  // namespace blitz
--- a/include/client/gui/BlitzGui.h
+++ b/include/client/gui/BlitzGui.h
@@ -1,7 +1,6 @@
 #pragma once

 #include "GuiWidget.h"
-#include "client/display/InputManager.h"

 namespace blitz {

@@ -14,7 +13,7 @@ class BlitzGui : public GuiWidget {
 	enum SubMenu { Main = 0 };

  public:
-	BlitzGui(Client* client, input::InputManager& inputManager);
+	BlitzGui(Client* client);

 	virtual void Render() override;

--- a/include/client/gui/CreateGameMenu.h
+++ b/include/client/gui/CreateGameMenu.h
@@ -1,7 +1,6 @@
 #pragma once

 #include "GuiWidget.h"
-#include "client/display/InputManager.h"

 namespace blitz {

@@ -10,11 +9,8 @@ class Client;
 namespace gui {

 class CreateGameMenu : public GuiWidget {
-  private:
-	input::InputManager& m_InputManager;
-
  public:
-	CreateGameMenu(GuiWidget* parent, Client* client, input::InputManager& inputManager);
+	CreateGameMenu(GuiWidget* parent, Client* client) : GuiWidget(parent, client) {}

 	virtual void Render() override;
 };
--- a/include/client/gui/Crosshair.h
+++ b/include/client/gui/Crosshair.h
@@ -7,7 +7,7 @@ namespace gui {

 class CrossHair : public GuiWidget {
  private:
-	std::uint64_t m_CrossHairTexture;
+	int m_CrossHairTexture;

  public:
 	CrossHair(Client* client);
--- a/include/client/gui/GameChatGui.h
+++ b/include/client/gui/GameChatGui.h
@@ -2,7 +2,6 @@

 #include "GuiWidget.h"
 #include "client/Client.h"
-#include "client/display/InputManager.h"
 #include <string>
 #include <vector>

@@ -10,7 +9,7 @@ namespace blitz {

 namespace gui {

-class GameChatGui : public GuiWidget, game::ClientListener {
+class GameChatGui : public GuiWidget, GuiListener {
  private:
 	char InputBuf[256];
 	std::vector<protocol::ColoredText> m_Lines;
@@ -20,17 +19,14 @@ class GameChatGui : public GuiWidget, game::ClientListener {
 	bool ScrollToBottom = false;
 	bool AutoScroll = true;
 	float m_ChatDisplay = 0;
-	input::InputManager& m_InputManager;


 	void Draw(const char* title, bool* p_open);
 	void DrawMini(const char* title, bool* p_open);

  public:
-	GameChatGui(GuiWidget* parent, Client* client, input::InputManager& inputManager);
-	virtual ~GameChatGui();
-
-	virtual void OnTextChatReceived(const protocol::ColoredText& text) override;
+	GameChatGui(GuiWidget* parent, Client* client);
+	virtual void OnTextChatReceived(const protocol::ColoredText& text);

 	virtual void Render() override;
 };
--- a/include/client/gui/Hud.h
+++ b/include/client/gui/Hud.h
@@ -7,26 +7,18 @@ namespace blitz {

 class Client;

-namespace game {
-class Player;
-}  // namespace game
-
 namespace gui {
 class Hud : public GuiWidget {
  private:
-	std::uint64_t m_GunTexture;
-	std::uint64_t m_JPTexture;
-	utils::DelayTimer<float> m_Timer{5.0f};
+	/* data */
+
+	void Draw(const char* title, bool* p_open);
+	unsigned int m_GunTexture;
+	unsigned int m_JP;

  public:
 	Hud(GuiWidget* parent, Client* client);
 	virtual void Render() override;
-
-  private:
-	std::string FormatString();
-	void Draw(const char* title, bool* p_open);
-	void DrawFinishScreen(bool win);
-	void RenderTime(float, float);
 };

 }  // namespace gui
--- a/include/client/gui/JoinGameMenu.h
+++ b/include/client/gui/JoinGameMenu.h
@@ -1,7 +1,6 @@
 #pragma once

 #include "GuiWidget.h"
-#include "client/display/InputManager.h"

 namespace blitz {

@@ -10,11 +9,8 @@ class Client;
 namespace gui {

 class JoinGameMenu : public GuiWidget {
-  private:
-	input::InputManager& m_InputManager;
-
  public:
-	JoinGameMenu(GuiWidget* parent, Client* client, input::InputManager& inputManager);
+	JoinGameMenu(GuiWidget* parent, Client* client) : GuiWidget(parent, client) {}

 	virtual void Render() override;
 };
--- a/include/client/gui/LeaderBoardGui.h
+++ b/include/client/gui/LeaderBoardGui.h
@@ -6,14 +6,13 @@
 namespace blitz {

 namespace gui {
-class LeaderBoardGui : public GuiWidget {
+class LeaderBoard : public GuiWidget {
  private:
 	void Draw(const char* title, bool* p_open);
-	utils::DelayTimer<float> m_Timer{5.0f};

  public:
-	LeaderBoardGui(GuiWidget* parent, Client* client);
-	~LeaderBoardGui();
+	LeaderBoard(GuiWidget* parent, Client* client);
+	~LeaderBoard();

 	virtual void Render() override;
 };
--- a/include/client/gui/MainMenu.h
+++ b/include/client/gui/MainMenu.h
@@ -1,29 +1,19 @@
 #pragma once

 #include "GuiWidget.h"
-#include "blitz/game/Listeners.h"

 namespace blitz {

 class Client;

-namespace input {
-class InputManager;
-}  // namespace input
-
 namespace gui {

-class MainMenu : public GuiWidget, public game::ClientListener {
+class MainMenu : public GuiWidget {
  private:
 	enum SubMenu { CREATE_MENU = 0, JOIN_MENU, OPTION_MENU };

-	input::InputManager& m_InputManager;
-
  public:
-	MainMenu(Client* client, input::InputManager& inputManager);
-	virtual ~MainMenu();
-
-	virtual void OnGameLeave() override;
+	MainMenu(Client* client);

 	virtual void Render() override;
 };
--- a/include/client/gui/OptionsMenu.h
+++ b/include/client/gui/OptionsMenu.h
@@ -3,7 +3,6 @@
 #include "GuiWidget.h"
 #include "blitz/misc/Time.h"
 #include "client/config/BlitzConfig.h"
-#include "client/display/InputManager.h"
 #include <array>
 #include <string>

@@ -13,7 +12,7 @@ class Client;

 namespace gui {

-class OptionsMenu : public GuiWidget, public input::InputListener {
+class OptionsMenu : public GuiWidget {
  private:
 	bool m_ShowFPS;
 	bool m_VSync;
@@ -21,15 +20,13 @@ class OptionsMenu : public GuiWidget, public input::InputListener {
 	bool m_KeyPopupShouldClose;
 	utils::Timer m_Timer{100};
 	KeyAction m_CurrentAction;
-	input::InputManager& m_InputManager;

  public:
-	OptionsMenu(GuiWidget* parent, Client* client, input::InputManager& inputManager);
-	virtual ~OptionsMenu();
+	OptionsMenu(GuiWidget* parent, Client* client);

 	virtual void Render() override;

-	virtual void OnKeyDown(int key) override;
+	void OnKeyEvent(int key);

  private:
 	std::string GetKeyActionCodeName(KeyAction);
--- a/include/client/gui/ServerGui.h
+++ b/include/client/gui/ServerGui.h
@@ -1,17 +1,13 @@
 #pragma once

 #include "GuiWidget.h"
-#include "client/display/InputManager.h"

 namespace blitz {
 namespace gui {

 class ServerGui : public GuiWidget {
-  private:
-	input::InputManager& m_InputManager;
-
  public:
-	ServerGui(GuiWidget* parent, Client* client, input::InputManager& inputManager);
+	ServerGui(GuiWidget* parent, Client* client);

 	virtual void Render() override;
 };
--- a/include/client/render/BulletRenderer.h
+++ b/include/client/render/BulletRenderer.h
@@ -28,16 +28,16 @@ class BulletRenderer {
 	std::vector<Trail> m_Trails;
 	ModelLoader::Model m_BulletModel;
 	std::unique_ptr<shader::BulletShader> m_Shader;
+	unsigned int m_Vbo;
 	const Camera& m_Camera;

  public:
 	BulletRenderer(const Camera& cam);
 	~BulletRenderer();

-	void AddBullet(const Vec3f& origin, float yaw, float pitch, bool firstPersson);
+	void AddBullet(const Vec3f& origin, float yaw, float pitch);
 	void Update(float delta);
 	void Render();
-	void Clear();
 };

 }  // namespace render
--- a/include/client/render/Camera.h
+++ b/include/client/render/Camera.h
@@ -1,6 +1,7 @@
 #pragma once

 #include "blitz/game/Player.h"
+#include "blitz/maths/Vector.h"
 #include <cstdint>

 namespace blitz {
--- a/include/client/render/MainRenderer.h
+++ b/include/client/render/MainRenderer.h
@@ -20,7 +20,7 @@ class GunShader;

 namespace render {

-class MainRenderer : public game::ClientListener, public game::PlayerInputListener {
+class MainRenderer : public GuiListener, public game::PlayerInputListener {
  private:
 	Client* m_Client;
 	ModelLoader::Model m_PlayerModel;
@@ -29,23 +29,20 @@ class MainRenderer : public game::ClientListener, public game::PlayerInputListen
 	std::unique_ptr<shader::EntityShader> m_EntityShader;
 	std::unique_ptr<shader::WorldShader> m_WorldShader;
 	std::unique_ptr<shader::GunShader> m_GunShader;
+	input::PlayerController m_PlayerController;
 	unsigned int m_Texture;
 	float m_ShootTime;
 	Camera m_Camera;
 	BulletRenderer m_BulletRenderer;
-	input::PlayerController& m_PlayerController;

  public:
-	MainRenderer(Client* client, input::PlayerController& playerController);
+	MainRenderer(Client* client);
 	~MainRenderer();

 	virtual void OnSpectatorChange(game::PlayerID player) override;
 	virtual void OnPlayerShoot(game::PlayerID player, const Vec3f& position, float yaw, float pitch) override;
 	virtual void OnLocalPlayerShoot(const Vec3f& position, float yaw, float pitch) override;

-	virtual void OnGameConfigUpdate() override;
-	virtual void OnGameLeave() override;
-
 	void Update();
 	void Render();
 	void RenderEntity(const GL::VertexArray& vao, const Vec3f& position, float yaw);
--- a/include/client/render/OpenGL.h
+++ b/include/client/render/OpenGL.h
@@ -1,6 +1,6 @@
 #pragma once

-#ifdef BLITZ_GL_LOADER_GLEW
+#ifndef BLITZ_GL_LOADER_GLBNIDING
 #include <GL/glew.h>
 #else
 #include <glbinding/gl/gl.h>
--- a/include/client/render/loader/GLLoader.h
+++ b/include/client/render/loader/GLLoader.h
@@ -70,7 +70,7 @@ class VertexArray : private NonCopyable {
 	VertexArray(ElementBuffer&& indicies);
 	~VertexArray();

-	std::size_t GetVertexCount() const {
+	unsigned int GetVertexCount() const {
 		return m_ElementBuffer.GetTriangleCount();
 	}

--- a/include/client/render/loader/ModelLoader.h
+++ b/include/client/render/loader/ModelLoader.h
@@ -1,6 +1,5 @@
 #pragma once

-#include "blitz/maths/Physics.h"
 #include "client/render/loader/GLLoader.h"
 #include <memory>
 #include <string>
@@ -17,7 +16,5 @@ struct Model {

 Model LoadModel(const std::string& fileName);

-std::vector<maths::AABB> LoadModelAABBs(const std::string& fileName);
-
 }  // namespace ModelLoader
 }  // namespace blitz
--- a/include/server/Server.h
+++ b/include/server/Server.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file Server.h
- * \brief File containing the blitz::server::Server class
- */
-
 #include <map>
 #include <thread>

@@ -13,15 +8,7 @@
 #include "server/ServerConnexion.h"
 #include "server/game/ServerGame.h"

-/**
- * \def SERVER_TPS
- * \brief The server ticks per second
- */
 #define SERVER_TPS 20
-/**
- * \def SERVER_TICK
- * \brief The server tick duration
- */
 #define SERVER_TICK 1000 / SERVER_TPS

 namespace blitz {
@@ -29,10 +16,6 @@ namespace server {

 typedef std::map<std::uint8_t, std::unique_ptr<ServerConnexion>> ConnexionMap;

-/**
- * \class Server
- * \brief Class used to manage the server
- */
 class Server {
  private:
 	network::TCPListener m_Listener;
@@ -44,117 +27,48 @@ class Server {
 	std::thread m_Thread;
 	bool m_ServerRunning;

-	game::PlayerID m_FreePlayerID;
-
  public:
-	/**
-	 * \brief Constructor
-	 */
 	Server();
 	virtual ~Server();

-	/**
-	 * \brief Start the server
-	 * \param port The port
-	 * \param blocking If the server is blocking
-	 * \return If the server has started
-	 */
 	bool Start(std::uint16_t port, bool blocking);
-	/**
-	 * \brief Force the server to stop
-	 */
-	void Stop();
+	void Stop();  // force the server to stop

-	/**
-	 * \brief Restart the server
-	 */
 	void Restart();

-	/**
-	 * \brief Add a bot
-	 */
 	void AddBot();

-	/**
-	 * \brief Forcefully remove a player from the game
-	 * \param player the id of the player to remove
-	 */
-	void KickPlayer(game::PlayerID player);
-
-	/**
-	 * \brief Remove a connexion
-	 * \param connexionID The connexion ID
-	 */
 	void RemoveConnexion(std::uint8_t connexionID);

-	/**
-	 * \brief Broadcast a packet to all connexions
-	 * \param packet The packet
-	 */
 	void BroadcastPacket(const protocol::Packet* packet);
-	/**
-	 * \brief Broadcast a chat message
-	 * \param msg The message
-	 */
 	void BroadcastChatMessage(const std::string& msg);

-	/**
-	 * \brief Get the milliseconds per tick
-	 * \return The milliseconds per tick
-	 */
 	float GetMSPT() const {
 		return m_TickCounter.GetMSPT();
 	}

-	/**
-	 * \brief Get the ticks per second
-	 * \return The ticks per second
-	 */
 	float GetTPS() const {
 		return m_TickCounter.GetTPS();
 	}

-	/**
-	 * \brief Return whether the server is running
-	 */
 	bool IsRunning() {
 		return m_ServerRunning;
 	}

-	/**
-	 * \brief Get the connexions (const version)
-	 * \return The connexions
-	 */
 	const ConnexionMap& GetConnexions() const {
 		return m_Connections;
 	}

-	/**
-	 * \brief Get the connexions
-	 * \return The connexions
-	 */
 	ConnexionMap& GetConnexions() {
 		return m_Connections;
 	}

-	/**
-	 * \brief Get the game
-	 * \return The game
-	 */
 	ServerGame& GetGame() {
 		return m_Game;
 	}

-	/**
-	 * \brief Get the listening port
-	 * \return The listening port
-	 */
 	std::uint16_t GetListeningPort();

-	/**
-	 * \brief Get a new player ID
-	 * \return The new player ID
-	 */
 	game::PlayerID GetNewPlayerID();

  private:
--- a/include/server/ServerConnexion.h
+++ b/include/server/ServerConnexion.h
@@ -1,10 +1,5 @@
 #pragma once

-/**
- * \file ServerConnexion.h
- * \brief File containing the blitz::server::ServerConnexion class
- */
-
 #include "blitz/network/Connexion.h"

 namespace blitz {
@@ -20,23 +15,13 @@ namespace server {

 class Server;

-/**
- * \struct KeepAlive
- * \brief Structure containing the keep alive informations
- * \var KeepAlive::KeepAliveID The keep alive ID
- * \var KeepAlive::SendTime The time when the keep alive was sent
- * \var KeepAlive::RecievedResponse If the keep alive has recieved a response
- */
 struct KeepAlive {
-	std::uint64_t KeepAliveID = 0;
-	std::uint64_t SendTime;
-	bool RecievedResponse = false;
+	std::uint64_t keepAliveID = 0;
+	std::uint64_t sendTime;
+	bool recievedResponse = false;
 };

-/**
- * \class ServerConnexion
- * \brief Class used to manage the server connexion
- */
+
 class ServerConnexion : public network::Connexion {
  private:
 	Server* m_Server;
@@ -46,31 +31,11 @@ class ServerConnexion : public network::Connexion {
 	std::string m_ChatColor;

  public:
-	/**
-	 * \brief Constructor
-	 * \param server The server
-	 * \param socket The socket
-	 * \param id The ID of the connexion
-	 */
 	ServerConnexion(Server* server, network::TCPSocket& socket, std::uint8_t id);
-	/**
-	 * \brief Move constructor
-	 */
 	ServerConnexion(ServerConnexion&& move);
 	virtual ~ServerConnexion();

-	/**
-	 * \brief Start the connexion
-	 */
-	void Init();
-
-	/**
-	 * \brief Get the ID of the connexion
-	 * \return The ID of the connexion
-	 */
-	std::uint8_t GetID() const {
-		return m_ID;
-	}
+	void Start();

 	virtual void HandlePacket(const protocol::PlayerLoginPacket* packet) override;
 	virtual void HandlePacket(const protocol::KeepAlivePacket* packet) override;
@@ -79,7 +44,11 @@ class ServerConnexion : public network::Connexion {
 	virtual void HandlePacket(const protocol::PlayerPositionAndRotationPacket* packet) override;
 	virtual void HandlePacket(const protocol::PlayerShootPacket* packet) override;

-	virtual bool UpdateSocket() override;
+	std::uint8_t GetID() const {
+		return m_ID;
+	}
+
+	virtual bool UpdateSocket();

  private:
 	void RegisterHandlers();
@@ -88,8 +57,6 @@ class ServerConnexion : public network::Connexion {
 	void InitConnection();
 	void InitPlayerChatColor();
 	void SendPlayers();
-	void SendGameState();
-	void SendServerConfig();
 };

 }  // namespace server
--- a/include/server/game/ServerGame.h
+++ b/include/server/game/ServerGame.h
@@ -1,103 +1,34 @@
 #pragma once

-/**
- * \file ServerGame.h
- * \brief File containing the blitz::server::ServerGame class
- */
-
 #include "blitz/game/Game.h"
+#include "blitz/misc/Time.h"

 namespace blitz {
 namespace server {

-/**
- * \struct ServerDuration
- * \brief Structure containing the server game durations
- * \var ServerDuration::m_GameDuration The game duration
- * \var ServerDuration::m_PrepDuration The preparation duration
- * \var ServerDuration::m_EndDuration The end duration
- */
-struct ServerDuration {
-	std::uint64_t m_GameDuration = 1000 * 3 * 60;
-	std::uint64_t m_PrepDuration = 1000 * 10;
-	std::uint64_t m_EndDuration = 1000 * 30;
-};
-
 class Server;

-/**
- * \class ServerGame
- * \brief Class used to manage the server game
- */
 class ServerGame : public game::Game {
  private:
 	Server* m_Server;
 	utils::Timer m_PositionTimer;
-	ServerDuration m_ServerDuration;

  public:
-	/**
-	 * \brief Constructor
-	 * \param server The server
-	 */
 	ServerGame(Server* server);
 	virtual ~ServerGame();

-	/**
-	 * \brief Process a player shoot
-	 * \param player The player
-	 * \param position The position of the player
-	 * \param yaw The yaw
-	 * \param pitch The pitch
-	 */
-	void ProcessShoot(game::PlayerID player, Vec3f position, float yaw, float pitch);
+	void CheckShoot(game::PlayerID player, Vec3f position, float yaw, float pitch);

-	/**
-	 * \brief Process a player login
-	 * \param player The player
-	 * \param name The name of the player
-	 */
 	void AddPlayer(game::PlayerID player, const std::string& name) override;
-	/**
-	 * \brief Remove a player from the game if he disconnected
-	 */
 	void RemovePlayer(game::PlayerID player) override;

-	/**
-	 * \brief Update the game
-	 * \param delta The delta time in milliseconds
-	 */
 	void Tick(std::uint64_t delta) override;

-	/**
-	 * \brief Set the game state
-	 * \param gameState The game state
-	 * \param duration The duration in milliseconds
-	 */
-	virtual void UpdateGameState(game::GameState gameState, std::uint64_t duration) override;
-
-	/**
-	 * \brief Get the server duration
-	 * \return The server duration in milliseconds
-	 */
-	ServerDuration& GetServerDuration() {
-		return m_ServerDuration;
-	}
-
-	/**
-	 * \brief Send the player positions
-	 */
-	void SendServerConfig();
-
  private:
 	void SendPlayerPositions();
 	void DamagePlayer(game::Player& player, game::Player& shooter);
 	void UpdateHP(game::Player& player, float newHP);
 	void UpdatePlayerStats();
-	void StartGame();	// when at least 2 players joined
-	void CancelGame();	// when not enough players are left
-	void ResetPlayerStats();
-	void InitGameConfig();
 };

 }  // namespace server
--- a/libs/imgui/backends/imgui_impl_sdl2.h
+++ b/libs/imgui/backends/imgui_impl_sdl2.h
@@ -19,7 +19,7 @@
 #include "imgui.h"      // IMGUI_IMPL_API
 #ifndef IMGUI_DISABLE

-struct SDL_Window;
+class SDL_Window;
 struct SDL_Renderer;
 typedef union SDL_Event SDL_Event;

--- a/src/ClientMain.cpp
+++ b/src/ClientMain.cpp
@@ -1,28 +1,23 @@
 #include "blitz/network/Network.h"
 #include "client/Client.h"
-#include "client/audio/AudioManager.h"
 #include "client/display/Display.h"
-#include "client/display/InputManager.h"
 #include "client/render/MainRenderer.h"

 int main(int argc, char** argv) {

 	blitz::Client client;
-	blitz::input::InputManager inputManager;
-	blitz::Display display(1920, 1080, "BlitzKrieg", &client, inputManager);
+	blitz::Display display(1920, 1080, "BlitzKrieg", &client);

 	if (!display.Create())
 		return EXIT_FAILURE;

-	blitz::render::MainRenderer renderer(&client, display.GetPlayerController());
-	blitz::audio::AudioManager audioManager(&client);
+	blitz::render::MainRenderer renderer(&client);
 	blitz::network::NetworkInitializer network;

 	while (!display.IsCloseRequested()) {
 		client.Update();
 		display.PollEvents();
 		renderer.Update();
-		audioManager.Update();
 		renderer.Render();
 		display.Render();
 		display.Update();
--- a/src/blitz/common/DataBuffer.cpp
+++ b/src/blitz/common/DataBuffer.cpp
@@ -85,7 +85,7 @@ bool DataBuffer::ReadFile(const std::string& fileName) {
 	return m_Buffer.size() > 0;
 }

-bool DataBuffer::WriteFile(const std::string& fileName) const {
+bool DataBuffer::WriteFile(const std::string& fileName) {
 	try {
 		std::ofstream file(fileName, std::ostream::binary);
 		file.write(reinterpret_cast<const char*>(m_Buffer.data()), static_cast<std::streamsize>(m_Buffer.size()));
--- a/src/blitz/game/Game.cpp
+++ b/src/blitz/game/Game.cpp
@@ -1,5 +1,4 @@
 #include "blitz/game/Game.h"
-#include <cmath>

 namespace blitz {
 namespace game {
@@ -26,19 +25,10 @@ void Game::AddPlayer(PlayerID player, const std::string& name) {
 	static float MAX_HP = 100;

 	game::Player newPlayer{player};
-	static const maths::AABB PLAYER_BASE_AABB = {Vec3f{-0.5f, -0.9f, -0.5f}, Vec3f{0.5f, 0.9f, 0.5f}};
-	newPlayer.SetHitBoxSize(PLAYER_BASE_AABB);
-	newPlayer.SetPosition({
-		0.0f,
-		std::fabs(PLAYER_BASE_AABB.to.y - PLAYER_BASE_AABB.from.y) * 10.0f,
-		0.0f
-	});
 	newPlayer.SetName(name);
 	newPlayer.SetHP(MAX_HP);

 	GetPlayers().insert({player, newPlayer});
-
-	NotifyListeners(&GameListener::OnPlayerJoin, player);
 }

 void Game::RemovePlayer(PlayerID player) {
@@ -47,17 +37,8 @@ void Game::RemovePlayer(PlayerID player) {
 	if (it == GetPlayers().end())
 		return;

-	NotifyListeners(&GameListener::OnPlayerLeave, player);
-
 	GetPlayers().erase(it);
 }

-void Game::UpdateGameState(GameState newGameState, std::uint64_t timeRemaining) {
-	m_GameState = newGameState;
-	m_GameTimer.SetInterval(timeRemaining);
-	m_GameTimer.Reset();
-	NotifyListeners(&GameListener::OnGameStateUpdate, newGameState);
-}
-
 }  // namespace game
 }  // namespace blitz
--- a/src/blitz/game/LeaderBoard.cpp
+++ b/src/blitz/game/LeaderBoard.cpp
@@ -1,29 +0,0 @@
-#include "blitz/game/LeaderBoard.h"
-
-namespace blitz {
-namespace game {
-
-void LeaderBoard::AddPlayer(Player* player) {
-	m_Players.push_back(player);
-	Update();
-}
-
-void LeaderBoard::RemovePlayer(PlayerID player) {
-	auto it = std::find_if(m_Players.begin(), m_Players.end(), [player](game::Player* p) { return p->GetID() == player; });
-	if (it != m_Players.end())
-		m_Players.erase(it);
-}
-
-void LeaderBoard::Update() {
-	std::sort(m_Players.begin(), m_Players.end(), [](Player* a, Player* b) {
-		std::uint16_t killsA = a->GetStats().m_Kills;
-		std::uint16_t killsB = b->GetStats().m_Kills;
-		if (killsA == killsB) {
-			return a->GetStats().m_Deaths < b->GetStats().m_Deaths;
-		}
-		return killsA > killsB;
-	});
-}
-
-}  // namespace game
-}  // namespace blitz
--- a/src/blitz/game/World.cpp
+++ b/src/blitz/game/World.cpp
@@ -1,13 +0,0 @@
-#include "blitz/game/World.h"
-
-#include "blitz/game/Game.h"
-
-namespace blitz {
-namespace game {
-
-World::World(Game* game) : m_Game(game) {}
-
-World::~World() {}
-
-}  // namespace game
-}  // namespace blitz
--- a/src/blitz/maths/Maths.cpp
+++ b/src/blitz/maths/Maths.cpp
@@ -5,20 +5,15 @@
 namespace blitz {
 namespace maths {

-Mat4f Perspective(float fovY, float invAspectRatio, float zNear, float zFar) {
-
-	static const float FRAC_PI_2 = 1.5707963267948966;
-
-	const float cotanHalfFovy = -std::tan(std::fmaf(fovY, 0.5f, FRAC_PI_2));
-
-	float neg_i_z_diff = -1.0f / (zFar - zNear);
+Mat4f Perspective(float fovY, float aspectRatio, float zNear, float zFar) {
+	const float tanHalfFovy = std::tan(fovY / 2.0f);

 	Mat4f result{};
-	result.x0 = cotanHalfFovy * invAspectRatio;
-	result.y1 = cotanHalfFovy;
-	result.z2 = (zFar + zNear) * neg_i_z_diff;
+	result.x0 = 1.0f / (aspectRatio * tanHalfFovy);
+	result.y1 = 1.0f / (tanHalfFovy);
+	result.z2 = -(zFar + zNear) / (zFar - zNear);
 	result.z3 = -1.0f;
-	result.w2 = 2.0f * zFar * zNear * neg_i_z_diff;
+	result.w2 = -(2.0f * zFar * zNear) / (zFar - zNear);

 	return result;
 }
@@ -64,7 +59,7 @@ Mat4f Inverse(const Mat4f& mat) {

 	assert(det != 0 && "Determinant equals 0 !");

-	float invdet = 1.0f / det;
+	float invdet = 1.0 / det;

 	Mat4f result;

@@ -176,13 +171,5 @@ Mat4f Rotate(float angle, Vec3f axis) {
 	return mat;
 }

-Vec3f GetDirectionVectorFromRotation(float yaw, float pitch) {
-	return {
-		std::cos(yaw) * std::cos(pitch),
-		std::sin(pitch),
-		std::sin(yaw) * std::cos(pitch),
-	};
-}
-
 }  // namespace maths
 }  // namespace blitz
--- a/src/blitz/maths/Physics.cpp
+++ b/src/blitz/maths/Physics.cpp
@@ -1,112 +1,67 @@
 #include "blitz/maths/Physics.h"
 #include "blitz/maths/Maths.h"
+
 #include <cmath>

 namespace blitz {
 namespace maths {

-AABB AABB::Enlarge(const AABB& with) const {
-	const Vec3f dir = 0.5f * (with.to - with.from);
+/**
+* @brief Returns `true` if the half-line `ray` _strictly_ intersects with `aabb`,
+*  and `false` if it _strictly_ doesn't intersect.
+*  Note that if it only intersects with corners, edges, or sides of the box, 
+*  or if any coordinate in `ray` is `NAN` or `inf` or if any coordinate in
+*  `aabb` is `NAN` the result is unspecified.
+ * */
+float Distance(const Ray& ray, const AABB& aabb) {

-	return AABB{
-		from - dir,
-		to + dir,
-	};
-}
-
-AABB AABB::Direct() const {
-	return AABB{Min(from, to), Max(from, to)};
-}
-
-Vec3f AABB::Center() const {
-	return (from + to) * 0.5f;
-}
-
-AABB AABB::operator+(const Vec3f& offset) const {
-	return AABB{from + offset, to + offset};
-}
-
-AABB AABB::operator+=(const Vec3f& offset) {
-	*this = *this + offset;
-	return *this;
-}
-
-bool AABB::OverlapsWith(const AABB& aabb) const {
-
-	return RangesOverlapping(from.x, to.x, aabb.from.x, aabb.to.x) && 
-		   RangesOverlapping(from.y, to.y, aabb.from.y, aabb.to.y) &&
-		   RangesOverlapping(from.z, to.z, aabb.from.z, aabb.to.z);
-}
-
-std::optional<IntersectionData> AABB::Intersection(const AABB& aabb, const Vec3f& dir) const {
-	return Ray { Center(), dir }.Intersection(aabb.Enlarge(*this));
-}
-
-Vec3f Ray::operator()(float t) const {
-	return FmaF(Vec3f::splat(t), direction, origin);
-}
-
-std::optional<IntersectionData> Ray::Intersection(const AABB& aabb) const {
-
-	// This function calculates smallest interval I = ] tmin, tmax [,
-	// such that for all t in I ray(t) is in the AABB, now, if tmin > tmax
-	// there is no such t, i.e. the ray never intersects with the AABB
+	// This function calculates smallest interval I = ] a, b [, for strictly positive a and b
+	// such that for all t in I, for all l, r, o, d corresponding
+	// coordinates in aabb.from, aabb.to, ray.origin, ray.direction, respectively
 	//
-	// and returns true if it's non-empty i.e. a < b
+	//	min(l, r) < o + t * d < max(l, r)
+	// 
+	// and returns true if it's non-empty i.e. a < b 

 	// m = min(l, r), M = max(l, r)
 	// m < o + t * d < M
-	AABB directed = aabb.Direct();
-	Vec3f& l = directed.from;
-	Vec3f& r = directed.to;
+	Vec3f l = Min(aabb.from, aabb.to);
+	Vec3f r = Max(aabb.to, aabb.from);

 	// m - o < t * d < M - o
-	l -= origin;
-	r -= origin;
+	l -= ray.origin;
+	r -= ray.origin;

 	// (m - o) / d < t < (M - o) / d
-	l /= direction;
-	r /= direction;
+	l /= ray.direction;
+	r /= ray.direction;

 	// but if d is negative the inequality is flipped
 	Vec3f u = Min(l, r);
 	r = Max(l, r);
 	l = u;

-	const float tmin = ReduceFMaxF(l);
-	const float tmax = ReduceFMinF(r);
+	float tmin = ReduceMax(l);
+	float tmax = ReduceMin(r);

-	// Since Min propagates NANs and ReduceFMinF doesn't, and since NAN != <any float>
-	// the inequality becomes ignored for coordinates where a NaN is involved
+	// Since Min propagates NANs and ReduceMin doesn't, and since NAN !< <any float>
+	// the inequality becomes ignored for coordinates where a NAN is involved
 	// (as a result of 0.0 / 0.0). If all coordinates are NAN, this means
 	// that the box is reduced to a point and the ray has direction 0,
-	// in which case this returns 0.0, which is technically the correct result
-	if (tmin <= tmax && tmax > 0.0f) {
-
-		Axis axis = Axis::aZ;
-		for (std::size_t i = 2; i >= 0; i--) {
-			Axis this_axis = Axis(i);
-			if (l[this_axis] == tmin) {
-				axis = this_axis;
-				break;
-			}
-		}
-
-		const float dist = std::fmaxf(0.0f, tmin);
-		return std::make_optional(IntersectionData { dist, axis });
+	// in which case this returns -1
+	if (tmax >= 0.0f && tmin <= tmax) {
+		return std::fmaxf(tmin, 0.0f);
 	}
-	return std::nullopt;
+
+	return -1.0f;
 }

-bool Ray::Intersects(const AABB& aabb) const {
-	auto data = Intersection(aabb);
-	return data.has_value() && data->distance >= 0.0f;
+bool Intersects(const AABB& aabb1, const AABB& aabb2) {
+	return false;
 }

-CollisionData IntersectionData::ToCollision(const Vec3f& dir) const {
-	Vec3f new_dir = dir;
-	new_dir[axis] = 0.0f;
-	return CollisionData{dir * (distance - 0.07f), new_dir * (1.0f - distance)};
+bool Intersects(const Ray& ray, const AABB& aabb) {
+	return Distance(ray, aabb) >= 0.0f;
 }

 }  // namespace maths
--- a/src/blitz/misc/Compression.cpp
+++ b/src/blitz/misc/Compression.cpp
@@ -14,7 +14,7 @@ static DataBuffer Inflate(const std::uint8_t* source, std::size_t size, std::siz
 	result.Resize(uncompressedSize);

 	uncompress(reinterpret_cast<Bytef*>(result.data()), reinterpret_cast<uLongf*>(&uncompressedSize),
-		reinterpret_cast<const Bytef*>(source), static_cast<uLong>(size));
+		reinterpret_cast<const Bytef*>(source), size);

 	assert(result.GetSize() == uncompressedSize);
 	return result;
@@ -22,11 +22,10 @@ static DataBuffer Inflate(const std::uint8_t* source, std::size_t size, std::siz

 static DataBuffer Deflate(const std::uint8_t* source, std::size_t size) {
 	DataBuffer result;
-	uLongf compressedSize = size;
+	uLongf compressedSize;

 	result.Resize(size);  // Resize for the compressed data to fit into
-	compress(
-		reinterpret_cast<Bytef*>(result.data()), &compressedSize, reinterpret_cast<const Bytef*>(source), static_cast<uLong>(size));
+	compress(reinterpret_cast<Bytef*>(result.data()), &compressedSize, reinterpret_cast<const Bytef*>(source), size);
 	result.Resize(compressedSize);	// Resize to cut useless data

 	return result;
--- a/src/blitz/misc/Easing.cpp
+++ b/src/blitz/misc/Easing.cpp
@@ -10,126 +10,122 @@ namespace utils {
 /* Sine functions */

 float EaseInSine(float x) {
-	return static_cast<float>(1.0 - std::cos((x * maths::PI) / 2.0));
+	return 1.0f - std::cos((x * maths::PI) / 2.0f);
 }

 float EaseOutSine(float x) {
-	return static_cast<float>(std::sin((x * maths::PI) / 2.0));
+	return std::sin((x * maths::PI) / 2.0f);
 }

 float EaseInOutSine(float x) {
-	return static_cast<float>(-(std::cos(maths::PI * x) - 1.0) / 2.0);
+	return -(std::cos(maths::PI * x) - 1.0f) / 2.0f;
 }

 /* Cubic functions */

 float EaseInCubic(float x) {
-	return static_cast<float>(x * EaseInQuad(x));
+	return x * EaseInQuad(x);
 }

 float EaseOutCubic(float x) {
-	return static_cast<float>(1 - std::pow(1 - x, 3));
+	return 1 - std::pow(1 - x, 3);
 }

 float EaseInOutCubic(float x) {
-	return x < 0.5f ? 4.0f * EaseInCubic(x) : 1.0f - std::pow(-2.0f * x + 2.0f, 3.0f) / 2.0f;
+	return x < 0.5 ? 4 * EaseInCubic(x) : 1 - std::pow(-2 * x + 2, 3) / 2.0f;
 }

 /* Quint functions */

 float EaseInQuint(float x) {
-	return static_cast<float>(x * EaseInQuart(x));
+	return x * EaseInQuart(x);
 }

 float EaseOutQuint(float x) {
-	return static_cast<float>(1 - std::pow(1 - x, 5));
+	return 1 - std::pow(1 - x, 5);
 }

 float EaseInOutQuint(float x) {
-	return static_cast<float>(x < 0.5 ? 16 * EaseInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0);
+	return x < 0.5 ? 16 * EaseInQuint(x) : 1 - std::pow(-2 * x + 2, 5) / 2.0f;
 }

 /* Circ functions */

 float EaseInCirc(float x) {
-	return static_cast<float>(1 - std::sqrt(1 - std::pow(x, 2)));
+	return 1 - std::sqrt(1 - std::pow(x, 2));
 }

 float EaseOutCirc(float x) {
-	return static_cast<float>(std::sqrt(1 - std::pow(x - 1, 2)));
+	return std::sqrt(1 - std::pow(x - 1, 2));
 }

 float EaseInOutCirc(float x) {
-	return x < 0.5f ? (1.0f - std::sqrt(1.0f - std::pow(2.0f * x, 2.0f))) / 2.0f
-					: (std::sqrt(1.0f - std::pow(-2.0f * x + 2.0f, 2.0f)) + 1.0f) / 2.0f;
+	return x < 0.5 ? (1 - std::sqrt(1 - std::pow(2 * x, 2))) / 2.0f : (std::sqrt(1 - std::pow(-2 * x + 2, 2)) + 1) / 2.0f;
 }

 /* Elastic functions */

 float EaseInElastic(float x) {
-	const float c4 = (2 * maths::PI) / 3.0;
+	const float c4 = (2 * maths::PI) / 3.0f;

-	return static_cast<float>(x == 0 ? 0 : x == 1 ? 1 : -std::pow(2, 10 * x - 10) * std::sin((x * 10 - 10.75) * c4));
+	return x == 0 ? 0 : x == 1 ? 1 : -std::pow(2, 10 * x - 10) * std::sin((x * 10 - 10.75) * c4);
 }

 float EaseOutElastic(float x) {
-	const float c4 = (2 * maths::PI) / 3.0;
+	const float c4 = (2 * maths::PI) / 3.0f;

-	return static_cast<float>(x == 0 ? 0 : x == 1 ? 1 : std::pow(2, -10 * x) * std::sin((x * 10 - 0.75) * c4) + 1);
+	return x == 0 ? 0 : x == 1 ? 1 : std::pow(2, -10 * x) * std::sin((x * 10 - 0.75) * c4) + 1;
 }

 float EaseInOutElastic(float x) {
 	const float c5 = (2 * maths::PI) / 4.5;

-	return static_cast<float>(x == 0	? 0
-							  : x == 1	? 1
-							  : x < 0.5 ? -(std::pow(2, 20 * x - 10) * std::sin((20 * x - 11.125) * c5)) / 2.0
-										: (std::pow(2, -20 * x + 10) * std::sin((20 * x - 11.125) * c5)) / 2.0 + 1);
+	return x == 0	 ? 0
+		   : x == 1	 ? 1
+		   : x < 0.5 ? -(std::pow(2, 20 * x - 10) * std::sin((20 * x - 11.125) * c5)) / 2.0f
+					 : (std::pow(2, -20 * x + 10) * std::sin((20 * x - 11.125) * c5)) / 2.0f + 1;
 }

 /* Quad functions */

 float EaseInQuad(float x) {
-	return static_cast<float>(x * x);
+	return x * x;
 }

 float EaseOutQuad(float x) {
-	return static_cast<float>(1 - (1 - x) * (1 - x));
+	return 1 - (1 - x) * (1 - x);
 }

 float EaseInOutQuad(float x) {
-	return static_cast<float>(x < 0.5 ? 2 * x * x : 1 - std::pow(-2 * x + 2, 2) / 2.0);
+	return x < 0.5 ? 2 * x * x : 1 - std::pow(-2 * x + 2, 2) / 2.0f;
 }

 /* Quart functions */

 float EaseInQuart(float x) {
-	return static_cast<float>(x * EaseInCubic(x));
+	return x * EaseInCubic(x);
 }

 float EaseOutQuart(float x) {
-	return static_cast<float>(1 - std::pow(1 - x, 4));
+	return 1 - std::pow(1 - x, 4);
 }

 float EaseInOutQuart(float x) {
-	return static_cast<float>(x < 0.5 ? 8 * EaseInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0);
+	return x < 0.5 ? 8 * EaseInQuart(x) : 1 - std::pow(-2 * x + 2, 4) / 2.0f;
 }

 /* Expo functions */

 float EaseInExpo(float x) {
-	return static_cast<float>(x == 0 ? 0 : std::pow(2, 10 * x - 10));
+	return x == 0 ? 0 : std::pow(2, 10 * x - 10);
 }

 float EaseOutExpo(float x) {
-	return static_cast<float>(x == 1 ? 1 : 1 - std::pow(2, -10 * x));
+	return x == 1 ? 1 : 1 - std::pow(2, -10 * x);
 }

 float EaseInOutExpo(float x) {
-	return static_cast<float>(x == 0	? 0
-							  : x == 1	? 1
-							  : x < 0.5 ? std::pow(2, 20 * x - 10) / 2.0
-										: (2 - std::pow(2, -20 * x + 10)) / 2.0);
+	return x == 0 ? 0 : x == 1 ? 1 : x < 0.5 ? std::pow(2, 20 * x - 10) / 2.0f : (2 - std::pow(2, -20 * x + 10)) / 2.0f;
 }

 /* Back functions */
@@ -138,28 +134,28 @@ float EaseInBack(float x) {
 	const float c1 = 1.70158;
 	const float c3 = c1 + 1;

-	return static_cast<float>(c3 * EaseInCubic(x) - c1 * EaseInQuad(x));
+	return c3 * EaseInCubic(x) - c1 * EaseInQuad(x);
 }

 float EaseOutBack(float x) {
 	const float c1 = 1.70158;
 	const float c3 = c1 + 1;

-	return static_cast<float>(1 + c3 * std::pow(x - 1, 3) + c1 * std::pow(x - 1, 2));
+	return 1 + c3 * std::pow(x - 1, 3) + c1 * std::pow(x - 1, 2);
 }

 float EaseInOutBack(float x) {
 	const float c1 = 1.70158;
 	const float c2 = c1 * 1.525;

-	return static_cast<float>(x < 0.5 ? (std::pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2.0
-									  : (std::pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2.0);
+	return x < 0.5 ? (std::pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2.0f
+				   : (std::pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2.0f;
 }

 /* Bounce functions */

 float EaseInBounce(float x) {
-	return static_cast<float>(1 - EaseOutBounce(1 - x));
+	return 1 - EaseOutBounce(1 - x);
 }

 float EaseOutBounce(float x) {
@@ -167,21 +163,21 @@ float EaseOutBounce(float x) {
 	const float d1 = 2.75;

 	if (x < 1 / d1) {
-		return static_cast<float>(n1 * EaseInQuad(x));
+		return n1 * EaseInQuad(x);
 	} else if (x < 2 / d1) {
 		x -= 1.5;
-		return static_cast<float>(n1 * (x / d1) * x + 0.75);
+		return n1 * (x / d1) * x + 0.75;
 	} else if (x < 2.5 / d1) {
 		x -= 2.25;
-		return static_cast<float>(n1 * (x / d1) * x + 0.9375);
+		return n1 * (x / d1) * x + 0.9375;
 	} else {
 		x -= 2.625;
-		return static_cast<float>(n1 * (x / d1) * x + 0.984375);
+		return n1 * (x / d1) * x + 0.984375;
 	}
 }

 float EaseInOutBounce(float x) {
-	return static_cast<float>(x < 0.5 ? (1 - EaseOutBounce(1 - 2 * x)) / 2.0 : (1 + EaseOutBounce(2 * x - 1)) / 2.0);
+	return x < 0.5 ? (1 - EaseOutBounce(1 - 2 * x)) / 2.0f : (1 + EaseOutBounce(2 * x - 1)) / 2.0f;
 }

 }  // namespace utils
--- a/src/blitz/misc/Log.cpp
+++ b/src/blitz/misc/Log.cpp
@@ -1,6 +1,8 @@
 #include "blitz/misc/Log.h"

-
+#if defined(__ANDROID__) and not defined(BLITZ_HEADLESS)
+#define BLITZ_ANDROID_LOGGING
+#endif

 #ifdef BLITZ_ANDROID_LOGGING
 #include <android/log.h>
--- a/src/blitz/misc/TickCounter.cpp
+++ b/src/blitz/misc/TickCounter.cpp
@@ -6,7 +6,7 @@ namespace blitz {
 namespace utils {

 void TickCounter::Reset() {
-	m_TPS = static_cast<float>(m_TargetTPS);
+	m_TPS = m_TargetTPS;
 	m_LastTPSTime = utils::GetTime();
 	m_TickCount = 0;
 }
--- a/src/blitz/network/Network.cpp
+++ b/src/blitz/network/Network.cpp
@@ -1,17 +1,10 @@
 #include "blitz/network/Network.h"

 #include "blitz/misc/Log.h"
-#include <signal.h>
-

 namespace blitz {
 namespace network {

-/* Catch Signal Handler function */
-void signal_callback_handler(int signum) {
-	utils::LOGD("[Network] Caught a SIGPIPE !");
-}
-
 #ifdef _WIN32
 NetworkInitializer::NetworkInitializer() {
 	WSADATA wsaData;
@@ -25,10 +18,7 @@ NetworkInitializer::~NetworkInitializer() {
 	WSACleanup();
 }
 #else
-NetworkInitializer::NetworkInitializer() {
-	/* Prevents the game for crashing when socket closes on the other side */
-	signal(SIGPIPE, signal_callback_handler);
-}
+NetworkInitializer::NetworkInitializer() {}
 NetworkInitializer::~NetworkInitializer() {}
 #endif

--- a/src/blitz/network/TCPListener.cpp
+++ b/src/blitz/network/TCPListener.cpp
@@ -11,14 +11,14 @@
 namespace blitz {
 namespace network {

-TCPListener::TCPListener() : m_Handle(static_cast<blitz::network::SocketHandle>(INVALID_SOCKET)), m_Port(0), m_MaxConnections(0) {}
+TCPListener::TCPListener() : m_Handle(INVALID_SOCKET), m_Port(0), m_MaxConnections(0) {}

 TCPListener::~TCPListener() {
 	Destroy();
 }

 bool TCPListener::Listen(std::uint16_t port, int maxConnections) {
-	if ((m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))) < 0) {
+	if ((m_Handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
 		utils::LOGE("[TCPListener] Failed to create server socket !");
 		return false;
 	}
@@ -47,8 +47,8 @@ bool TCPListener::Listen(std::uint16_t port, int maxConnections) {
 bool TCPListener::Accept(TCPSocket& newSocket) {
 	int addrlen = sizeof(newSocket.m_RemoteAddr);

-	newSocket.m_Handle = static_cast<SocketHandle>(
-		accept(m_Handle, reinterpret_cast<sockaddr*>(&newSocket.m_RemoteAddr), reinterpret_cast<socklen_t*>(&addrlen)));
+	newSocket.m_Handle =
+		accept(m_Handle, reinterpret_cast<sockaddr*>(&newSocket.m_RemoteAddr), reinterpret_cast<socklen_t*>(&addrlen));

 	if (newSocket.m_Handle < 0)
 		return false;
--- a/src/blitz/network/TCPSocket.cpp
+++ b/src/blitz/network/TCPSocket.cpp
@@ -83,7 +83,7 @@ bool TCPSocket::Connect(const std::string& host, unsigned short port) {
 		return false;
 	}

-	m_Handle = static_cast<SocketHandle>(socket(AF_INET, SOCK_STREAM, IPPROTO_TCP));
+	m_Handle = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 	if (m_Handle < 0) {
 		utils::LOGE("[TCPSocket] Failed to create socket !");
 		return false;
@@ -120,16 +120,14 @@ size_t TCPSocket::Send(const unsigned char* data, size_t size) {
 	std::size_t sent = 0;

 	while (sent < size) {
-		int cur = send(m_Handle, reinterpret_cast<const char*>(data + sent), static_cast<int>(size - sent), 0);
-
+		int cur = send(m_Handle, reinterpret_cast<const char*>(data + sent), size - sent, 0);
 		if (cur <= 0) {
-			m_Status = Status::Error;
 			Disconnect();
-			m_Status = Status::Error;
 			return 0;
 		}
 		sent += static_cast<std::size_t>(cur);
 	}
+
 	return sent;
 }

@@ -137,7 +135,7 @@ std::size_t TCPSocket::Receive(DataBuffer& buffer, std::size_t amount) {
 	buffer.Resize(amount);
 	buffer.SetReadOffset(0);

-	int recvAmount = recv(m_Handle, reinterpret_cast<char*>(buffer.data()), static_cast<int>(amount), 0);
+	int recvAmount = recv(m_Handle, reinterpret_cast<char*>(buffer.data()), amount, 0);
 	if (recvAmount <= 0) {
 #if defined(_WIN32) || defined(WIN32)
 		int err = WSAGetLastError();
@@ -151,7 +149,6 @@ std::size_t TCPSocket::Receive(DataBuffer& buffer, std::size_t amount) {

 		Disconnect();
 		buffer.Clear();
-		m_Status = Status::Error;
 		return 0;
 	}
 	buffer.Resize(static_cast<std::size_t>(recvAmount));
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Morph01	6ab9126cd7	Add mouse speed setting to BlitzConfig All checks were successful Linux arm64 / Build (push) Successful in 4m49s Details	2024-03-29 22:08:18 +01:00
Persson-dev	0f0d2cb5e0	Merge branch 'gui' of git.ale-pri.com:Blitz/Blitz into gui All checks were successful Linux arm64 / Build (push) Successful in 4m46s Details	2024-03-26 12:51:49 +01:00
Persson-dev	d5c52e8626	Merge branch 'main' into gui	2024-03-26 12:51:08 +01:00
Morph01	e16cea7214	timer and leaderboard Some checks failed Linux arm64 / Build (push) Failing after 4m53s Details	2024-03-26 12:38:20 +01:00
Persson-dev	42a37abe45	im stupid Some checks failed Linux arm64 / Build (push) Failing after 4m30s Details	2024-03-26 10:42:18 +01:00
Persson-dev	fdc0d69605	update shoot on death Some checks failed Linux arm64 / Build (push) Has been cancelled Details	2024-03-26 10:40:32 +01:00
Persson-dev	c115602419	Merge branch 'stats' into gui Some checks failed Linux arm64 / Build (push) Has been cancelled Details	2024-03-26 10:35:34 +01:00
Persson-dev	4590672b36	add PlayerStatsPacket Some checks failed Linux arm64 / Build (push) Failing after 4m28s Details	2024-03-26 10:35:05 +01:00
Persson-dev	f79c65a563	fix merge Some checks failed Linux arm64 / Build (push) Failing after 4m29s Details	2024-03-26 09:44:44 +01:00
Persson-dev	da76ae3d33	Merge branch 'gui' of git.ale-pri.com:Blitz/Blitz into gui Some checks failed Linux arm64 / Build (push) Failing after 2m40s Details	2024-03-26 09:39:27 +01:00
Persson-dev	ad389aa576	Merge branch 'dev' into gui	2024-03-26 09:38:59 +01:00
Morph01	bd517c6cfe	fix retour / quitter button All checks were successful Linux arm64 / Build (push) Successful in 4m35s Details	2024-03-26 09:32:07 +01:00
Morph01	63c33e4bc5	simple leaderboard All checks were successful Linux arm64 / Build (push) Successful in 4m34s Details	2024-03-22 09:13:17 +01:00
Persson-dev	bea98cbe45	fix merge All checks were successful Linux arm64 / Build (push) Successful in 8m2s Details	2024-03-20 16:59:31 +01:00
Simon Pribylski	bc84906b56	remove old KeyAction Some checks failed Linux arm64 / Build (push) Failing after 6m47s Details	2024-03-20 16:40:10 +01:00
Morph01	292fac185d	Squashed commit of the following: Some checks failed Linux arm64 / Build (push) Failing after 2m48s Details commit `2b0930a734` Author: Morph01 <thibaut6969delastreet@gmail.com> Date: Tue Mar 19 10:43:55 2024 +0100 hud of blitz (#16) Résoudre partiellement #12 Co-authored-by: Persson-dev <sim16.prib@gmail.com> Co-authored-by: Morph01 <145839520+Morph01@users.noreply.github.com> Co-authored-by: Simon Pribylski <sim16.prib@gmail.com> Reviewed-on: #16 commit `84b6acad4c` Author: Persson-dev <sim16.prib@gmail.com> Date: Tue Mar 19 10:15:54 2024 +0100 less spooky light commit `9f94d51fc4` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 14 16:36:15 2024 +0100 Ajout de tests d'intégration (#17) Le paquet fournissant OpenGL a été temporairement remplacé par glew Reviewed-on: #17 Co-authored-by: Persson-dev <sim16.prib@gmail.com> Co-committed-by: Persson-dev <sim16.prib@gmail.com> commit `9951256881` Author: Simon Pribylski <sim16.prib@gmail.com> Date: Wed Mar 13 20:19:37 2024 +0100 action: install libsdl via apt commit `4a02054648` Author: Morph01 <145839520+Morph01@users.noreply.github.com> Date: Wed Mar 13 13:53:20 2024 +0100 compression tests commit `19c39312bf` Author: Morph01 <145839520+Morph01@users.noreply.github.com> Date: Wed Mar 13 13:51:57 2024 +0100 setup action commit `d5014b1e8a` Author: Persson-dev <sim16.prib@gmail.com> Date: Tue Mar 12 10:26:47 2024 +0100 Revert "extend Vec3" This reverts commit `dccfa9c936`. commit `dccfa9c936` Author: = <=> Date: Tue Mar 12 10:01:00 2024 +0100 extend Vec3 commit `e39fc8aa70` Author: Simon Pribylski <sim16.prib@gmail.com> Date: Tue Mar 12 08:55:49 2024 +0100 Star Wars (#14) Reviewed-on: #14 commit `d42f67724d` Author: AquaEBM <AquaEBM@gmail.com> Date: Tue Mar 12 08:32:53 2024 +0100 fix error commit `71bc4dd249` Author: Persson-dev <sim16.prib@gmail.com> Date: Sat Mar 9 18:37:54 2024 +0100 add keybindings (#13) Co-authored-by: Morph01 <thibaut6969delastreet@gmail.com> Reviewed-on: #13 Co-authored-by: Persson-dev <sim16.prib@gmail.com> Co-committed-by: Persson-dev <sim16.prib@gmail.com> commit `2cb5074140` Author: Persson-dev <sim16.prib@gmail.com> Date: Sat Mar 9 11:01:30 2024 +0100 better server logs commit `269ac16d28` Author: Persson-dev <sim16.prib@gmail.com> Date: Fri Mar 8 22:59:50 2024 +0100 more precise logging commit `b7926d7a98` Author: Persson-dev <sim16.prib@gmail.com> Date: Fri Mar 8 22:57:38 2024 +0100 pretty log commit `52da1cf19b` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 23:10:37 2024 +0100 explicit server in logs commit `2da89c8dab` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 21:12:41 2024 +0100 xmake: remove global include commit `88cb433ecf` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 21:03:23 2024 +0100 xmake: relative paths commit `d96b01074e` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 20:50:14 2024 +0100 split xmake targets commit `a1effa05cd` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 20:14:12 2024 +0100 remove github ci commit `7b58117f36` Author: Persson-dev <sim16.prib@gmail.com> Date: Thu Mar 7 20:13:05 2024 +0100 fix warnings commit `bf8a6458a0` Author: Persson-dev <sim16.prib@gmail.com> Date: Tue Mar 5 12:30:09 2024 +0100 valgrind full info commit `18ddede8c0` Author: Persson-dev <sim16.prib@gmail.com> Date: Tue Mar 5 12:29:39 2024 +0100 add shoot	2024-03-19 12:14:46 +01:00
Morph01	b2ecc690c2	repositioning the back and exit buttons	2024-03-10 17:40:57 +01:00
Morph01	80dbd73bfb	keybind change works in game	2024-03-09 14:47:18 +01:00
Persson-dev	4399787209	fix windows build	2024-03-08 19:59:41 +01:00
Persson-dev	25fe2eb6d5	fix warnings	2024-03-08 19:53:25 +01:00
Morph01	9c5e788ee0	hotkey save	2024-03-07 15:31:24 +01:00
Morph01	f28eb338d7	add title bar in option menu and a hotkey binding interface	2024-03-05 12:18:45 +01:00
Morph01	fdd0b185ac	Revert "add getkeyname" This reverts commit `49ca6043bf`.	2024-03-05 10:50:08 +01:00
Persson-dev	49ca6043bf	add getkeyname	2024-03-05 10:45:08 +01:00