384 lines
12 KiB
C++
384 lines
12 KiB
C++
#pragma once
|
|
|
|
#include "network/DataBuffer.h"
|
|
#include "game/World.h"
|
|
#include "game/BaseGame.h"
|
|
|
|
namespace td {
|
|
namespace protocol {
|
|
|
|
class PacketHandler;
|
|
|
|
enum class PacketType : std::uint8_t{
|
|
PlayerLogin = 0,
|
|
PlayerJoin,
|
|
PlayerLeave,
|
|
WorldBeginData,
|
|
WorldData,
|
|
ChunkData,
|
|
KeepAlive,
|
|
UpdateMoney,
|
|
UpdateEXP,
|
|
UpdateLobbyTime,
|
|
UpdateGameState,
|
|
Disconnect,
|
|
PlayerList,
|
|
ConnectionInfo,
|
|
SelectTeam,
|
|
UpdatePlayerTeam,
|
|
ServerTps,
|
|
SpawnMob,
|
|
};
|
|
|
|
class Packet{
|
|
public:
|
|
Packet(){}
|
|
virtual ~Packet(){}
|
|
|
|
virtual DataBuffer Serialize() const = 0;
|
|
virtual void Deserialize(DataBuffer& data) = 0;
|
|
virtual void Dispatch(PacketHandler* handler) = 0;
|
|
|
|
virtual PacketType getType() const = 0;
|
|
std::uint8_t getID() const{ return (std::uint8_t)getType(); }
|
|
};
|
|
|
|
|
|
class KeepAlivePacket : public Packet{
|
|
private:
|
|
std::uint64_t m_AliveID;
|
|
public:
|
|
KeepAlivePacket(){}
|
|
KeepAlivePacket(std::uint64_t aliveID): m_AliveID(aliveID){}
|
|
virtual ~KeepAlivePacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
std::uint64_t getAliveID(){ return m_AliveID; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::KeepAlive; }
|
|
};
|
|
|
|
class PlayerLoginPacket : public Packet{
|
|
private:
|
|
std::string m_PlayerName;
|
|
public:
|
|
PlayerLoginPacket(){}
|
|
PlayerLoginPacket(std::string playerName): m_PlayerName(playerName){}
|
|
virtual ~PlayerLoginPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
virtual PacketType getType() const{ return PacketType::PlayerLogin; }
|
|
|
|
const std::string& getPlayerName(){ return m_PlayerName; }
|
|
};
|
|
|
|
class WorldBeginDataPacket : public Packet{
|
|
private:
|
|
game::TowerTileColorPalette m_TowerPlacePalette;
|
|
game::Color m_WalkablePalette;
|
|
std::vector<game::Color> m_DecorationPalette;
|
|
|
|
game::SpawnColorPalette m_SpawnColorPalette;
|
|
|
|
game::TilePalette m_TilePalette;
|
|
|
|
game::Spawn m_RedSpawn, m_BlueSpawn;
|
|
game::TeamCastle m_RedTower, m_BlueTower;
|
|
|
|
const game::World* m_World;
|
|
public:
|
|
WorldBeginDataPacket(){}
|
|
WorldBeginDataPacket(const game::World* world): m_World(world){}
|
|
virtual ~WorldBeginDataPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
virtual PacketType getType() const{ return PacketType::WorldBeginData; }
|
|
|
|
const game::TowerTileColorPalette& getTowerTilePalette() const{ return m_TowerPlacePalette; }
|
|
const game::Color& getWalkableTileColor() const{ return m_WalkablePalette; }
|
|
const std::vector<game::Color>& getDecorationPalette() const{ return m_DecorationPalette; }
|
|
|
|
const game::Spawn& getRedSpawn() const{ return m_RedSpawn; }
|
|
const game::Spawn& getBlueSpawn() const{ return m_BlueSpawn; }
|
|
|
|
const game::SpawnColorPalette& getSpawnPalette() const{ return m_SpawnColorPalette; }
|
|
|
|
const game::TeamCastle& getRedCastle() const{ return m_RedTower; }
|
|
const game::TeamCastle& getBlueCastle() const{ return m_BlueTower; }
|
|
|
|
const game::TilePalette getTilePalette() const{ return m_TilePalette; }
|
|
};
|
|
|
|
class WorldDataPacket : public Packet{
|
|
private:
|
|
std::unordered_map<game::ChunkCoord, game::ChunkPtr> m_Chunks;
|
|
|
|
const game::World* m_World;
|
|
public:
|
|
WorldDataPacket(){}
|
|
WorldDataPacket(const game::World* world): m_World(world){}
|
|
virtual ~WorldDataPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
virtual PacketType getType() const{ return PacketType::WorldData; }
|
|
|
|
const std::unordered_map<game::ChunkCoord, game::ChunkPtr>& getChunks() const{ return m_Chunks; }
|
|
};
|
|
|
|
class UpdateMoneyPacket : public Packet{
|
|
private:
|
|
std::uint32_t m_NewAmount;
|
|
public:
|
|
UpdateMoneyPacket(){}
|
|
UpdateMoneyPacket(std::uint32_t newAmount): m_NewAmount(newAmount){}
|
|
virtual ~UpdateMoneyPacket(){}
|
|
|
|
std::uint32_t getGold() const{ return m_NewAmount; }
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
virtual PacketType getType() const{ return PacketType::UpdateMoney; }
|
|
};
|
|
|
|
class UpdateExpPacket : public Packet{
|
|
private:
|
|
std::uint32_t m_NewAmount;
|
|
public:
|
|
UpdateExpPacket(){}
|
|
UpdateExpPacket(std::uint32_t newAmount): m_NewAmount(newAmount){}
|
|
virtual ~UpdateExpPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
virtual PacketType getType() const{ return PacketType::UpdateEXP; }
|
|
};
|
|
|
|
class UpdateLobbyTimePacket : public Packet{
|
|
private:
|
|
std::uint32_t m_RemainingTime;
|
|
public:
|
|
UpdateLobbyTimePacket(){}
|
|
UpdateLobbyTimePacket(std::uint32_t remainingTime): m_RemainingTime(remainingTime){}
|
|
virtual ~UpdateLobbyTimePacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
std::uint32_t getRemainingTime() const{ return m_RemainingTime; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::UpdateLobbyTime; }
|
|
};
|
|
|
|
class UpdateGameStatePacket : public Packet{
|
|
private:
|
|
game::GameState m_GameState;
|
|
public:
|
|
UpdateGameStatePacket(){}
|
|
UpdateGameStatePacket(game::GameState gameState): m_GameState(gameState){}
|
|
virtual ~UpdateGameStatePacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
game::GameState getGameState() const{ return m_GameState; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::UpdateGameState; }
|
|
};
|
|
|
|
struct PlayerInfo{
|
|
std::string name;
|
|
game::TeamColor team;
|
|
};
|
|
|
|
class PlayerListPacket : public Packet{
|
|
private:
|
|
std::map<std::uint8_t, PlayerInfo> m_Players;
|
|
public:
|
|
PlayerListPacket(){}
|
|
PlayerListPacket(std::map<std::uint8_t, PlayerInfo> players): m_Players(players){}
|
|
virtual ~PlayerListPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
const std::map<std::uint8_t, PlayerInfo>& getPlayers() const{ return m_Players; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::PlayerList; }
|
|
};
|
|
|
|
class PlayerJoinPacket : public Packet{
|
|
private:
|
|
std::uint8_t m_PlayerID;
|
|
std::string m_PlayerName;
|
|
public:
|
|
PlayerJoinPacket(){}
|
|
PlayerJoinPacket(std::uint8_t playerID, const std::string& playerName): m_PlayerID(playerID), m_PlayerName(playerName){}
|
|
virtual ~PlayerJoinPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
std::uint8_t getPlayerID() const{ return m_PlayerID; }
|
|
const std::string& getPlayerName() const{ return m_PlayerName; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::PlayerJoin; }
|
|
};
|
|
|
|
class PlayerLeavePacket : public Packet{
|
|
private:
|
|
std::uint8_t m_PlayerID;
|
|
public:
|
|
PlayerLeavePacket(){}
|
|
PlayerLeavePacket(std::uint8_t playerID): m_PlayerID(playerID){}
|
|
virtual ~PlayerLeavePacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
std::uint8_t getPlayerID() const{ return m_PlayerID; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::PlayerLeave; }
|
|
};
|
|
|
|
class ConnexionInfoPacket : public Packet{
|
|
private:
|
|
std::uint8_t m_ConnectionID;
|
|
public:
|
|
ConnexionInfoPacket(){}
|
|
ConnexionInfoPacket(std::uint8_t connectionID): m_ConnectionID(connectionID){}
|
|
virtual ~ConnexionInfoPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
std::uint8_t getConnectionID() const{ return m_ConnectionID; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::ConnectionInfo; }
|
|
};
|
|
|
|
class SelectTeamPacket : public Packet{
|
|
private:
|
|
game::TeamColor m_SelectedTeam;
|
|
public:
|
|
SelectTeamPacket(){}
|
|
SelectTeamPacket(game::TeamColor selectedTeam): m_SelectedTeam(selectedTeam){}
|
|
virtual ~SelectTeamPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::SelectTeam; }
|
|
};
|
|
|
|
class UpdatePlayerTeamPacket : public Packet{
|
|
private:
|
|
std::uint8_t m_PlayerID;
|
|
game::TeamColor m_SelectedTeam;
|
|
public:
|
|
UpdatePlayerTeamPacket(){}
|
|
UpdatePlayerTeamPacket(std::uint8_t playerID, game::TeamColor selectedTeam): m_PlayerID(playerID), m_SelectedTeam(selectedTeam){}
|
|
virtual ~UpdatePlayerTeamPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
game::TeamColor getSelectedTeam() const{ return m_SelectedTeam; }
|
|
std::uint8_t getPlayerID() const{ return m_PlayerID; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::UpdatePlayerTeam; }
|
|
};
|
|
|
|
class DisconnectPacket : public Packet{
|
|
private:
|
|
std::string m_Reason; // only when sent from server
|
|
public:
|
|
DisconnectPacket(){}
|
|
DisconnectPacket(std::string reason): m_Reason(reason){}
|
|
virtual ~DisconnectPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
const std::string& getReason() const{ return m_Reason; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::Disconnect; }
|
|
};
|
|
|
|
class ServerTpsPacket : public Packet{
|
|
private:
|
|
float m_TPS;
|
|
std::uint64_t m_PacketSendTime; // used to calculate ping
|
|
public:
|
|
ServerTpsPacket(){}
|
|
ServerTpsPacket(float tps, std::uint64_t sendTime): m_TPS(tps), m_PacketSendTime(sendTime){}
|
|
virtual ~ServerTpsPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
float getTPS() const{ return m_TPS; }
|
|
std::uint64_t getPacketSendTime() const {return m_PacketSendTime;}
|
|
|
|
virtual PacketType getType() const{ return PacketType::ServerTps; }
|
|
};
|
|
|
|
class SpawnMobPacket : public Packet{
|
|
private:
|
|
game::MobID m_MobID;
|
|
game::MobType m_MobType;
|
|
game::MobLevel m_MobLevel;
|
|
game::Direction m_MobDirection;
|
|
game::PlayerID m_Sender;
|
|
float m_MobX, m_MobY;
|
|
public:
|
|
SpawnMobPacket(){}
|
|
SpawnMobPacket(game::MobID id, game::MobType type, std::uint8_t level, game::PlayerID sender,
|
|
float x, float y, game::Direction dir) : m_MobID(id), m_MobType(type), m_MobLevel(level),
|
|
m_MobDirection(dir), m_Sender(sender), m_MobX(x), m_MobY(y){}
|
|
virtual ~SpawnMobPacket(){}
|
|
|
|
virtual DataBuffer Serialize() const;
|
|
virtual void Deserialize(DataBuffer& data);
|
|
virtual void Dispatch(PacketHandler* handler);
|
|
|
|
game::MobID getMobID() const{ return m_MobID; }
|
|
game::MobType getMobType() const{ return m_MobType; }
|
|
game::MobLevel getMobLevel() const{ return m_MobLevel; }
|
|
game::Direction getMobDirection() const{ return m_MobDirection; }
|
|
game::PlayerID getSender() const{ return m_Sender; }
|
|
float getMobX() const{ return m_MobX; }
|
|
float getMobY() const{ return m_MobY; }
|
|
|
|
virtual PacketType getType() const{ return PacketType::SpawnMob; }
|
|
};
|
|
|
|
}
|
|
} |