refactor: use of unique_ptr instead of new

2021-11-06 13:02:53 +01:00
parent 26290d8332
commit 6825a6327f
19 changed files with 136 additions and 134 deletions
--- 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);
 };
--- 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; }
--- 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
--- 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;
 };
--- 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(); }

--- 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; }
--- 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);
--- 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
--- 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
--- 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; }
--- 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);
 }

--- 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();
 }
--- 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()));
 }

--- 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());
--- 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);
--- 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);
--- 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();
--- 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;
 }
--- 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 {