From 91c215c16d1a9e4da57ba49ec5be57a152c5741a Mon Sep 17 00:00:00 2001 From: Persson-dev Date: Mon, 19 Aug 2024 11:04:37 +0200 Subject: [PATCH] add blitz files --- include/blitz/common/NonCopyable.h | 25 ++ include/blitz/common/Types.h | 11 + include/blitz/protocol/ByteBuffer.h | 89 +++++++ include/blitz/protocol/PacketData.h | 72 ++++++ include/blitz/protocol/PacketDeclare.h | 49 ++++ include/blitz/protocol/PacketDispatcher.h | 58 +++++ include/blitz/protocol/PacketFactory.h | 21 ++ include/blitz/protocol/PacketHandler.h | 34 +++ include/blitz/protocol/PacketSerializer.h | 20 ++ include/blitz/protocol/PacketVisitor.h | 39 +++ include/blitz/protocol/Packets.h | 112 +++++++++ src/blitz/protocol/ByteBuffer.cpp | 49 ++++ src/blitz/protocol/PacketDispatcher.cpp | 37 +++ src/blitz/protocol/PacketFactory.cpp | 32 +++ src/blitz/protocol/PacketHandler.cpp | 14 ++ src/blitz/protocol/PacketSerializer.cpp | 294 ++++++++++++++++++++++ src/blitz/protocol/PacketVisitor.cpp | 11 + src/blitz/protocol/Packets.cpp | 18 ++ xmake/target.lua | 2 + 19 files changed, 987 insertions(+) create mode 100644 include/blitz/common/NonCopyable.h create mode 100644 include/blitz/common/Types.h create mode 100644 include/blitz/protocol/ByteBuffer.h create mode 100644 include/blitz/protocol/PacketData.h create mode 100644 include/blitz/protocol/PacketDeclare.h create mode 100644 include/blitz/protocol/PacketDispatcher.h create mode 100644 include/blitz/protocol/PacketFactory.h create mode 100644 include/blitz/protocol/PacketHandler.h create mode 100644 include/blitz/protocol/PacketSerializer.h create mode 100644 include/blitz/protocol/PacketVisitor.h create mode 100644 include/blitz/protocol/Packets.h create mode 100644 src/blitz/protocol/ByteBuffer.cpp create mode 100644 src/blitz/protocol/PacketDispatcher.cpp create mode 100644 src/blitz/protocol/PacketFactory.cpp create mode 100644 src/blitz/protocol/PacketHandler.cpp create mode 100644 src/blitz/protocol/PacketSerializer.cpp create mode 100644 src/blitz/protocol/PacketVisitor.cpp create mode 100644 src/blitz/protocol/Packets.cpp diff --git a/include/blitz/common/NonCopyable.h b/include/blitz/common/NonCopyable.h new file mode 100644 index 0000000..308a744 --- /dev/null +++ b/include/blitz/common/NonCopyable.h @@ -0,0 +1,25 @@ +#pragma once + +/** + * \file NonCopyable.h + * \brief File containing the blitz::NonCopyable class + */ + +namespace blitz { + +/** + * \class NonCopyable + * \brief Class used to make a class non copyable + * \note Inherit from this class privately to make a class non copyable + */ +class NonCopyable { + public: + NonCopyable(const NonCopyable&) = delete; + NonCopyable& operator=(const NonCopyable&) = delete; + + protected: + NonCopyable() {} + ~NonCopyable() {} +}; + +} // namespace blitz diff --git a/include/blitz/common/Types.h b/include/blitz/common/Types.h new file mode 100644 index 0000000..1208204 --- /dev/null +++ b/include/blitz/common/Types.h @@ -0,0 +1,11 @@ +#pragma once + +#include + +namespace blitz { + +using EntityID = std::uint64_t; +using PeerID = std::int32_t; +using PlayerID = PeerID; + +} // namespace blitz diff --git a/include/blitz/protocol/ByteBuffer.h b/include/blitz/protocol/ByteBuffer.h new file mode 100644 index 0000000..5540bae --- /dev/null +++ b/include/blitz/protocol/ByteBuffer.h @@ -0,0 +1,89 @@ +#pragma once + +#include +#include +#include + +namespace blitz { +namespace protocol { + +class PlayerInfo; + +#define Operators(Type, GodotType) \ + ByteBuffer& operator>>(Type& a_Data) { \ + a_Data = m_Buffer.decode_##GodotType(m_ReadOffset); \ + m_ReadOffset += sizeof(a_Data); \ + return *this; \ + } \ + \ + ByteBuffer& operator<<(Type a_Data) { \ + m_Buffer.resize(m_Buffer.size() + sizeof(a_Data)); \ + m_Buffer.encode_##GodotType(m_Buffer.size() - sizeof(a_Data), a_Data); \ + return *this; \ + } + +class ByteBuffer { + private: + godot::PackedByteArray m_Buffer; + std::size_t m_ReadOffset; + + public: + ByteBuffer(godot::PackedByteArray&& a_Buffer) : m_Buffer(std::move(a_Buffer)), m_ReadOffset(0) {} + ByteBuffer() : m_ReadOffset(0) { + m_Buffer.resize(0); + } + + const godot::PackedByteArray& GetByteArray() const { + return m_Buffer; + } + + godot::PackedByteArray& GetByteArray() { + return m_Buffer; + } + + // Integers + Operators(int8_t, s8); + Operators(uint8_t, u8); + Operators(int16_t, s16); + Operators(uint16_t, u16); + Operators(int32_t, s32); + Operators(uint32_t, u32); + Operators(int64_t, s64); + Operators(uint64_t, u64); + + // Reals + Operators(float, float); + Operators(double, double); + + ByteBuffer& operator<<(const godot::String& a_Data); + ByteBuffer& operator>>(godot::String& a_Data); + + ByteBuffer& operator<<(const godot::Vector3& a_Data); + ByteBuffer& operator>>(godot::Vector3& a_Data); + + template + ByteBuffer& operator<<(const std::vector& a_Data) { + *this << static_cast(a_Data.size()); + for (const T& data : a_Data) { + *this << data; + } + return *this; + } + + template + ByteBuffer& operator>>(std::vector& a_Data) { + std::uint32_t arraySize; + *this >> arraySize; + a_Data.resize(arraySize); + for (std::uint32_t i = 0; i < arraySize; i++) { + *this >> a_Data[i]; + } + return *this; + } + + ByteBuffer& operator<<(const PlayerInfo& a_Data); + ByteBuffer& operator>>(PlayerInfo& a_Data); +}; + +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/PacketData.h b/include/blitz/protocol/PacketData.h new file mode 100644 index 0000000..0587af7 --- /dev/null +++ b/include/blitz/protocol/PacketData.h @@ -0,0 +1,72 @@ +#pragma once + +#include +#include +#include +#include + +namespace blitz { +namespace protocol { + +struct PlayerInfo { + PlayerID m_PlayerId; + godot::String m_PlayerName; +}; + +namespace data { + +struct PlayerLogin { + godot::String m_PlayerName; +}; + +struct UpdateHealth { + float m_NewHealth; +}; + +struct LoggingSuccess { + PlayerID m_PlayerId; +}; + +struct PlayerDeath {}; + +struct PlayerJoin { + PlayerInfo m_Player; +}; + +struct PlayerLeave { + PlayerID m_PlayerId; +}; + +struct PlayerStats {}; + +struct PlayerList { + std::vector m_Players; +}; + +struct ServerConfig {}; + +struct ServerTps {}; + +struct UpdateGameState {}; + +struct KeepAlive { + std::uint64_t m_KeepAliveId; +}; + +struct Disconnect {}; + +struct ChatMessage { + godot::String m_Text; +}; + +struct PlayerPositionAndRotation { + PlayerID m_Player; + godot::Vector3 m_Position; + godot::Vector3 m_Rotation; +}; + +struct PlayerShoot {}; + +} // namespace data +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/PacketDeclare.h b/include/blitz/protocol/PacketDeclare.h new file mode 100644 index 0000000..a4340cb --- /dev/null +++ b/include/blitz/protocol/PacketDeclare.h @@ -0,0 +1,49 @@ +#pragma once + +/** + * \file PacketDeclare.h + * \brief Holds the definitions of the packets (but not their content) + */ + +namespace blitz { +namespace protocol { + +/** + * \enum PacketSender + * \brief Indicate who should send a packet + */ +enum class PacketSender { + /** Sent by clients and server */ + Both, + /** Sent by clients to the server */ + Client, + /** Sent by server to the clients */ + Server, +}; + + +/** + * \def DeclareAllPacket + * \brief Avoids repetitive operations on packets + */ +#define DeclareAllPacket() \ + DeclarePacket(ChatMessage, Reliable, Both) \ + DeclarePacket(Disconnect, Reliable, Both) \ + DeclarePacket(KeepAlive, Reliable, Both) \ + DeclarePacket(LoggingSuccess, Reliable, Server) \ + DeclarePacket(PlayerDeath, Reliable, Server) \ + DeclarePacket(PlayerJoin, Reliable, Server) \ + DeclarePacket(PlayerLeave, Reliable, Server) \ + DeclarePacket(PlayerList, Reliable, Server) \ + DeclarePacket(PlayerLogin, Reliable, Client) \ + DeclarePacket(PlayerPositionAndRotation, Reliable, Both) \ + DeclarePacket(PlayerShoot, Reliable, Both) \ + DeclarePacket(PlayerStats, Reliable, Server) \ + DeclarePacket(ServerConfig, Reliable, Server) \ + DeclarePacket(ServerTps, Reliable, Server) \ + DeclarePacket(UpdateGameState, Reliable, Server) \ + DeclarePacket(UpdateHealth, Reliable, Client) + + +} // namespace protocol +} // namespace blitz \ No newline at end of file diff --git a/include/blitz/protocol/PacketDispatcher.h b/include/blitz/protocol/PacketDispatcher.h new file mode 100644 index 0000000..4e9b32d --- /dev/null +++ b/include/blitz/protocol/PacketDispatcher.h @@ -0,0 +1,58 @@ +#pragma once + +/** + * \file PacketDispatcher.h + * \brief File containing the blitz::protocol::PacketDispatcher class + */ + +#include +#include + +#include + +namespace blitz { +namespace protocol { + +class PacketHandler; + +/** + * \class PacketDispatcher + * \brief Class used to dispatch packets + */ +class PacketDispatcher : private NonCopyable { + private: + std::map> m_Handlers; + + public: + /** + * \brief Constructor + */ + PacketDispatcher() {} + + /** + * \brief Dispatch a packet + * \param packet The packet to dispatch + */ + void Dispatch(const Packet& packet); + + /** + * \brief Register a packet handler + * \param type The packet type + * \param handler The packet handler + */ + void RegisterHandler(PacketType type, PacketHandler& handler); + /** + * \brief Unregister a packet handler + * \param type The packet type + * \param handler The packet handler + */ + void UnregisterHandler(PacketType type, PacketHandler& handler); + /** + * \brief Unregister a packet handler + * \param handler The packet handler + */ + void UnregisterHandler(PacketHandler& handler); +}; + +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/PacketFactory.h b/include/blitz/protocol/PacketFactory.h new file mode 100644 index 0000000..88ed43f --- /dev/null +++ b/include/blitz/protocol/PacketFactory.h @@ -0,0 +1,21 @@ +#pragma once + +#include +#include + +namespace blitz { +namespace protocol { +namespace PacketFactory { + +template::value>::type> +std::unique_ptr CreatePacket() { + return std::make_unique(); +} + +const std::unique_ptr& CreateReadOnlyPacket(PacketType a_Type); + +void Init(); + +} // namespace PacketFactory +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/PacketHandler.h b/include/blitz/protocol/PacketHandler.h new file mode 100644 index 0000000..e99b731 --- /dev/null +++ b/include/blitz/protocol/PacketHandler.h @@ -0,0 +1,34 @@ +#pragma once + +/** + * \file PacketHandler.h + * \brief File containing the blitz::protocol::PacketHandler class + */ + +#include +#include + +namespace blitz { +namespace protocol { + +class PacketDispatcher; + +#define DeclarePacket(PacketName, ...) virtual void Visit(const packets::PacketName&); virtual void HandlePacket(const packets::PacketName&) {} + +/** + * \class PacketHandler + * \brief Class used to handle packets + */ +class PacketHandler : public PacketVisitor { + public: + PacketHandler() {} + ~PacketHandler() {} + + DeclareAllPacket() + +}; + +#undef DeclarePacket + +} // namespace protocol +} // namespace blitz \ No newline at end of file diff --git a/include/blitz/protocol/PacketSerializer.h b/include/blitz/protocol/PacketSerializer.h new file mode 100644 index 0000000..f797525 --- /dev/null +++ b/include/blitz/protocol/PacketSerializer.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include + +namespace blitz { +namespace protocol { + +using PacketPtr = std::unique_ptr; + +namespace PacketSerializer { + +godot::PackedByteArray Serialize(const Packet& a_Packet); + +std::unique_ptr Deserialize(godot::PackedByteArray& a_Data); + +} +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/PacketVisitor.h b/include/blitz/protocol/PacketVisitor.h new file mode 100644 index 0000000..1f41f53 --- /dev/null +++ b/include/blitz/protocol/PacketVisitor.h @@ -0,0 +1,39 @@ +#pragma once + +/** + * \file PacketVisitor.h + * \brief File containing the blitz::protocol::PacketVisitor class + */ + +#include + +namespace blitz { +namespace protocol { + +#define DeclarePacket(PacketName, ...) \ + /** This function is called when the packet processed by PacketVisitor::Check is a PacketName */ \ + virtual void Visit(const packets::PacketName&) {} + +/** + * \class PacketVisitor + * \brief This class uses double-dispatch in order to find the real type of a packet + */ +class PacketVisitor : private NonCopyable { + protected: + PacketVisitor() {} + virtual ~PacketVisitor() {} + + public: + /** + * \brief Calls the right PacketVisitor::Visit method corresponding to the real type of the packet + * \param packet the Packet to visit + */ + void Check(const Packet& packet); + + DeclareAllPacket() +}; + +#undef DeclarePacket + +} // namespace protocol +} // namespace blitz diff --git a/include/blitz/protocol/Packets.h b/include/blitz/protocol/Packets.h new file mode 100644 index 0000000..f0d47f6 --- /dev/null +++ b/include/blitz/protocol/Packets.h @@ -0,0 +1,112 @@ +#pragma once + +/** + * \file Packets.h + * \brief File containing the definitions of the packets + */ + +#include +#include +#include + +namespace blitz { +namespace protocol { + +class PacketVisitor; + +/** A Packet id is 8 bits wide */ +using PacketID = std::uint8_t; + +#define DeclarePacket(PacketName, ...) /** PacketName */ PacketName, + +/** + * \enum PacketType + * \brief Map a Packet to an id + */ +enum class PacketType : PacketID { + + DeclareAllPacket() + + /** The number of packets */ + PACKET_COUNT +}; + + +#undef DeclarePacket + + +class Packet : private NonCopyable { + public: + /** + * \return The real type of the packet + */ + virtual PacketType GetType() const = 0; + + /** + * \brief The network peer who sent the packet + */ + PeerID m_Sender; + + private: + /** Use a PacketVisitor to make double-dispatch possible */ + virtual void Accept(PacketVisitor& a_Visitor) const = 0; + + friend class PacketVisitor; +}; + + + + + +namespace packets { + +/** + * \class ConcretePacket + * \brief A Packet associated with an id and holding data + * \tparam PT The packet type + * \tparam Data The structure holding the data of the packet (in blitz::protocol::data namespace) + */ +template +class ConcretePacket : public Packet { + public: + /** The type of the struct holding the data */ + using PacketDataType = Data; + + /** The structure holding the actual data */ + PacketDataType m_Data; + + /** Construct the packet with data of type PacketDataType */ + ConcretePacket(const PacketDataType& a_Data = {}); + + constexpr PacketType GetType() const override { + return PT; + }; + + private: + void Accept(PacketVisitor& a_Visitor) const override; +}; + + + + + +// define BLITZ_INSTANCIATE_PACKETS +// before including this file +// if you want to instantiate templates +#ifdef BLITZ_INSTANCIATE_PACKETS +#define DeclarePacket(PacketName, ...) \ + using PacketName = ConcretePacket; \ + template class ConcretePacket; +#else +#define DeclarePacket(PacketName, ...) /** Defines the PacketName packet */ \ + using PacketName = ConcretePacket; +#endif + +DeclareAllPacket() + +#undef DeclarePacket + +} // namespace packets + +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/ByteBuffer.cpp b/src/blitz/protocol/ByteBuffer.cpp new file mode 100644 index 0000000..1916f7e --- /dev/null +++ b/src/blitz/protocol/ByteBuffer.cpp @@ -0,0 +1,49 @@ +#include + +#include + +namespace blitz { +namespace protocol { + +ByteBuffer& ByteBuffer::operator>>(PlayerInfo& a_Data) { + *this >> a_Data.m_PlayerId >> a_Data.m_PlayerName; + return *this; +} + +ByteBuffer& ByteBuffer::operator<<(const PlayerInfo& a_Data) { + *this << a_Data.m_PlayerId << a_Data.m_PlayerName; + return *this; +} + +ByteBuffer& ByteBuffer::operator<<(const godot::Vector3& a_Data) { + *this << a_Data.x << a_Data.y << a_Data.z; + return *this; +} + +ByteBuffer& ByteBuffer::operator>>(godot::Vector3& a_Data) { + *this >> a_Data.x >> a_Data.y >> a_Data.z; + return *this; +} + +ByteBuffer& ByteBuffer::operator>>(godot::String& a_Data) { + int nullPos = m_Buffer.find(0, m_ReadOffset); + // TODO: error handling + if (nullPos < 0) + return *this; + + godot::PackedByteArray stringBuffer = m_Buffer.slice(m_ReadOffset, nullPos); + a_Data = stringBuffer.get_string_from_utf8(); + m_ReadOffset = nullPos + 1; + return *this; +} + +ByteBuffer& ByteBuffer::operator<<(const godot::String& a_Data) { + godot::PackedByteArray stringBuffer = a_Data.to_utf8_buffer(); + m_Buffer.append_array(stringBuffer); + // ends the string + *this << static_cast(0); + return *this; +} + +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/PacketDispatcher.cpp b/src/blitz/protocol/PacketDispatcher.cpp new file mode 100644 index 0000000..b704fa3 --- /dev/null +++ b/src/blitz/protocol/PacketDispatcher.cpp @@ -0,0 +1,37 @@ +#include + +#include +#include + +namespace blitz { +namespace protocol { + +void PacketDispatcher::RegisterHandler(PacketType type, PacketHandler& handler) { + auto found = std::find(m_Handlers[type].begin(), m_Handlers[type].end(), &handler); + if (found == m_Handlers[type].end()) + m_Handlers[type].push_back(&handler); +} + +void PacketDispatcher::UnregisterHandler(PacketType type, PacketHandler& handler) { + m_Handlers[type].erase(std::remove(m_Handlers[type].begin(), m_Handlers[type].end(), &handler), m_Handlers[type].end()); +} + +void PacketDispatcher::UnregisterHandler(PacketHandler& handler) { + for (auto& pair : m_Handlers) { + if (pair.second.empty()) + continue; + + PacketType type = pair.first; + + m_Handlers[type].erase(std::remove(m_Handlers[type].begin(), m_Handlers[type].end(), &handler), m_Handlers[type].end()); + } +} + +void PacketDispatcher::Dispatch(const Packet& packet) { + PacketType type = packet.GetType(); + for (PacketHandler* handler : m_Handlers[type]) + handler->Check(packet); +} + +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/PacketFactory.cpp b/src/blitz/protocol/PacketFactory.cpp new file mode 100644 index 0000000..d21743f --- /dev/null +++ b/src/blitz/protocol/PacketFactory.cpp @@ -0,0 +1,32 @@ +#include + +#include +#include +#include + +namespace blitz { +namespace protocol { +namespace PacketFactory { + +using PacketCreator = std::function()>; + +#define DeclarePacket(PacketName, ...) std::make_unique(), + +static std::array, static_cast(PacketType::PACKET_COUNT)> Packets; + +void Init() { + Packets = { + + DeclareAllPacket() + + }; +} + +const std::unique_ptr& CreateReadOnlyPacket(PacketType a_Type) { + assert(a_Type < PacketType::PACKET_COUNT); + return Packets[static_cast(a_Type)]; +} + +} // namespace PacketFactory +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/PacketHandler.cpp b/src/blitz/protocol/PacketHandler.cpp new file mode 100644 index 0000000..4d68fbc --- /dev/null +++ b/src/blitz/protocol/PacketHandler.cpp @@ -0,0 +1,14 @@ +#include + +namespace blitz { +namespace protocol { + +#define DeclarePacket(PacketName, ...) \ + void PacketHandler::Visit(const packets::PacketName& a_Packet) { \ + HandlePacket(a_Packet); \ + } + +DeclareAllPacket() + +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/PacketSerializer.cpp b/src/blitz/protocol/PacketSerializer.cpp new file mode 100644 index 0000000..74b7bb1 --- /dev/null +++ b/src/blitz/protocol/PacketSerializer.cpp @@ -0,0 +1,294 @@ +#include + +#include +#include +#include + +#include +#include + +namespace blitz { +namespace protocol { +namespace PacketSerializer { + +#define DeclarePacket(PacketName, ...) \ + void Visit(const packets::PacketName& a_Packet) override { \ + const auto& packetData = a_Packet.m_Data; \ + SerializePacketData(packetData); \ + } \ + \ + void SerializePacketData(const packets::PacketName::PacketDataType& a_Packet); + + + + +class Serializer : public PacketVisitor { + private: + ByteBuffer& m_Buffer; + + public: + Serializer(ByteBuffer& a_Buffer) : m_Buffer(a_Buffer) {} + + void Serialize(const Packet& a_Packet) { + m_Buffer << static_cast(a_Packet.GetType()); + Check(a_Packet); + } + + DeclareAllPacket() +}; + +#undef DeclarePacket + + + + + +#define DeclarePacket(PacketName, ...) \ + void Visit(const packets::PacketName& a_Packet) override { \ + auto packetPtr = PacketFactory::CreatePacket(); \ + auto& packetData = packetPtr->m_Data; \ + \ + DeserializePacketData(packetData); \ + \ + m_Packet = std::move(packetPtr); \ + } \ + \ + void DeserializePacketData(packets::PacketName::PacketDataType& a_Packet); + + + +class Deserializer : public PacketVisitor { + private: + ByteBuffer& m_Buffer; + PacketPtr m_Packet; + + public: + Deserializer(ByteBuffer&& a_Buffer) : m_Buffer(a_Buffer) {} + + bool Deserialize(const PacketPtr& a_Packet) { + try { + Check(*a_Packet.get()); + } catch (std::exception& e) { + return false; + } + return true; + } + + PacketPtr& GetPacket() { + return m_Packet; + } + + DeclareAllPacket() +}; + + + + + +godot::PackedByteArray Serialize(const Packet& a_Packet) { + ByteBuffer stream; + + Serializer serializer(stream); + serializer.Serialize(a_Packet); + + return stream.GetByteArray(); +} + +std::unique_ptr Deserialize(godot::PackedByteArray& a_Data) { + ByteBuffer stream(std::move(a_Data)); + + PacketID packetId; + stream >> packetId; + + if (packetId >= static_cast(PacketType::PACKET_COUNT)) + return nullptr; + + PacketType packetType = PacketType(packetId); + + // for double-dispatch + const PacketPtr& emptyPacket = PacketFactory::CreateReadOnlyPacket(packetType); + + Deserializer deserializer(std::move(stream)); + if (deserializer.Deserialize(emptyPacket)) { + PacketPtr packet = std::move(deserializer.GetPacket()); + return packet; + } + + return nullptr; +} + + + + + +//--------------------------------------------- +// Packet serializer implementation +//---------------------------------------------- + + + + + +void Serializer::SerializePacketData(const data::PlayerLogin& a_Packet) { + m_Buffer << a_Packet.m_PlayerName; +} + +void Deserializer::DeserializePacketData(data::PlayerLogin& a_Packet) { + m_Buffer >> a_Packet.m_PlayerName; +} + + + + +void Serializer::SerializePacketData(const data::UpdateHealth& a_Packet) { + m_Buffer << a_Packet.m_NewHealth; +} + +void Deserializer::DeserializePacketData(data::UpdateHealth& a_Packet) { + m_Buffer >> a_Packet.m_NewHealth; +} + + + + +void Serializer::SerializePacketData(const data::LoggingSuccess& a_Packet) { + m_Buffer << a_Packet.m_PlayerId; +} + +void Deserializer::DeserializePacketData(data::LoggingSuccess& a_Packet) { + m_Buffer >> a_Packet.m_PlayerId; +} + + + + +void Serializer::SerializePacketData(const data::PlayerDeath& a_Packet) {} + +void Deserializer::DeserializePacketData(data::PlayerDeath& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::PlayerJoin& a_Packet) { + m_Buffer << a_Packet.m_Player; +} + +void Deserializer::DeserializePacketData(data::PlayerJoin& a_Packet) { + m_Buffer >> a_Packet.m_Player; +} + + + + +void Serializer::SerializePacketData(const data::PlayerLeave& a_Packet) { + m_Buffer << a_Packet.m_PlayerId; +} + +void Deserializer::DeserializePacketData(data::PlayerLeave& a_Packet) { + m_Buffer >> a_Packet.m_PlayerId; +} + + + + +void Serializer::SerializePacketData(const data::PlayerList& a_Packet) { + m_Buffer << a_Packet.m_Players; + // m_Buffer << static_cast(a_Packet.m_Players.size()); + // for (auto player : a_Packet.m_Players) { + // m_Buffer << player.m_PlayerId << player.m_PlayerName; + // } +} + +void Deserializer::DeserializePacketData(data::PlayerList& a_Packet) { + m_Buffer >> a_Packet.m_Players; + // std::uint8_t playerCount; + // m_Buffer >> playerCount; + // for (std::uint8_t i = 0; i < playerCount; i++) { + // PlayerInfo player; + // m_Buffer >> player.m_PlayerId >> player.m_PlayerName; + // a_Packet.m_Players.push_back(player); + // } +} + + + + +void Serializer::SerializePacketData(const data::PlayerStats& a_Packet) {} + +void Deserializer::DeserializePacketData(data::PlayerStats& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::ServerConfig& a_Packet) {} + +void Deserializer::DeserializePacketData(data::ServerConfig& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::ServerTps& a_Packet) {} + +void Deserializer::DeserializePacketData(data::ServerTps& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::UpdateGameState& a_Packet) {} + +void Deserializer::DeserializePacketData(data::UpdateGameState& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::KeepAlive& a_Packet) { + m_Buffer << a_Packet.m_KeepAliveId; +} + +void Deserializer::DeserializePacketData(data::KeepAlive& a_Packet) { + m_Buffer >> a_Packet.m_KeepAliveId; +} + + + + +void Serializer::SerializePacketData(const data::Disconnect& a_Packet) {} + +void Deserializer::DeserializePacketData(data::Disconnect& a_Packet) {} + + + + +void Serializer::SerializePacketData(const data::ChatMessage& a_Packet) { + m_Buffer << a_Packet.m_Text; +} + +void Deserializer::DeserializePacketData(data::ChatMessage& a_Packet) { + m_Buffer >> a_Packet.m_Text; +} + + + + +void Serializer::SerializePacketData(const data::PlayerPositionAndRotation& a_Packet) { + m_Buffer << a_Packet.m_Player << a_Packet.m_Position << a_Packet.m_Rotation; +} + +void Deserializer::DeserializePacketData(data::PlayerPositionAndRotation& a_Packet) { + m_Buffer >> a_Packet.m_Player >> a_Packet.m_Position >> a_Packet.m_Rotation; +} + + + + +void Serializer::SerializePacketData(const data::PlayerShoot& a_Packet) {} + +void Deserializer::DeserializePacketData(data::PlayerShoot& a_Packet) {} + + + + + +} // namespace PacketSerializer +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/PacketVisitor.cpp b/src/blitz/protocol/PacketVisitor.cpp new file mode 100644 index 0000000..90f1382 --- /dev/null +++ b/src/blitz/protocol/PacketVisitor.cpp @@ -0,0 +1,11 @@ +#include + +namespace blitz { +namespace protocol { + +void PacketVisitor::Check(const Packet& a_Packet) { + a_Packet.Accept(*this); +} + +} // namespace protocol +} // namespace blitz diff --git a/src/blitz/protocol/Packets.cpp b/src/blitz/protocol/Packets.cpp new file mode 100644 index 0000000..84913b0 --- /dev/null +++ b/src/blitz/protocol/Packets.cpp @@ -0,0 +1,18 @@ +#define BLITZ_INSTANCIATE_PACKETS +#include + +#include + +namespace blitz { +namespace protocol { + +template +packets::ConcretePacket::ConcretePacket(const PacketDataType& a_Data) : m_Data(a_Data) {} + +template +void packets::ConcretePacket::Accept(PacketVisitor& a_Visitor) const { + a_Visitor.Visit(*this); +} + +} // namespace protocol +} // namespace blitz diff --git a/xmake/target.lua b/xmake/target.lua index f5d56a4..8ce9c00 100644 --- a/xmake/target.lua +++ b/xmake/target.lua @@ -14,6 +14,8 @@ target(PROJECT_NAME) -- more on https://xmake.io/#/manual/project_target?id=targetadd_files add_files("../src/**.cpp") + add_includedirs("../include") + -- change the output name set_basename(PROJECT_NAME .. ".$(os)_$(mode)_$(arch)")