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

5
src/game/Connexion.cpp
View File

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

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

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

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

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

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

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

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

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;
PacketType type = packet->getType();

50
src/protocol/PacketFactory.cpp
View File

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

2
src/protocol/Protocol.cpp
View File

@@ -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 {