Persson-dev/Tower-Defense
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

refactor: use of unique_ptr instead of new

Browse Source
This commit is contained in:
Simon Pribylski
2021-11-06 13:02:53 +01:00
parent 26290d8332
commit 6825a6327f
19 changed files with 136 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/game/Connexion.h
View File

@@ -27,7 +27,7 @@ public:
network::Socket::Status getSocketStatus() const { return m_Socket.GetStatus(); } network::Socket::Status getSocketStatus() const { return m_Socket.GetStatus(); }
void sendPacket(protocol::Packet* packet); void sendPacket(const protocol::Packet* packet);
REMOVE_COPY(Connexion); REMOVE_COPY(Connexion);
}; };

8
include/game/client/ClientConnexion.h
View File

@@ -18,10 +18,10 @@ public:
virtual bool updateSocket(); virtual bool updateSocket();
virtual void HandlePacket(protocol::KeepAlivePacket* packet); virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
virtual void HandlePacket(protocol::ConnexionInfoPacket* packet); virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(const protocol::DisconnectPacket* packet);
virtual void HandlePacket(protocol::ServerTpsPacket* packet); virtual void HandlePacket(const protocol::ServerTpsPacket* packet);
const std::string& getDisconnectReason() const { return m_DisconnectReason; } const std::string& getDisconnectReason() const { return m_DisconnectReason; }
float getServerTPS() const { return m_ServerTPS; } float getServerTPS() const { return m_ServerTPS; }

22
include/game/client/ClientGame.h
View File

@@ -39,17 +39,17 @@ public:
void PlaceTower(game::TowerType type, const glm::vec2& position); void PlaceTower(game::TowerType type, const glm::vec2& position);
virtual void HandlePacket(protocol::ConnexionInfoPacket* packet); virtual void HandlePacket(const protocol::ConnexionInfoPacket* packet);
virtual void HandlePacket(protocol::PlayerJoinPacket* packet); virtual void HandlePacket(const protocol::PlayerJoinPacket* packet);
virtual void HandlePacket(protocol::PlayerLeavePacket* packet); virtual void HandlePacket(const protocol::PlayerLeavePacket* packet);
virtual void HandlePacket(protocol::PlayerListPacket* packet); virtual void HandlePacket(const protocol::PlayerListPacket* packet);
virtual void HandlePacket(protocol::UpdatePlayerTeamPacket* packet); virtual void HandlePacket(const protocol::UpdatePlayerTeamPacket* packet);
virtual void HandlePacket(protocol::UpdateGameStatePacket* packet); virtual void HandlePacket(const protocol::UpdateGameStatePacket* packet);
virtual void HandlePacket(protocol::UpdateLobbyTimePacket* packet); virtual void HandlePacket(const protocol::UpdateLobbyTimePacket* packet);
virtual void HandlePacket(protocol::UpdateMoneyPacket* packet); virtual void HandlePacket(const protocol::UpdateMoneyPacket* packet);
virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(const protocol::DisconnectPacket* packet);
virtual void HandlePacket(protocol::WorldDataPacket* packet); virtual void HandlePacket(const protocol::WorldDataPacket* packet);
virtual void HandlePacket(protocol::WorldAddTowerPacket* packet); virtual void HandlePacket(const protocol::WorldAddTowerPacket* packet);
}; };
} // namespace client } // namespace client

8
include/game/client/WorldClient.h
View File

@@ -14,10 +14,10 @@ private:
public: public:
WorldClient(ClientGame* game); WorldClient(ClientGame* game);
virtual void HandlePacket(protocol::WorldBeginDataPacket* packet) override; virtual void HandlePacket(const protocol::WorldBeginDataPacket* packet) override;
virtual void HandlePacket(protocol::WorldDataPacket* packet) override; virtual void HandlePacket(const protocol::WorldDataPacket* packet) override;
virtual void HandlePacket(protocol::SpawnMobPacket* packet) override; virtual void HandlePacket(const protocol::SpawnMobPacket* packet) override;
virtual void HandlePacket(protocol::UpgradeTowerPacket* packet) override; virtual void HandlePacket(const protocol::UpgradeTowerPacket* packet) override;
virtual void OnArrowShot(game::MobPtr target, game::Tower* shooter) override; virtual void OnArrowShot(game::MobPtr target, game::Tower* shooter) override;
}; };

2
include/game/server/Server.h
View File

@@ -70,7 +70,7 @@ public:
void removeConnexion(std::uint8_t connexionID); void removeConnexion(std::uint8_t connexionID);
void broadcastPacket(protocol::Packet* packet); void broadcastPacket(const protocol::Packet* packet);
float getTPS() const { return m_TickCounter.getTPS(); } float getTPS() const { return m_TickCounter.getTPS(); }

14
include/game/server/ServerConnexion.h
View File

@@ -33,13 +33,13 @@ public:
void setServer(Server* server); void setServer(Server* server);
virtual void HandlePacket(protocol::PlayerLoginPacket* packet); virtual void HandlePacket(const protocol::PlayerLoginPacket* packet);
virtual void HandlePacket(protocol::KeepAlivePacket* packet); virtual void HandlePacket(const protocol::KeepAlivePacket* packet);
virtual void HandlePacket(protocol::SelectTeamPacket* packet); virtual void HandlePacket(const protocol::SelectTeamPacket* packet);
virtual void HandlePacket(protocol::DisconnectPacket* packet); virtual void HandlePacket(const protocol::DisconnectPacket* packet);
virtual void HandlePacket(protocol::PlaceTowerPacket* packet); virtual void HandlePacket(const protocol::PlaceTowerPacket* packet);
virtual void HandlePacket(protocol::SendMobsPacket* packet); virtual void HandlePacket(const protocol::SendMobsPacket* packet);
virtual void HandlePacket(protocol::UpgradeTowerPacket* packet); virtual void HandlePacket(const protocol::UpgradeTowerPacket* packet);
std::uint8_t getID() const { return m_ID; } std::uint8_t getID() const { return m_ID; }
const game::Player* getPlayer() const { return m_Player; } const game::Player* getPlayer() const { return m_Player; }

2
include/protocol/PacketDispatcher.h
View File

@@ -22,7 +22,7 @@ public:
PacketDispatcher(PacketDispatcher&& rhs) = delete; PacketDispatcher(PacketDispatcher&& rhs) = delete;
PacketDispatcher& operator=(PacketDispatcher&& rhs) = delete; PacketDispatcher& operator=(PacketDispatcher&& rhs) = delete;
void Dispatch(Packet* packet); void Dispatch(const PacketPtr& packet);
void RegisterHandler(PacketType type, PacketHandler* handler); void RegisterHandler(PacketType type, PacketHandler* handler);
void UnregisterHandler(PacketType type, PacketHandler* handler); void UnregisterHandler(PacketType type, PacketHandler* handler);

2
include/protocol/PacketFactory.h
View File

@@ -6,7 +6,7 @@ namespace td {
namespace protocol { namespace protocol {
namespace PacketFactory { namespace PacketFactory {
Packet* createPacket(PacketType type, DataBuffer& buffer); PacketPtr createPacket(PacketType type, DataBuffer& buffer);
} }
} // namespace protocol } // namespace protocol

44
include/protocol/PacketHandler.h
View File

@@ -16,28 +16,28 @@ public:
PacketDispatcher* GetDispatcher() { return m_Dispatcher; } PacketDispatcher* GetDispatcher() { return m_Dispatcher; }
virtual void HandlePacket(PlayerLoginPacket* packet) {} virtual void HandlePacket(const PlayerLoginPacket* packet) {}
virtual void HandlePacket(WorldBeginDataPacket* packet) {} virtual void HandlePacket(const WorldBeginDataPacket* packet) {}
virtual void HandlePacket(WorldDataPacket* packet) {} virtual void HandlePacket(const WorldDataPacket* packet) {}
virtual void HandlePacket(KeepAlivePacket* packet) {} virtual void HandlePacket(const KeepAlivePacket* packet) {}
virtual void HandlePacket(UpdateMoneyPacket* packet) {} virtual void HandlePacket(const UpdateMoneyPacket* packet) {}
virtual void HandlePacket(UpdateExpPacket* packet) {} virtual void HandlePacket(const UpdateExpPacket* packet) {}
virtual void HandlePacket(UpdateLobbyTimePacket* packet) {} virtual void HandlePacket(const UpdateLobbyTimePacket* packet) {}
virtual void HandlePacket(UpdateGameStatePacket* packet) {} virtual void HandlePacket(const UpdateGameStatePacket* packet) {}
virtual void HandlePacket(PlayerListPacket* packet) {} virtual void HandlePacket(const PlayerListPacket* packet) {}
virtual void HandlePacket(PlayerJoinPacket* packet) {} virtual void HandlePacket(const PlayerJoinPacket* packet) {}
virtual void HandlePacket(PlayerLeavePacket* packet) {} virtual void HandlePacket(const PlayerLeavePacket* packet) {}
virtual void HandlePacket(ConnexionInfoPacket* packet) {} virtual void HandlePacket(const ConnexionInfoPacket* packet) {}
virtual void HandlePacket(SelectTeamPacket* packet) {} virtual void HandlePacket(const SelectTeamPacket* packet) {}
virtual void HandlePacket(UpdatePlayerTeamPacket* packet) {} virtual void HandlePacket(const UpdatePlayerTeamPacket* packet) {}
virtual void HandlePacket(DisconnectPacket* packet) {} virtual void HandlePacket(const DisconnectPacket* packet) {}
virtual void HandlePacket(ServerTpsPacket* packet) {} virtual void HandlePacket(const ServerTpsPacket* packet) {}
virtual void HandlePacket(SpawnMobPacket* packet) {} virtual void HandlePacket(const SpawnMobPacket* packet) {}
virtual void HandlePacket(PlaceTowerPacket* packet) {} virtual void HandlePacket(const PlaceTowerPacket* packet) {}
virtual void HandlePacket(WorldAddTowerPacket* packet) {} virtual void HandlePacket(const WorldAddTowerPacket* packet) {}
virtual void HandlePacket(WorldRemoveTowerPacket* packet) {} virtual void HandlePacket(const WorldRemoveTowerPacket* packet) {}
virtual void HandlePacket(SendMobsPacket* packet) {} virtual void HandlePacket(const SendMobsPacket* packet) {}
virtual void HandlePacket(UpgradeTowerPacket* packet) {} virtual void HandlePacket(const UpgradeTowerPacket* packet) {}
}; };
} // namespace protocol } // namespace protocol

53
include/protocol/Protocol.h
View File

@@ -4,6 +4,8 @@
#include "game/World.h" #include "game/World.h"
#include "game/BaseGame.h" #include "game/BaseGame.h"
#include <memory>
namespace td { namespace td {
namespace protocol { namespace protocol {
@@ -65,12 +67,13 @@ public:
virtual DataBuffer Serialize() const = 0; virtual DataBuffer Serialize() const = 0;
virtual void Deserialize(DataBuffer& data) = 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; virtual PacketType getType() const = 0;
std::uint8_t getID() const { return (std::uint8_t)getType(); } std::uint8_t getID() const { return (std::uint8_t)getType(); }
}; };
typedef std::unique_ptr<Packet> PacketPtr;
class KeepAlivePacket : public Packet { class KeepAlivePacket : public Packet {
private: private:
@@ -82,9 +85,9 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); 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; } virtual PacketType getType() const { return PacketType::KeepAlive; }
}; };
@@ -99,11 +102,11 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::PlayerLogin; } 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 { class WorldBeginDataPacket : public Packet {
@@ -118,7 +121,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::WorldBeginData; } virtual PacketType getType() const { return PacketType::WorldBeginData; }
@@ -152,7 +155,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::WorldData; } virtual PacketType getType() const { return PacketType::WorldData; }
@@ -174,7 +177,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::UpdateMoney; } virtual PacketType getType() const { return PacketType::UpdateMoney; }
}; };
@@ -189,7 +192,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
virtual PacketType getType() const { return PacketType::UpdateEXP; } virtual PacketType getType() const { return PacketType::UpdateEXP; }
}; };
@@ -204,7 +207,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
std::uint32_t getRemainingTime() const { return m_RemainingTime; } std::uint32_t getRemainingTime() const { return m_RemainingTime; }
@@ -221,7 +224,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::GameState getGameState() const { return m_GameState; } game::GameState getGameState() const { return m_GameState; }
@@ -243,7 +246,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); 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; } const std::map<std::uint8_t, PlayerInfo>& getPlayers() const { return m_Players; }
@@ -261,7 +264,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
std::uint8_t getPlayerID() const { return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
const std::string& getPlayerName() const { return m_PlayerName; } const std::string& getPlayerName() const { return m_PlayerName; }
@@ -279,7 +282,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
std::uint8_t getPlayerID() const { return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
@@ -296,7 +299,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
std::uint8_t getConnectionID() const { return m_ConnectionID; } std::uint8_t getConnectionID() const { return m_ConnectionID; }
@@ -313,7 +316,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::TeamColor getSelectedTeam() const { return m_SelectedTeam; } game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
@@ -331,7 +334,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::TeamColor getSelectedTeam() const { return m_SelectedTeam; } game::TeamColor getSelectedTeam() const { return m_SelectedTeam; }
std::uint8_t getPlayerID() const { return m_PlayerID; } std::uint8_t getPlayerID() const { return m_PlayerID; }
@@ -349,7 +352,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
const std::string& getReason() const { return m_Reason; } const std::string& getReason() const { return m_Reason; }
@@ -367,7 +370,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
float getTPS() const { return m_TPS; } float getTPS() const { return m_TPS; }
std::uint64_t getPacketSendTime() const { return m_PacketSendTime; } std::uint64_t getPacketSendTime() const { return m_PacketSendTime; }
@@ -391,7 +394,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); 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; } const std::vector<MobSend>& getMobSends() const { return m_MobSends; }
@@ -415,7 +418,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::MobID getMobID() const { return m_MobID; } game::MobID getMobID() const { return m_MobID; }
game::MobType getMobType() const { return m_MobType; } game::MobType getMobType() const { return m_MobType; }
@@ -440,7 +443,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); 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 getTowerX() const { return m_TowerX; }
std::int32_t getTowerY() const { return m_TowerY; } std::int32_t getTowerY() const { return m_TowerY; }
@@ -463,7 +466,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; } game::TowerID getTowerID() const { return m_TowerID; }
std::int32_t getTowerX() const { return m_TowerX; } std::int32_t getTowerX() const { return m_TowerX; }
@@ -484,7 +487,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; } game::TowerID getTowerID() const { return m_TowerID; }
@@ -502,7 +505,7 @@ public:
virtual DataBuffer Serialize() const; virtual DataBuffer Serialize() const;
virtual void Deserialize(DataBuffer& data); virtual void Deserialize(DataBuffer& data);
virtual void Dispatch(PacketHandler* handler); virtual void Dispatch(PacketHandler* handler) const;
game::TowerID getTowerID() const { return m_TowerID; } game::TowerID getTowerID() const { return m_TowerID; }
game::TowerLevel getTowerLevel() const { return m_TowerLevel; } game::TowerLevel getTowerLevel() const { return m_TowerLevel; }

5
src/game/Connexion.cpp
View File

@@ -47,9 +47,8 @@ bool Connexion::updateSocket() {
protocol::PacketType packetType; protocol::PacketType packetType;
decompressed >> packetType; decompressed >> packetType;
protocol::Packet* packet = protocol::PacketFactory::createPacket(packetType, decompressed); PacketPtr packet = protocol::PacketFactory::createPacket(packetType, decompressed);
GetDispatcher()->Dispatch(packet); GetDispatcher()->Dispatch(packet);
delete packet;
} }
return true; return true;
} }
@@ -62,7 +61,7 @@ bool Connexion::connect(const std::string& address, std::uint16_t port) {
return true; return true;
} }
void Connexion::sendPacket(protocol::Packet* packet) { void Connexion::sendPacket(const protocol::Packet* packet) {
network::SendPacket(packet->Serialize(), m_Socket); network::SendPacket(packet->Serialize(), m_Socket);
} }

8
src/game/client/ClientConnexion.cpp
View File

@@ -15,17 +15,17 @@ void ClientConnexion::registerHandlers() {
GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this); GetDispatcher()->RegisterHandler(protocol::PacketType::ServerTps, this);
} }
void ClientConnexion::HandlePacket(protocol::KeepAlivePacket* packet) { void ClientConnexion::HandlePacket(const protocol::KeepAlivePacket* packet) {
protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID()); protocol::KeepAlivePacket keepAlivePacket(packet->getAliveID());
sendPacket(&keepAlivePacket); sendPacket(&keepAlivePacket);
} }
void ClientConnexion::HandlePacket(protocol::ConnexionInfoPacket* packet) { void ClientConnexion::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
m_ConnectionID = packet->getConnectionID(); m_ConnectionID = packet->getConnectionID();
login(); login();
} }
void ClientConnexion::HandlePacket(protocol::ServerTpsPacket* packet) { void ClientConnexion::HandlePacket(const protocol::ServerTpsPacket* packet) {
m_ServerTPS = packet->getTPS(); m_ServerTPS = packet->getTPS();
m_Ping = utils::getTime() - packet->getPacketSendTime(); m_Ping = utils::getTime() - packet->getPacketSendTime();
} }
@@ -39,7 +39,7 @@ bool ClientConnexion::updateSocket() {
return Connexion::updateSocket(); return Connexion::updateSocket();
} }
void ClientConnexion::HandlePacket(protocol::DisconnectPacket* packet) { void ClientConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
m_DisconnectReason = packet->getReason(); m_DisconnectReason = packet->getReason();
closeConnection(); closeConnection();
} }

22
src/game/client/ClientGame.cpp
View File

@@ -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()); game::Player player(packet->getPlayerID());
player.setName(packet->getPlayerName()); player.setName(packet->getPlayerName());
m_Players.insert({ player.getID(), player }); 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()]; game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() != game::TeamColor::None) { if (player->getTeamColor() != game::TeamColor::None) {
m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player); m_Teams[(std::size_t)player->getTeamColor()].removePlayer(player);
@@ -51,7 +51,7 @@ void ClientGame::HandlePacket(protocol::PlayerLeavePacket* packet) {
m_Players.erase(player->getID()); m_Players.erase(player->getID());
} }
void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) { void ClientGame::HandlePacket(const protocol::PlayerListPacket* packet) {
for (auto pair : packet->getPlayers()) { for (auto pair : packet->getPlayers()) {
std::uint8_t playerID = pair.first; std::uint8_t playerID = pair.first;
protocol::PlayerInfo playerInfo = pair.second; protocol::PlayerInfo playerInfo = pair.second;
@@ -66,7 +66,7 @@ void ClientGame::HandlePacket(protocol::PlayerListPacket* packet) {
m_Player = &m_Players[m_ConnexionID]; 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()]; game::Player* player = &m_Players[packet->getPlayerID()];
if (player->getTeamColor() == game::TeamColor::None) { //join a team if (player->getTeamColor() == game::TeamColor::None) { //join a team
getTeam(packet->getSelectedTeam()).addPlayer(player); getTeam(packet->getSelectedTeam()).addPlayer(player);
@@ -79,27 +79,27 @@ void ClientGame::HandlePacket(protocol::UpdatePlayerTeamPacket* packet) {
player->setTeamColor(packet->getSelectedTeam()); player->setTeamColor(packet->getSelectedTeam());
} }
void ClientGame::HandlePacket(protocol::UpdateGameStatePacket* packet) { void ClientGame::HandlePacket(const protocol::UpdateGameStatePacket* packet) {
setGameState(packet->getGameState()); setGameState(packet->getGameState());
} }
void ClientGame::HandlePacket(protocol::ConnexionInfoPacket* packet) { void ClientGame::HandlePacket(const protocol::ConnexionInfoPacket* packet) {
m_ConnexionID = packet->getConnectionID(); m_ConnexionID = packet->getConnectionID();
} }
void ClientGame::HandlePacket(protocol::UpdateLobbyTimePacket* packet) { void ClientGame::HandlePacket(const protocol::UpdateLobbyTimePacket* packet) {
m_LobbyTime = packet->getRemainingTime(); m_LobbyTime = packet->getRemainingTime();
} }
void ClientGame::HandlePacket(protocol::UpdateMoneyPacket* packet) { void ClientGame::HandlePacket(const protocol::UpdateMoneyPacket* packet) {
m_Player->setGold(packet->getGold()); m_Player->setGold(packet->getGold());
} }
void ClientGame::HandlePacket(protocol::DisconnectPacket* packet) { void ClientGame::HandlePacket(const protocol::DisconnectPacket* packet) {
m_GameState = game::GameState::Disconnected; m_GameState = game::GameState::Disconnected;
} }
void ClientGame::HandlePacket(protocol::WorldDataPacket* packet) { void ClientGame::HandlePacket(const protocol::WorldDataPacket* packet) {
m_WorldRenderer.loadModels(); m_WorldRenderer.loadModels();
// set cam pos to player spawn // set cam pos to player spawn
const game::Spawn& spawn = m_World->getTeam(m_Player->getTeamColor()).getSpawn(); 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); 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())); m_WorldRenderer.addTower(m_WorldClient.placeTowerAt(packet->getTowerID(), packet->getTowerType(), packet->getTowerX(), packet->getTowerY(), packet->getBuilder()));
} }

8
src/game/client/WorldClient.cpp
View File

@@ -12,20 +12,20 @@ WorldClient::WorldClient(ClientGame* game) : game::World(game), protocol::Packet
GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this); GetDispatcher()->RegisterHandler(protocol::PacketType::SpawnMob, this);
} }
void WorldClient::HandlePacket(protocol::WorldBeginDataPacket* packet) { void WorldClient::HandlePacket(const protocol::WorldBeginDataPacket* packet) {
loadMap(packet); loadMap(packet);
} }
void WorldClient::HandlePacket(protocol::WorldDataPacket* packet) { void WorldClient::HandlePacket(const protocol::WorldDataPacket* packet) {
loadMap(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(), spawnMobAt(packet->getMobID(), packet->getMobType(), packet->getMobLevel(), packet->getSender(),
packet->getMobX(), packet->getMobY(), packet->getMobDirection()); 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()); game::TowerPtr tower = getTowerById(packet->getTowerID());
if(tower == nullptr) return; // this should not happen but who knows ? if(tower == nullptr) return; // this should not happen but who knows ?
tower->upgrade(packet->getTowerLevel().getLevel(), packet->getTowerLevel().getPath()); tower->upgrade(packet->getTowerLevel().getLevel(), packet->getTowerLevel().getPath());

2
src/game/server/Server.cpp
View File

@@ -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) { for (auto& connection : m_Connections) {
ServerConnexion& con = connection.second; ServerConnexion& con = connection.second;
con.sendPacket(packet); con.sendPacket(packet);

14
src/game/server/ServerConnexion.cpp
View File

@@ -72,7 +72,7 @@ void ServerConnexion::sendKeepAlive() {
m_KeepAlive.sendTime = time; 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()) { if (m_Player->getName().empty() && !packet->getPlayerName().empty()) {
m_Player->setName(packet->getPlayerName()); 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) if (m_Server->getGame().getGameState() != game::GameState::Lobby)
return; return;
if ((std::int8_t)packet->getSelectedTeam() >= -1 || (std::int8_t)packet->getSelectedTeam() <= 1) { 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) if (packet->getAliveID() == m_KeepAlive.keepAliveID)
m_KeepAlive.recievedResponse = true; m_KeepAlive.recievedResponse = true;
} }
void ServerConnexion::HandlePacket(protocol::DisconnectPacket* packet) { void ServerConnexion::HandlePacket(const protocol::DisconnectPacket* packet) {
closeConnection(); 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(); game::TowerType towerType = packet->getTowerType();
const game::TowerInfo& towerInfo = game::getTowerInfo(towerType); const game::TowerInfo& towerInfo = game::getTowerInfo(towerType);
server::ServerWorld* world = m_Server->getGame().getServerWorld(); server::ServerWorld* world = m_Server->getGame().getServerWorld();
@@ -164,7 +164,7 @@ void ServerConnexion::HandlePacket(protocol::PlaceTowerPacket* packet) {
m_Server->broadcastPacket(&addTowerPacket); 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(); const std::vector<protocol::MobSend>& mobSent = packet->getMobSends();
//TODO: verify the packet //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 //TODO: verify the packet
m_Server->broadcastPacket(packet); m_Server->broadcastPacket(packet);

2
src/protocol/PacketDispatcher.cpp
View File

@@ -25,7 +25,7 @@ void PacketDispatcher::UnregisterHandler(PacketHandler* handler) {
} }
} }
void PacketDispatcher::Dispatch(Packet* packet) { void PacketDispatcher::Dispatch(const PacketPtr& packet) {
if (!packet) return; if (!packet) return;
PacketType type = packet->getType(); PacketType type = packet->getType();

50
src/protocol/PacketFactory.cpp
View File

@@ -6,35 +6,35 @@ namespace td {
namespace protocol { namespace protocol {
namespace PacketFactory { namespace PacketFactory {
using PacketCreator = std::function<Packet* ()>; using PacketCreator = std::function<PacketPtr ()>;
static std::map<PacketType, PacketCreator> packets = { static std::map<PacketType, PacketCreator> packets = {
{PacketType::PlayerLogin, []() -> Packet* {return new PlayerLoginPacket();} }, {PacketType::PlayerLogin, []() -> PacketPtr {return std::make_unique<PlayerLoginPacket>();} },
{PacketType::WorldBeginData, []() -> Packet* {return new WorldBeginDataPacket();} }, {PacketType::WorldBeginData, []() -> PacketPtr {return std::make_unique<WorldBeginDataPacket>();} },
{PacketType::WorldData, []() -> Packet* {return new WorldDataPacket();} }, {PacketType::WorldData, []() -> PacketPtr {return std::make_unique<WorldDataPacket>();} },
{PacketType::KeepAlive, []() -> Packet* {return new KeepAlivePacket();} }, {PacketType::KeepAlive, []() -> PacketPtr {return std::make_unique<KeepAlivePacket>();} },
{PacketType::UpdateMoney, []() -> Packet* {return new UpdateMoneyPacket();} }, {PacketType::UpdateMoney, []() -> PacketPtr {return std::make_unique<UpdateMoneyPacket>();} },
{PacketType::UpdateEXP, []() -> Packet* {return new UpdateExpPacket();} }, {PacketType::UpdateEXP, []() -> PacketPtr {return std::make_unique<UpdateExpPacket>();} },
{PacketType::UpdateLobbyTime, []() -> Packet* {return new UpdateLobbyTimePacket(); } }, {PacketType::UpdateLobbyTime, []() -> PacketPtr {return std::make_unique<UpdateLobbyTimePacket>(); } },
{PacketType::UpdateGameState, []() -> Packet* {return new UpdateGameStatePacket(); } }, {PacketType::UpdateGameState, []() -> PacketPtr {return std::make_unique<UpdateGameStatePacket>(); } },
{PacketType::PlayerList, []() -> Packet* {return new PlayerListPacket(); } }, {PacketType::PlayerList, []() -> PacketPtr {return std::make_unique<PlayerListPacket>(); } },
{PacketType::PlayerJoin, []() -> Packet* {return new PlayerJoinPacket(); } }, {PacketType::PlayerJoin, []() -> PacketPtr {return std::make_unique<PlayerJoinPacket>(); } },
{PacketType::PlayerLeave, []() -> Packet* {return new PlayerLeavePacket(); } }, {PacketType::PlayerLeave, []() -> PacketPtr {return std::make_unique<PlayerLeavePacket>(); } },
{PacketType::ConnectionInfo, []() -> Packet* {return new ConnexionInfoPacket(); } }, {PacketType::ConnectionInfo, []() -> PacketPtr {return std::make_unique<ConnexionInfoPacket>(); } },
{PacketType::SelectTeam, []() -> Packet* {return new SelectTeamPacket(); } }, {PacketType::SelectTeam, []() -> PacketPtr {return std::make_unique<SelectTeamPacket>(); } },
{PacketType::UpdatePlayerTeam, []() -> Packet* {return new UpdatePlayerTeamPacket(); } }, {PacketType::UpdatePlayerTeam, []() -> PacketPtr {return std::make_unique<UpdatePlayerTeamPacket>(); } },
{PacketType::Disconnect, []() -> Packet* {return new DisconnectPacket(); } }, {PacketType::Disconnect, []() -> PacketPtr {return std::make_unique<DisconnectPacket>(); } },
{PacketType::ServerTps, []() -> Packet* {return new ServerTpsPacket(); } }, {PacketType::ServerTps, []() -> PacketPtr {return std::make_unique<ServerTpsPacket>(); } },
{PacketType::SpawnMob, []() -> Packet* {return new SpawnMobPacket(); } }, {PacketType::SpawnMob, []() -> PacketPtr {return std::make_unique<SpawnMobPacket>(); } },
{PacketType::PlaceTower, []() -> Packet* {return new PlaceTowerPacket(); } }, {PacketType::PlaceTower, []() -> PacketPtr {return std::make_unique<PlaceTowerPacket>(); } },
{PacketType::WorldAddTower, []() -> Packet* {return new WorldAddTowerPacket(); } }, {PacketType::WorldAddTower, []() -> PacketPtr {return std::make_unique<WorldAddTowerPacket>(); } },
{PacketType::WorldRemoveTower, []() -> Packet* {return new WorldRemoveTowerPacket(); } }, {PacketType::WorldRemoveTower, []() -> PacketPtr {return std::make_unique<WorldRemoveTowerPacket>(); } },
{PacketType::SendMobs, []() -> Packet* {return new SendMobsPacket(); } }, {PacketType::SendMobs, []() -> PacketPtr {return std::make_unique<SendMobsPacket>(); } },
{PacketType::UpgradeTower, []() -> Packet* {return new UpgradeTowerPacket(); } }, {PacketType::UpgradeTower, []() -> PacketPtr {return std::make_unique<UpgradeTowerPacket>(); } },
}; };
Packet* createPacket(PacketType type, DataBuffer& buffer) { PacketPtr createPacket(PacketType type, DataBuffer& buffer) {
Packet* packet = packets[type](); PacketPtr packet = packets[type]();
packet->Deserialize(buffer); packet->Deserialize(buffer);
return packet; return packet;
} }

2
src/protocol/Protocol.cpp
View File

@@ -1,7 +1,7 @@
#include "protocol/PacketHandler.h" #include "protocol/PacketHandler.h"
#include <cmath> #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 td {
namespace protocol { namespace protocol {