From 6825a6327fc63c5c16f73132c5082fdd9ecb9646 Mon Sep 17 00:00:00 2001
From: Persson-dev <sim16.prib@gmail.com>
Date: Sat, 6 Nov 2021 13:02:53 +0100
Subject: [PATCH] refactor: use of unique_ptr instead of new

---
 include/game/Connexion.h              |  2 +-
 include/game/client/ClientConnexion.h |  8 ++--
 include/game/client/ClientGame.h      | 22 +++++------
 include/game/client/WorldClient.h     |  8 ++--
 include/game/server/Server.h          |  2 +-
 include/game/server/ServerConnexion.h | 14 +++----
 include/protocol/PacketDispatcher.h   |  2 +-
 include/protocol/PacketFactory.h      |  2 +-
 include/protocol/PacketHandler.h      | 44 +++++++++++-----------
 include/protocol/Protocol.h           | 53 ++++++++++++++-------------
 src/game/Connexion.cpp                |  5 +--
 src/game/client/ClientConnexion.cpp   |  8 ++--
 src/game/client/ClientGame.cpp        | 22 +++++------
 src/game/client/WorldClient.cpp       |  8 ++--
 src/game/server/Server.cpp            |  2 +-
 src/game/server/ServerConnexion.cpp   | 14 +++----
 src/protocol/PacketDispatcher.cpp     |  2 +-
 src/protocol/PacketFactory.cpp        | 50 ++++++++++++-------------
 src/protocol/Protocol.cpp             |  2 +-
 19 files changed, 136 insertions(+), 134 deletions(-)

diff --git a/include/game/Connexion.h b/include/game/Connexion.h
index 7578b49..ace2138 100644
--- a/include/game/Connexion.h
+++ b/include/game/Connexion.h
@@ -27,7 +27,7 @@ public:
 
     network::Socket::Status getSocketStatus() const { return m_Socket.GetStatus(); }
 
-    void sendPacket(protocol::Packet* packet);
+    void sendPacket(const protocol::Packet* packet);
 
     REMOVE_COPY(Connexion);
 };
diff --git a/include/game/client/ClientConnexion.h b/include/game/client/ClientConnexion.h
index a7e1869..669ee9d 100644
--- a/include/game/client/ClientConnexion.h
+++ b/include/game/client/ClientConnexion.h
@@ -18,10 +18,10 @@ public:
 
     virtual bool updateSocket();
 
-    virtual void HandlePacket(protocol::KeepAlivePacket* packet);
-    virtual void HandlePacket(protocol::ConnexionInfoPacket* packet);
-    virtual void HandlePacket(protocol::DisconnectPacket* packet);
-    virtual void HandlePacket(protocol::ServerTpsPacket* packet);
+    virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
+    virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
+    virtual void HandlePacket(const protocol::DisconnectPacket* packet);
+    virtual void HandlePacket(const protocol::ServerTpsPacket* packet);
 
     const std::string& getDisconnectReason() const { return m_DisconnectReason; }
     float getServerTPS() const { return m_ServerTPS; }
diff --git a/include/game/client/ClientGame.h b/include/game/client/ClientGame.h
index 6ce81a8..9663e06 100644
--- a/include/game/client/ClientGame.h
+++ b/include/game/client/ClientGame.h
@@ -39,17 +39,17 @@ public:
 
     void PlaceTower(game::TowerType type, const glm::vec2& position);
 
-    virtual void HandlePacket(protocol::ConnexionInfoPacket* packet);
-    virtual void HandlePacket(protocol::PlayerJoinPacket* packet);
-    virtual void HandlePacket(protocol::PlayerLeavePacket* packet);
-    virtual void HandlePacket(protocol::PlayerListPacket* packet);
-    virtual void HandlePacket(protocol::UpdatePlayerTeamPacket* packet);
-    virtual void HandlePacket(protocol::UpdateGameStatePacket* packet);
-    virtual void HandlePacket(protocol::UpdateLobbyTimePacket* packet);
-    virtual void HandlePacket(protocol::UpdateMoneyPacket* packet);
-    virtual void HandlePacket(protocol::DisconnectPacket* packet);
-    virtual void HandlePacket(protocol::WorldDataPacket* packet);
-    virtual void HandlePacket(protocol::WorldAddTowerPacket* packet);
+    virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
+    virtual void HandlePacket(const protocol::PlayerJoinPacket* packet);
+    virtual void HandlePacket(const protocol::PlayerLeavePacket* packet);
+    virtual void HandlePacket(const protocol::PlayerListPacket* packet);
+    virtual void HandlePacket(const protocol::UpdatePlayerTeamPacket* packet);
+    virtual void HandlePacket(const protocol::UpdateGameStatePacket* packet);
+    virtual void HandlePacket(const protocol::UpdateLobbyTimePacket* packet);
+    virtual void HandlePacket(const protocol::UpdateMoneyPacket* packet);
+    virtual void HandlePacket(const protocol::DisconnectPacket* packet);
+    virtual void HandlePacket(const protocol::WorldDataPacket* packet);
+    virtual void HandlePacket(const protocol::WorldAddTowerPacket* packet);
 };
 
 } // namespace client
diff --git a/include/game/client/WorldClient.h b/include/game/client/WorldClient.h
index c9121e6..ca0df32 100644
--- a/include/game/client/WorldClient.h
+++ b/include/game/client/WorldClient.h
@@ -14,10 +14,10 @@ private:
 public:
     WorldClient(ClientGame* game);
 
-    virtual void HandlePacket(protocol::WorldBeginDataPacket* packet) override;
-    virtual void HandlePacket(protocol::WorldDataPacket* packet) override;
-    virtual void HandlePacket(protocol::SpawnMobPacket* packet) override;
-    virtual void HandlePacket(protocol::UpgradeTowerPacket* packet) override;
+    virtual void HandlePacket(const protocol::WorldBeginDataPacket* packet) override;
+    virtual void HandlePacket(const protocol::WorldDataPacket* packet) override;
+    virtual void HandlePacket(const protocol::SpawnMobPacket* packet) override;
+    virtual void HandlePacket(const protocol::UpgradeTowerPacket* packet) override;
 
     virtual void OnArrowShot(game::MobPtr target, game::Tower* shooter) override;
 };
diff --git a/include/game/server/Server.h b/include/game/server/Server.h
index 5c6fdff..dfff91d 100644
--- a/include/game/server/Server.h
+++ b/include/game/server/Server.h
@@ -70,7 +70,7 @@ public:
 
     void removeConnexion(std::uint8_t connexionID);
 
-    void broadcastPacket(protocol::Packet* packet);
+    void broadcastPacket(const protocol::Packet* packet);
 
     float getTPS() const { return m_TickCounter.getTPS(); }
 
diff --git a/include/game/server/ServerConnexion.h b/include/game/server/ServerConnexion.h
index e97015b..e4ff39e 100644
--- a/include/game/server/ServerConnexion.h
+++ b/include/game/server/ServerConnexion.h
@@ -33,13 +33,13 @@ public:
 
     void setServer(Server* server);
 
-    virtual void HandlePacket(protocol::PlayerLoginPacket* packet);
-    virtual void HandlePacket(protocol::KeepAlivePacket* packet);
-    virtual void HandlePacket(protocol::SelectTeamPacket* packet);
-    virtual void HandlePacket(protocol::DisconnectPacket* packet);
-    virtual void HandlePacket(protocol::PlaceTowerPacket* packet);
-    virtual void HandlePacket(protocol::SendMobsPacket* packet);
-    virtual void HandlePacket(protocol::UpgradeTowerPacket* packet);
+    virtual void HandlePacket(const protocol::PlayerLoginPacket* packet);
+    virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
+    virtual void HandlePacket(const protocol::SelectTeamPacket* packet);
+    virtual void HandlePacket(const protocol::DisconnectPacket* packet);
+    virtual void HandlePacket(const protocol::PlaceTowerPacket* packet);
+    virtual void HandlePacket(const protocol::SendMobsPacket* packet);
+    virtual void HandlePacket(const protocol::UpgradeTowerPacket* packet);
 
     std::uint8_t getID() const { return m_ID; }
     const game::Player* getPlayer() const { return m_Player; }
diff --git a/include/protocol/PacketDispatcher.h b/include/protocol/PacketDispatcher.h
index edda9be..57ea40a 100644
--- a/include/protocol/PacketDispatcher.h
+++ b/include/protocol/PacketDispatcher.h
@@ -22,7 +22,7 @@ public:
     PacketDispatcher(PacketDispatcher&& rhs) = delete;
     PacketDispatcher& operator=(PacketDispatcher&& rhs) = delete;
 
-    void Dispatch(Packet* packet);
+    void Dispatch(const PacketPtr& packet);
 
     void RegisterHandler(PacketType type, PacketHandler* handler);
     void UnregisterHandler(PacketType type, PacketHandler* handler);
diff --git a/include/protocol/PacketFactory.h b/include/protocol/PacketFactory.h
index 409a206..9ba9fe0 100644
--- a/include/protocol/PacketFactory.h
+++ b/include/protocol/PacketFactory.h
@@ -6,7 +6,7 @@ namespace td {
 namespace protocol {
 namespace PacketFactory {
 
-Packet* createPacket(PacketType type, DataBuffer& buffer);
+PacketPtr createPacket(PacketType type, DataBuffer& buffer);
 
 }
 } // namespace protocol
diff --git a/include/protocol/PacketHandler.h b/include/protocol/PacketHandler.h
index 5470a41..a4870b9 100644
--- a/include/protocol/PacketHandler.h
+++ b/include/protocol/PacketHandler.h
@@ -16,28 +16,28 @@ public:
 
     PacketDispatcher* GetDispatcher() { return m_Dispatcher; }
 
-    virtual void HandlePacket(PlayerLoginPacket* packet) {}
-    virtual void HandlePacket(WorldBeginDataPacket* packet) {}
-    virtual void HandlePacket(WorldDataPacket* packet) {}
-    virtual void HandlePacket(KeepAlivePacket* packet) {}
-    virtual void HandlePacket(UpdateMoneyPacket* packet) {}
-    virtual void HandlePacket(UpdateExpPacket* packet) {}
-    virtual void HandlePacket(UpdateLobbyTimePacket* packet) {}
-    virtual void HandlePacket(UpdateGameStatePacket* packet) {}
-    virtual void HandlePacket(PlayerListPacket* packet) {}
-    virtual void HandlePacket(PlayerJoinPacket* packet) {}
-    virtual void HandlePacket(PlayerLeavePacket* packet) {}
-    virtual void HandlePacket(ConnexionInfoPacket* packet) {}
-    virtual void HandlePacket(SelectTeamPacket* packet) {}
-    virtual void HandlePacket(UpdatePlayerTeamPacket* packet) {}
-    virtual void HandlePacket(DisconnectPacket* packet) {}
-    virtual void HandlePacket(ServerTpsPacket* packet) {}
-    virtual void HandlePacket(SpawnMobPacket* packet) {}
-    virtual void HandlePacket(PlaceTowerPacket* packet) {}
-    virtual void HandlePacket(WorldAddTowerPacket* packet) {}
-    virtual void HandlePacket(WorldRemoveTowerPacket* packet) {}
-    virtual void HandlePacket(SendMobsPacket* packet) {}
-    virtual void HandlePacket(UpgradeTowerPacket* packet) {}
+    virtual void HandlePacket(const PlayerLoginPacket* packet) {}
+    virtual void HandlePacket(const WorldBeginDataPacket* packet) {}
+    virtual void HandlePacket(const WorldDataPacket* packet) {}
+    virtual void HandlePacket(const KeepAlivePacket* packet) {}
+    virtual void HandlePacket(const UpdateMoneyPacket* packet) {}
+    virtual void HandlePacket(const UpdateExpPacket* packet) {}
+    virtual void HandlePacket(const UpdateLobbyTimePacket* packet) {}
+    virtual void HandlePacket(const UpdateGameStatePacket* packet) {}
+    virtual void HandlePacket(const PlayerListPacket* packet) {}
+    virtual void HandlePacket(const PlayerJoinPacket* packet) {}
+    virtual void HandlePacket(const PlayerLeavePacket* packet) {}
+    virtual void HandlePacket(const ConnexionInfoPacket* packet) {}
+    virtual void HandlePacket(const SelectTeamPacket* packet) {}
+    virtual void HandlePacket(const UpdatePlayerTeamPacket* packet) {}
+    virtual void HandlePacket(const DisconnectPacket* packet) {}
+    virtual void HandlePacket(const ServerTpsPacket* packet) {}
+    virtual void HandlePacket(const SpawnMobPacket* packet) {}
+    virtual void HandlePacket(const PlaceTowerPacket* packet) {}
+    virtual void HandlePacket(const WorldAddTowerPacket* packet) {}
+    virtual void HandlePacket(const WorldRemoveTowerPacket* packet) {}
+    virtual void HandlePacket(const SendMobsPacket* packet) {}
+    virtual void HandlePacket(const UpgradeTowerPacket* packet) {}
 };
 
 } // namespace protocol
diff --git a/include/protocol/Protocol.h b/include/protocol/Protocol.h
index fc4a36c..20ac731 100644
--- a/include/protocol/Protocol.h
+++ b/include/protocol/Protocol.h
@@ -4,6 +4,8 @@
 #include "game/World.h"
 #include "game/BaseGame.h"
 
+#include <memory>
+
 namespace td {
 namespace protocol {
 
@@ -65,12 +67,13 @@ public:
 
     virtual DataBuffer Serialize() const = 0;
     virtual void Deserialize(DataBuffer& data) = 0;
-    virtual void Dispatch(PacketHandler* handler) = 0;
+    virtual void Dispatch(PacketHandler* handler) const = 0;
 
     virtual PacketType getType() const = 0;
     std::uint8_t getID() const { return (std::uint8_t)getType(); }
 };
 
+typedef std::unique_ptr<Packet> PacketPtr;
 
 class KeepAlivePacket : public Packet {
 private:
@@ -82,9 +85,9 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
-    std::uint64_t getAliveID() { return m_AliveID; }
+    std::uint64_t getAliveID() const { return m_AliveID; }
 
     virtual PacketType getType() const { return PacketType::KeepAlive; }
 };
@@ -99,11 +102,11 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     virtual PacketType getType() const { return PacketType::PlayerLogin; }
 
-    const std::string& getPlayerName() { return m_PlayerName; }
+    const std::string& getPlayerName() const { return m_PlayerName; }
 };
 
 class WorldBeginDataPacket : public Packet {
@@ -118,7 +121,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     virtual PacketType getType() const { return PacketType::WorldBeginData; }
 
@@ -152,7 +155,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     virtual PacketType getType() const { return PacketType::WorldData; }
 
@@ -174,7 +177,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     virtual PacketType getType() const { return PacketType::UpdateMoney; }
 };
@@ -189,7 +192,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     virtual PacketType getType() const { return PacketType::UpdateEXP; }
 };
@@ -204,7 +207,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     std::uint32_t getRemainingTime() const { return m_RemainingTime; }
 
@@ -221,7 +224,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::GameState getGameState() const { return m_GameState; }
 
@@ -243,7 +246,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     const std::map<std::uint8_t, PlayerInfo>& getPlayers() const { return m_Players; }
 
@@ -261,7 +264,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     std::uint8_t getPlayerID() const { return m_PlayerID; }
     const std::string& getPlayerName() const { return m_PlayerName; }
@@ -279,7 +282,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     std::uint8_t getPlayerID() const { return m_PlayerID; }
 
@@ -296,7 +299,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     std::uint8_t getConnectionID() const { return m_ConnectionID; }
 
@@ -313,7 +316,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
 
@@ -331,7 +334,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
     std::uint8_t getPlayerID() const { return m_PlayerID; }
@@ -349,7 +352,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     const std::string& getReason() const { return m_Reason; }
 
@@ -367,7 +370,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     float getTPS() const { return m_TPS; }
     std::uint64_t getPacketSendTime() const { return m_PacketSendTime; }
@@ -391,7 +394,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     const std::vector<MobSend>& getMobSends() const { return m_MobSends; }
 
@@ -415,7 +418,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::MobID getMobID() const { return m_MobID; }
     game::MobType getMobType() const { return m_MobType; }
@@ -440,7 +443,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     std::int32_t getTowerX() const { return m_TowerX; }
     std::int32_t getTowerY() const { return m_TowerY; }
@@ -463,7 +466,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::TowerID getTowerID() const { return m_TowerID; }
     std::int32_t getTowerX() const { return m_TowerX; }
@@ -484,7 +487,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::TowerID getTowerID() const { return m_TowerID; }
 
@@ -502,7 +505,7 @@ public:
 
     virtual DataBuffer Serialize() const;
     virtual void Deserialize(DataBuffer& data);
-    virtual void Dispatch(PacketHandler* handler);
+    virtual void Dispatch(PacketHandler* handler) const;
 
     game::TowerID getTowerID() const { return m_TowerID; }
     game::TowerLevel getTowerLevel() const { return m_TowerLevel; }
diff --git a/src/game/Connexion.cpp b/src/game/Connexion.cpp
index 3fc055e..fc6e34b 100644
--- a/src/game/Connexion.cpp
+++ b/src/game/Connexion.cpp
@@ -47,9 +47,8 @@ bool Connexion::updateSocket() {
         protocol::PacketType packetType;
         decompressed >> packetType;
 
-        protocol::Packet* packet = protocol::PacketFactory::createPacket(packetType, decompressed);
+        PacketPtr packet = protocol::PacketFactory::createPacket(packetType, decompressed);
         GetDispatcher()->Dispatch(packet);
-        delete packet;
     }
     return true;
 }
@@ -62,7 +61,7 @@ bool Connexion::connect(const std::string& address, std::uint16_t port) {
     return true;
 }
 
-void Connexion::sendPacket(protocol::Packet* packet) {
+void Connexion::sendPacket(const protocol::Packet* packet) {
     network::SendPacket(packet->Serialize(), m_Socket);
 }
 
diff --git a/src/game/client/ClientConnexion.cpp b/src/game/client/ClientConnexion.cpp
index a6820d5..ce01ba6 100644
--- a/src/game/client/ClientConnexion.cpp
+++ b/src/game/client/ClientConnexion.cpp
@@ -15,17 +15,17 @@ void ClientConnexion::registerHandlers() {
     GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this);
 }
 
-void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet) {
+void ClientConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
     protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID());
     sendPacket(&keepAlivePacket);
 }
 
-void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet) {
+void ClientConnexion::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
     m_ConnectionID = packet->getConnectionID();
     login();
 }
 
-void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet) {
+void ClientConnexion::HandlePacket(const protocol::ServerTpsPacket* packet) {
     m_ServerTPS = packet->getTPS();
     m_Ping = utils::getTime() - packet->getPacketSendTime();
 }
@@ -39,7 +39,7 @@ bool ClientConnexion::updateSocket() {
     return Connexion::updateSocket();
 }
 
-void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet) {
+void ClientConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
     m_DisconnectReason = packet->getReason();
     closeConnection();
 }
diff --git a/src/game/client/ClientGame.cpp b/src/game/client/ClientGame.cpp
index cdca806..ab7cd55 100644
--- a/src/game/client/ClientGame.cpp
+++ b/src/game/client/ClientGame.cpp
@@ -36,14 +36,14 @@ void ClientGame::tick(std::uint64_t delta) {
     }
 }
 
-void ClientGame::HandlePacket(protocol::PlayerJoinPacket* packet) {
+void ClientGame::HandlePacket(const protocol::PlayerJoinPacket* packet) {
     game::Player player(packet->getPlayerID());
     player.setName(packet->getPlayerName());
 
     m_Players.insert({ player.getID(), player });
 }
 
-void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet) {
+void ClientGame::HandlePacket(const protocol::PlayerLeavePacket* packet) {
     game::Player* player = &m_Players[packet->getPlayerID()];
     if (player->getTeamColor() != game::TeamColor::None) {
         m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player);
@@ -51,7 +51,7 @@ void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet) {
     m_Players.erase(player->getID());
 }
 
-void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) {
+void ClientGame::HandlePacket(const protocol::PlayerListPacket* packet) {
     for (auto pair : packet->getPlayers()) {
         std::uint8_t playerID = pair.first;
         protocol::PlayerInfo playerInfo = pair.second;
@@ -66,7 +66,7 @@ void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) {
     m_Player = &m_Players[m_ConnexionID];
 }
 
-void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) {
+void ClientGame::HandlePacket(const protocol::UpdatePlayerTeamPacket* packet) {
     game::Player* player = &m_Players[packet->getPlayerID()];
     if (player->getTeamColor() == game::TeamColor::None) { //join a team
         getTeam(packet->getSelectedTeam()).addPlayer(player);
@@ -79,27 +79,27 @@ void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) {
     player->setTeamColor(packet->getSelectedTeam());
 }
 
-void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet) {
+void ClientGame::HandlePacket(const protocol::UpdateGameStatePacket* packet) {
     setGameState(packet->getGameState());
 }
 
-void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet) {
+void ClientGame::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
     m_ConnexionID = packet->getConnectionID();
 }
 
-void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet) {
+void ClientGame::HandlePacket(const protocol::UpdateLobbyTimePacket* packet) {
     m_LobbyTime = packet->getRemainingTime();
 }
 
-void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet) {
+void ClientGame::HandlePacket(const protocol::UpdateMoneyPacket* packet) {
     m_Player->setGold(packet->getGold());
 }
 
-void ClientGame::HandlePacket(protocol::DisconnectPacket* packet) {
+void ClientGame::HandlePacket(const protocol::DisconnectPacket* packet) {
     m_GameState = game::GameState::Disconnected;
 }
 
-void ClientGame::HandlePacket(protocol::WorldDataPacket* packet) {
+void ClientGame::HandlePacket(const protocol::WorldDataPacket* packet) {
     m_WorldRenderer.loadModels();
     // set cam pos to player spawn
     const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn();
@@ -117,7 +117,7 @@ void ClientGame::PlaceTower(game::TowerType type, const glm::vec2& position) {
     m_Client->getConnexion().sendPacket(&packet);
 }
 
-void ClientGame::HandlePacket(protocol::WorldAddTowerPacket* packet) {
+void ClientGame::HandlePacket(const protocol::WorldAddTowerPacket* packet) {
     m_WorldRenderer.addTower(m_WorldClient.placeTowerAt(packet->getTowerID(), packet->getTowerType(), packet->getTowerX(), packet->getTowerY(), packet->getBuilder()));
 }
 
diff --git a/src/game/client/WorldClient.cpp b/src/game/client/WorldClient.cpp
index 69f8004..44f4fda 100644
--- a/src/game/client/WorldClient.cpp
+++ b/src/game/client/WorldClient.cpp
@@ -12,20 +12,20 @@ WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::Packet
     GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this);
 }
 
-void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet) {
+void WorldClient::HandlePacket(const protocol::WorldBeginDataPacket* packet) {
     loadMap(packet);
 }
 
-void WorldClient::HandlePacket(protocol::WorldDataPacket* packet) {
+void WorldClient::HandlePacket(const protocol::WorldDataPacket* packet) {
     loadMap(packet);
 }
 
-void WorldClient::HandlePacket(protocol::SpawnMobPacket* packet) {
+void WorldClient::HandlePacket(const protocol::SpawnMobPacket* packet) {
     spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
         packet->getMobX(), packet->getMobY(), packet->getMobDirection());
 }
 
-void WorldClient::HandlePacket(protocol::UpgradeTowerPacket* packet) {
+void WorldClient::HandlePacket(const protocol::UpgradeTowerPacket* packet) {
     game::TowerPtr tower = getTowerById(packet->getTowerID());
     if(tower == nullptr) return; // this should not happen but who knows ?
     tower->upgrade(packet->getTowerLevel().getLevel(), packet->getTowerLevel().getPath());
diff --git a/src/game/server/Server.cpp b/src/game/server/Server.cpp
index e5bc8a6..31f7ce8 100644
--- a/src/game/server/Server.cpp
+++ b/src/game/server/Server.cpp
@@ -107,7 +107,7 @@ void Server::updateSockets() {
     }
 }
 
-void Server::broadcastPacket(protocol::Packet* packet) {
+void Server::broadcastPacket(const protocol::Packet* packet) {
     for (auto& connection : m_Connections) {
         ServerConnexion& con = connection.second;
         con.sendPacket(packet);
diff --git a/src/game/server/ServerConnexion.cpp b/src/game/server/ServerConnexion.cpp
index 990f9c6..96382ee 100644
--- a/src/game/server/ServerConnexion.cpp
+++ b/src/game/server/ServerConnexion.cpp
@@ -72,7 +72,7 @@ void ServerConnexion::sendKeepAlive() {
     m_KeepAlive.sendTime = time;
 }
 
-void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::PlayerLoginPacket* packet) {
     if (m_Player->getName().empty() && !packet->getPlayerName().empty()) {
         m_Player->setName(packet->getPlayerName());
 
@@ -95,7 +95,7 @@ void ServerConnexion::HandlePacket(protocol::PlayerLoginPacket* packet) {
     }
 }
 
-void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::SelectTeamPacket* packet) {
     if (m_Server->getGame().getGameState() != game::GameState::Lobby)
         return;
     if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) {
@@ -114,12 +114,12 @@ void ServerConnexion::HandlePacket(protocol::SelectTeamPacket* packet) {
     }
 }
 
-void ServerConnexion::HandlePacket(protocol::KeepAlivePacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
     if (packet->getAliveID() == m_KeepAlive.keepAliveID)
         m_KeepAlive.recievedResponse = true;
 }
 
-void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
     closeConnection();
 }
 
@@ -145,7 +145,7 @@ void ServerConnexion::initConnection() {
     }
 }
 
-void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::PlaceTowerPacket* packet) {
     game::TowerType towerType = packet->getTowerType();
     const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
     server::ServerWorld* world = m_Server->getGame().getServerWorld();
@@ -164,7 +164,7 @@ void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
     m_Server->broadcastPacket(&addTowerPacket);
 }
 
-void ServerConnexion::HandlePacket(protocol::SendMobsPacket* packet) {
+void ServerConnexion::HandlePacket(const protocol::SendMobsPacket* packet) {
     const std::vector<protocol::MobSend>& mobSent = packet->getMobSends();
 
     //TODO: verify the packet
@@ -174,7 +174,7 @@ void ServerConnexion::HandlePacket(protocol::SendMobsPacket* packet) {
     }
 }
 
-void ServerConnexion::HandlePacket(protocol::UpgradeTowerPacket* packet){
+void ServerConnexion::HandlePacket(const protocol::UpgradeTowerPacket* packet){
     //TODO: verify the packet
 
     m_Server->broadcastPacket(packet);
diff --git a/src/protocol/PacketDispatcher.cpp b/src/protocol/PacketDispatcher.cpp
index fbcb073..62561e2 100644
--- a/src/protocol/PacketDispatcher.cpp
+++ b/src/protocol/PacketDispatcher.cpp
@@ -25,7 +25,7 @@ void PacketDispatcher::UnregisterHandler(PacketHandler* handler) {
     }
 }
 
-void PacketDispatcher::Dispatch(Packet* packet) {
+void PacketDispatcher::Dispatch(const PacketPtr& packet) {
     if (!packet) return;
 
     PacketType type = packet->getType();
diff --git a/src/protocol/PacketFactory.cpp b/src/protocol/PacketFactory.cpp
index f7d32bd..610ba42 100644
--- a/src/protocol/PacketFactory.cpp
+++ b/src/protocol/PacketFactory.cpp
@@ -6,35 +6,35 @@ namespace td {
 namespace protocol {
 namespace PacketFactory {
 
-using PacketCreator = std::function<Packet* ()>;
+using PacketCreator = std::function<PacketPtr ()>;
 
 static std::map<PacketType, PacketCreator> packets = {
-    {PacketType::PlayerLogin,       []() -> Packet* {return new PlayerLoginPacket();} },
-    {PacketType::WorldBeginData,    []() -> Packet* {return new WorldBeginDataPacket();} },
-    {PacketType::WorldData,         []() -> Packet* {return new WorldDataPacket();} },
-    {PacketType::KeepAlive,         []() -> Packet* {return new KeepAlivePacket();} },
-    {PacketType::UpdateMoney,       []() -> Packet* {return new UpdateMoneyPacket();} },
-    {PacketType::UpdateEXP,         []() -> Packet* {return new UpdateExpPacket();} },
-    {PacketType::UpdateLobbyTime,   []() -> Packet* {return new UpdateLobbyTimePacket(); } },
-    {PacketType::UpdateGameState,   []() -> Packet* {return new UpdateGameStatePacket(); } },
-    {PacketType::PlayerList,        []() -> Packet* {return new PlayerListPacket(); } },
-    {PacketType::PlayerJoin,        []() -> Packet* {return new PlayerJoinPacket(); } },
-    {PacketType::PlayerLeave,       []() -> Packet* {return new PlayerLeavePacket(); } },
-    {PacketType::ConnectionInfo,    []() -> Packet* {return new ConnexionInfoPacket(); } },
-    {PacketType::SelectTeam,        []() -> Packet* {return new SelectTeamPacket(); } },
-    {PacketType::UpdatePlayerTeam,  []() -> Packet* {return new UpdatePlayerTeamPacket(); } },
-    {PacketType::Disconnect,        []() -> Packet* {return new DisconnectPacket(); } },
-    {PacketType::ServerTps,         []() -> Packet* {return new ServerTpsPacket(); } },
-    {PacketType::SpawnMob,          []() -> Packet* {return new SpawnMobPacket(); } },
-    {PacketType::PlaceTower,        []() -> Packet* {return new PlaceTowerPacket(); } },
-    {PacketType::WorldAddTower,     []() -> Packet* {return new WorldAddTowerPacket(); } },
-    {PacketType::WorldRemoveTower,  []() -> Packet* {return new WorldRemoveTowerPacket(); } },
-    {PacketType::SendMobs,          []() -> Packet* {return new SendMobsPacket(); } },
-    {PacketType::UpgradeTower,      []() -> Packet* {return new UpgradeTowerPacket(); } },
+    {PacketType::PlayerLogin,       []() -> PacketPtr {return std::make_unique<PlayerLoginPacket>();} },
+    {PacketType::WorldBeginData,    []() -> PacketPtr {return std::make_unique<WorldBeginDataPacket>();} },
+    {PacketType::WorldData,         []() -> PacketPtr {return std::make_unique<WorldDataPacket>();} },
+    {PacketType::KeepAlive,         []() -> PacketPtr {return std::make_unique<KeepAlivePacket>();} },
+    {PacketType::UpdateMoney,       []() -> PacketPtr {return std::make_unique<UpdateMoneyPacket>();} },
+    {PacketType::UpdateEXP,         []() -> PacketPtr {return std::make_unique<UpdateExpPacket>();} },
+    {PacketType::UpdateLobbyTime,   []() -> PacketPtr {return std::make_unique<UpdateLobbyTimePacket>(); } },
+    {PacketType::UpdateGameState,   []() -> PacketPtr {return std::make_unique<UpdateGameStatePacket>(); } },
+    {PacketType::PlayerList,        []() -> PacketPtr {return std::make_unique<PlayerListPacket>(); } },
+    {PacketType::PlayerJoin,        []() -> PacketPtr {return std::make_unique<PlayerJoinPacket>(); } },
+    {PacketType::PlayerLeave,       []() -> PacketPtr {return std::make_unique<PlayerLeavePacket>(); } },
+    {PacketType::ConnectionInfo,    []() -> PacketPtr {return std::make_unique<ConnexionInfoPacket>(); } },
+    {PacketType::SelectTeam,        []() -> PacketPtr {return std::make_unique<SelectTeamPacket>(); } },
+    {PacketType::UpdatePlayerTeam,  []() -> PacketPtr {return std::make_unique<UpdatePlayerTeamPacket>(); } },
+    {PacketType::Disconnect,        []() -> PacketPtr {return std::make_unique<DisconnectPacket>(); } },
+    {PacketType::ServerTps,         []() -> PacketPtr {return std::make_unique<ServerTpsPacket>(); } },
+    {PacketType::SpawnMob,          []() -> PacketPtr {return std::make_unique<SpawnMobPacket>(); } },
+    {PacketType::PlaceTower,        []() -> PacketPtr {return std::make_unique<PlaceTowerPacket>(); } },
+    {PacketType::WorldAddTower,     []() -> PacketPtr {return std::make_unique<WorldAddTowerPacket>(); } },
+    {PacketType::WorldRemoveTower,  []() -> PacketPtr {return std::make_unique<WorldRemoveTowerPacket>(); } },
+    {PacketType::SendMobs,          []() -> PacketPtr {return std::make_unique<SendMobsPacket>(); } },
+    {PacketType::UpgradeTower,      []() -> PacketPtr {return std::make_unique<UpgradeTowerPacket>(); } },
 };
 
-Packet* createPacket(PacketType type, DataBuffer& buffer) {
-    Packet* packet = packets[type]();
+PacketPtr createPacket(PacketType type, DataBuffer& buffer) {
+    PacketPtr packet = packets[type]();
     packet->Deserialize(buffer);
     return packet;
 }
diff --git a/src/protocol/Protocol.cpp b/src/protocol/Protocol.cpp
index 406a0f5..89e23ae 100644
--- a/src/protocol/Protocol.cpp
+++ b/src/protocol/Protocol.cpp
@@ -1,7 +1,7 @@
 #include "protocol/PacketHandler.h"
 #include <cmath>
 
-#define REGISTER_DISPATCH_CLASS(className) void className::Dispatch(PacketHandler* handler){handler->HandlePacket(this);}
+#define REGISTER_DISPATCH_CLASS(className) void className::Dispatch(PacketHandler* handler) const {handler->HandlePacket(this);}
 
 namespace td {
 namespace protocol {