glm backwards compatibility

[blank.git] / src / net / Packet.hpp

diff --git a/src/net/Packet.hpp b/src/net/Packet.hpp
index 7b9b69e447289efbd2831503f5e3ea2689ce64e4..d7da977275e810e3298808cef8ea3a1b324031c4 100644 (file)
--- a/src/net/Packet.hpp
+++ b/src/net/Packet.hpp
@@ -1,11 +1,12 @@
 #ifndef BLANK_NET_PACKET_HPP_
 #define BLANK_NET_PACKET_HPP_
 
+#include "../graphics/glm.hpp"
+
 #include <cstdint>
 #include <ostream>
 #include <string>
 #include <SDL_net.h>
-#include <glm/glm.hpp>
 
 
 namespace blank {
@@ -73,8 +74,28 @@ struct Packet {
                template<class T>
                void Read(T &, size_t off) const noexcept;
 
+               void Write(const glm::quat &, size_t off) noexcept;
+               void Read(glm::quat &, size_t off) const noexcept;
+               void Write(const EntityState &, size_t off) noexcept;
+               void Read(EntityState &, size_t off) const noexcept;
+               void Write(const EntityState &, const glm::ivec3 &, size_t off) noexcept;
+               void Read(EntityState &, const glm::ivec3 &, size_t off) const noexcept;
+
                void WriteString(const std::string &src, std::size_t off, std::size_t maxlen) noexcept;
                void ReadString(std::string &dst, std::size_t off, std::size_t maxlen) const noexcept;
+
+               void WritePackB(const glm::ivec3 &, size_t off) noexcept;
+               void ReadPackB(glm::ivec3 &, size_t off) const noexcept;
+
+               void WritePackN(float, size_t off) noexcept;
+               void ReadPackN(float &, size_t off) const noexcept;
+               void WritePackN(const glm::vec3 &, size_t off) noexcept;
+               void ReadPackN(glm::vec3 &, size_t off) const noexcept;
+
+               void WritePackU(float, size_t off) noexcept;
+               void ReadPackU(float &, size_t off) const noexcept;
+               void WritePackU(const glm::vec3 &, size_t off) noexcept;
+               void ReadPackU(glm::vec3 &, size_t off) const noexcept;
        };
 
        struct Ping : public Payload {
@@ -92,7 +113,7 @@ struct Packet {
 
        struct Join : public Payload {
                static constexpr std::uint8_t TYPE = 2;
-               static constexpr std::size_t MAX_LEN = 100;
+               static constexpr std::size_t MAX_LEN = 78;
 
                void WritePlayer(const Entity &) noexcept;
                void ReadPlayerID(std::uint32_t &) const noexcept;
@@ -108,16 +129,12 @@ struct Packet {
 
        struct PlayerUpdate : public Payload {
                static constexpr std::uint8_t TYPE = 4;
-               static constexpr std::size_t MAX_LEN = 76;
+               static constexpr std::size_t MAX_LEN = 50;
 
                void WritePredictedState(const EntityState &) noexcept;
                void ReadPredictedState(EntityState &) const noexcept;
                void WriteMovement(const glm::vec3 &) noexcept;
                void ReadMovement(glm::vec3 &) const noexcept;
-               void WritePitch(float) noexcept;
-               void ReadPitch(float &) const noexcept;
-               void WriteYaw(float) noexcept;
-               void ReadYaw(float &) const noexcept;
                void WriteActions(std::uint8_t) noexcept;
                void ReadActions(std::uint8_t &) const noexcept;
                void WriteSlot(std::uint8_t) noexcept;
@@ -126,11 +143,11 @@ struct Packet {
 
        struct SpawnEntity : public Payload {
                static constexpr std::uint8_t TYPE = 5;
-               static constexpr std::size_t MAX_LEN = 132;
+               static constexpr std::size_t MAX_LEN = 110;
 
                void WriteEntity(const Entity &) noexcept;
                void ReadEntityID(std::uint32_t &) const noexcept;
-               void ReadSkeletonID(std::uint32_t &) const noexcept;
+               void ReadModelID(std::uint32_t &) const noexcept;
                void ReadEntity(Entity &) const noexcept;
        };
 
@@ -144,24 +161,26 @@ struct Packet {
 
        struct EntityUpdate : public Payload {
                static constexpr std::uint8_t TYPE = 7;
-               static constexpr std::size_t MAX_LEN = 480;
+               static constexpr std::size_t MAX_LEN = 460;
 
-               static constexpr std::uint32_t MAX_ENTITIES = 7;
+               static constexpr std::uint32_t MAX_ENTITIES = 12;
                static constexpr std::size_t GetSize(std::uint32_t num) noexcept {
-                       return 4 + (num * 68);
+                       return 16 + (num * 37);
                }
 
                void WriteEntityCount(std::uint32_t) noexcept;
                void ReadEntityCount(std::uint32_t &) const noexcept;
+               void WriteChunkBase(const glm::ivec3 &) noexcept;
+               void ReadChunkBase(glm::ivec3 &) const noexcept;
 
-               void WriteEntity(const Entity &, std::uint32_t) noexcept;
+               void WriteEntity(const Entity &, const glm::ivec3 &, std::uint32_t) noexcept;
                void ReadEntityID(std::uint32_t &, std::uint32_t) const noexcept;
-               void ReadEntityState(EntityState &, std::uint32_t) const noexcept;
+               void ReadEntityState(EntityState &, const glm::ivec3 &, std::uint32_t) const noexcept;
        };
 
        struct PlayerCorrection : public Payload {
                static constexpr std::uint8_t TYPE = 8;
-               static constexpr std::size_t MAX_LEN = 66;
+               static constexpr std::size_t MAX_LEN = 44;
 
                void WritePacketSeq(std::uint16_t) noexcept;
                void ReadPacketSeq(std::uint16_t &) const noexcept;
@@ -188,6 +207,10 @@ struct Packet {
                static constexpr std::size_t MAX_LEN = MAX_PAYLOAD_LEN;
                static constexpr std::size_t MAX_DATA_LEN = MAX_LEN - 12;
 
+               static constexpr std::size_t GetSize(std::size_t data_len) noexcept {
+                       return data_len + 12;
+               }
+
                void WriteTransmissionId(std::uint32_t) noexcept;
                void ReadTransmissionId(std::uint32_t &) const noexcept;
                void WriteDataOffset(std::uint32_t) noexcept;
@@ -218,6 +241,23 @@ struct Packet {
                void ReadBlock(Block &, std::uint32_t) const noexcept;
        };
 
+       struct Message : public Payload {
+               static constexpr std::uint8_t TYPE = 12;
+               static constexpr std::size_t MAX_LEN = 455;
+
+               static constexpr std::size_t MAX_MESSAGE_LEN = 450;
+               static std::size_t GetSize(const std::string &msg) noexcept {
+                       return 5 + std::min(msg.size() + 1, MAX_MESSAGE_LEN);
+               }
+
+               void WriteType(std::uint8_t) noexcept;
+               void ReadType(std::uint8_t &) const noexcept;
+               void WriteReferral(std::uint32_t) noexcept;
+               void ReadReferral(std::uint32_t &) const noexcept;
+               void WriteMessage(const std::string &) noexcept;
+               void ReadMessage(std::string &) const noexcept;
+       };
+
 
        template<class PayloadType>
        PayloadType As() {