snapshot.h

#pragma once
 
#include <cstdint>
#include <unordered_map>
#include <vector>
 
#include "ecs/entity.h"
#include "net/transport/connection.h"
#include "net/wire/schema.h"
 
namespace Vkm::Engine {
 
class NetSilenceMap;
class Scene;

class NetBaseline {
    public:
        struct Confirmed {
            std::vector<uint8_t> bytes;
            uint16_t             sequence = 0;  
            bool                 held     = false;
        };

        struct Pending {
            struct Change {
                EntityId             entity;    
                uint32_t             slot = 0;
                uint32_t             type = 0;
                std::vector<uint8_t> bytes;
            };
 
            uint16_t              sequence = 0;
            std::vector<Change>   changes;
            std::vector<EntityId> forgotten;  
        };
 
    public:
        NetBaseline() = default;
        ~NetBaseline() = default;
 
        NetBaseline(const NetBaseline& other) = delete;
        NetBaseline& operator=(const NetBaseline& other) = delete;
 
        NetBaseline(NetBaseline && other) = delete;
        NetBaseline& operator=(NetBaseline && other) = delete;
 
    public:
        const Confirmed* find(EntityId entity, uint32_t type) const;

        void hold(Pending && pending);

        void confirm(uint16_t sequence);

        void expire(uint16_t sequence);

        void gatherLost(const Scene& scene, std::vector<EntityId>& out) const;

        void clear() {
            m_entities.clear();
            m_pending.clear();
        }
 
        size_t knownEntities() const { return m_entities.size(); }
        size_t pendingSnapshots() const { return m_pending.size(); }
 
    private:
        struct EntityRecord {
            EntityId               entity;  
            std::vector<Confirmed> components;
        };
 
    private:
        std::unordered_map<uint32_t, EntityRecord> m_entities;
        std::vector<Pending>                       m_pending;
};

struct NetBudget {
    uint32_t bytes = static_cast<uint32_t>(NetConnection::MAX_PAYLOAD);

    EntityId owner;
};

struct NetSnapshotStats {
    uint32_t entitiesConsidered = 0;  
    uint32_t entitiesWritten    = 0;  
    uint32_t componentsWritten  = 0;  
    uint32_t entitiesDeferred   = 0;  
    uint32_t entitiesLost       = 0;  
    uint32_t bytesWritten       = 0;  
};

NetSnapshotStats writeSnapshot(
    const Scene& scene,
    const NetSchema& schema,
    const NetSilenceMap& silence,
    uint16_t sequence,
    const NetBudget& budget,
    NetBaseline& baseline,
    BitWriter& out
);

bool readSnapshot(
    Scene& scene,
    const NetSchema& schema,
    BitReader& in,
    std::vector<uint32_t>* touched = nullptr
);
 
} // namespace Vkm::Engine