GamerulePacket.hpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2025
** Created on 07/01/2026.
** File description:
** GamerulePacket.hpp
*/
 
#pragma once
 
#include <capnp/message.h>
#include <capnp/serialize.h>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <vector>
#include "schemas/s2c_messages.capnp.h"
 
namespace RType::Messages::S2C {
 
    struct Gamerule {
        std::string key;
        float value;
 
        Gamerule() : value(0.0f) {}
        Gamerule(const std::string &k, float v) : key(k), value(v) {}
    };
 
    class GamerulePacket {
       public:
        GamerulePacket() = default;
 
        void addGamerule(const std::string &key, float value) { gamerules[key] = value; }
 
        void addGamerule(const Gamerule &gamerule) { gamerules[gamerule.key] = gamerule.value; }
 
        [[nodiscard]] const std::unordered_map<std::string, float> &getGamerules() const { return gamerules; }
 
        [[nodiscard]] bool hasGamerule(const std::string &key) const {
            return gamerules.find(key) != gamerules.end();
        }
 
        [[nodiscard]] float getGamerule(const std::string &key, float defaultValue = 0.0f) const {
            auto it = gamerules.find(key);
            return (it != gamerules.end()) ? it->second : defaultValue;
        }
 
        void clear() { gamerules.clear(); }
 
        [[nodiscard]] size_t size() const { return gamerules.size(); }
 
        [[nodiscard]] std::vector<uint8_t> serialize() const {
            capnp::MallocMessageBuilder message;
            auto builder = message.initRoot<::GamerulePacket>();
 
            // Build gamerules list
            auto gamerulesBuilder = builder.initGamerules(static_cast<unsigned int>(gamerules.size()));
            unsigned int i = 0;
            for (const auto &[key, value] : gamerules) {
                auto gameruleBuilder = gamerulesBuilder[i];
                gameruleBuilder.setKey(key);
                gameruleBuilder.setValue(value);
                ++i;
            }
 
            auto bytes = capnp::messageToFlatArray(message);
            auto byteArray = bytes.asBytes();
            return std::vector(byteArray.begin(), byteArray.end());
        }
 
        static GamerulePacket deserialize(const std::vector<uint8_t> &data) {
            // Ensure buffer is word-aligned for Cap'n Proto (undefined behavior if not)
            KJ_REQUIRE(data.size() % sizeof(capnp::word) == 0,
                       "Serialized data size must be a multiple of capnp::word");
            auto aligned = kj::heapArray<uint8_t>(data.size());
            memcpy(aligned.begin(), data.data(), data.size());
            kj::ArrayPtr words(reinterpret_cast<const capnp::word *>(aligned.begin()),
                               data.size() / sizeof(capnp::word));
 
            capnp::FlatArrayMessageReader message(words);
            auto reader = message.getRoot<::GamerulePacket>();
 
            GamerulePacket result;
 
            // Deserialize gamerules list
            auto gamerarulesReader = reader.getGamerules();
            for (auto gameruleReader : gamerarulesReader) {
                std::string key = gameruleReader.getKey().cStr();
                float value = gameruleReader.getValue();
                result.addGamerule(key, value);
            }
 
            return result;
        }
 
       private:
        std::unordered_map<std::string, float> gamerules;
    };
 
}  // namespace RType::Messages::S2C