1er commit

include/protocol/PacketDispatcher.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "protocol/Protocol.h"
+
+#include <map>
+#include <vector>
+
+namespace td {
+namespace protocol {
+
+class PacketHandler;
+
+class PacketDispatcher {
+private:
+    std::map<PacketType, std::vector<PacketHandler*>> m_Handlers;
+
+public:
+    PacketDispatcher() = default;
+
+    PacketDispatcher(const PacketDispatcher& rhs) = delete;
+    PacketDispatcher& operator=(const PacketDispatcher& rhs) = delete;
+    PacketDispatcher(PacketDispatcher&& rhs) = delete;
+    PacketDispatcher& operator=(PacketDispatcher&& rhs) = delete;
+
+    void Dispatch(Packet* packet);
+
+    void RegisterHandler(PacketType type, PacketHandler* handler);
+    void UnregisterHandler(PacketType type, PacketHandler* handler);
+    void UnregisterHandler(PacketHandler* handler);
+};
+
+} // namespace protocol
+} // namespace td

include/protocol/PacketFactory.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "protocol/Protocol.h"
+
+namespace td {
+namespace protocol {
+namespace PacketFactory {
+
+Packet* createPacket(PacketType type, DataBuffer& buffer);
+
+}
+} // namespace protocol
+} // namespace td

include/protocol/PacketHandler.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include "protocol/Protocol.h"
+
+namespace td {
+namespace protocol {
+
+class PacketDispatcher;
+
+class PacketHandler{
+private:
+    PacketDispatcher* m_Dispatcher;
+public:
+    PacketHandler(PacketDispatcher* dispatcher) : m_Dispatcher(dispatcher){}
+    virtual ~PacketHandler(){}
+
+    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){}
+};
+
+} // namespace protocol
+} // namespace td

include/protocol/Protocol.h

@@ -0,0 +1,384 @@
+#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; }
+};
+
+}
+}