net_client.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
 
#include "ecs/component/core/transform.h"
#include "ecs/component/physics/rigidbody.h"
#include "ecs/entity.h"
#include "net/prediction/command.h"
#include "net/prediction/interpolation.h"
#include "net/prediction/pacing.h"
#include "net/transport/connection.h"
#include "net/wire/bit_stream.h"
#include "net/wire/protocol.h"
 
namespace Vkm::Engine {
 
class Scene;
class ResourceManager;
struct NetCore;
struct NetSpawn;

constexpr uint32_t NET_SPAWN_BUILDS_PER_FRAME = 8;

class NetClient {
    public:
        explicit NetClient(NetCore& core);
        ~NetClient();
 
        NetClient(const NetClient& other) = delete;
        NetClient& operator=(const NetClient& other) = delete;
 
        NetClient(NetClient && other) = delete;
        NetClient& operator=(NetClient && other) = delete;
 
    public:
        void open(const NetAddress& server);

        void close();
 
        void advance(float seconds);

        bool receive(Scene& scene, ResourceManager& resources);

        void send();

        bool simulates(EntityId entity) const;

        void lease(const std::vector<EntityId>& entities);

        void ageLeases();

        void beginTick(const InputCommand& command);

        void endTick(const Scene& scene, uint32_t tick);
 
        void beginReplayTick() { m_prediction.replaying = true; }

        void endReplay(const Scene& scene);
 
        void interpolate(Scene& scene, float deltaTime);

        void applyDrawCorrection(Scene& scene, float deltaTime);

        void removeDrawCorrection(Scene& scene);

        void forgetWorld();
 
        std::string describe() const;
 
    public:
        PlayerId localPlayer() const { return m_localPlayer; }
        EntityId localEntity() const { return m_localEntity; }

        bool isPlaying() const { return m_localPlayer != NO_PLAYER; }
 
        float roundTrip() const { return m_connection ? m_connection->roundTrip() : 0.0f; }
 
        size_t leaseCount() const { return m_prediction.leases.size(); }
 
        const std::vector<InputCommand>& replayCommands() const { return m_prediction.replay; }
 
        bool replaying() const { return m_prediction.replaying; }
 
        float predictionError() const { return m_prediction.error; }
 
        float renderDelay() const { return m_interpolation.behindTicks(); }
 
        float pacing() const { return m_prediction.pacing.scale(); }
 
    private:
        struct Predicted {
            uint32_t  tick = 0;
            glm::vec3 position{0.0f};
        };

        struct Lease {
            EntityId entity;
            uint32_t ticks = 0;
        };

        struct DrawCorrection {
            EntityId  entity;
            glm::vec3 offset;  
        };

        struct Held {
            EntityId  entity;
            Transform transform;
            Rigidbody body;
            bool      hasBody = false;
        };

        struct Prediction {
            std::vector<Predicted>      predicted;   
            float                       error = 0.0f;
            std::vector<InputCommand>   unacknowledged;  
            std::vector<InputCommand>   replay;      
            bool                        replaying = false;
 
            uint32_t                    heard = 0;   
            uint32_t                    sent  = 0;   

            NetPacing                   pacing;

            std::vector<Lease>          leases;
            std::vector<EntityId>       acquired;
            std::vector<EntityId>       released;

            std::vector<Held>           held;
            std::vector<DrawCorrection> corrections;
 
            bool warnedNoReplay = false;  
 
            void clear() { *this = Prediction{}; }
        };

        struct DrawnFrom {
            EntityId  entity;
            glm::vec3 drawn{0.0f};
        };
 
    private:
        bool onWelcome(Scene& scene, BitReader& reader);
        bool onRefuse(BitReader& reader);
        bool onGoodbye();
        void onSnapshot(Scene& scene, BitReader& reader);

        void holdPredicted(Scene& scene, std::vector<DrawnFrom>& takenFrom);

        void buildSpawned(Scene& scene, ResourceManager& resources);

        void buildInto(Scene& scene, ResourceManager& resources, EntityId root, const NetSpawn& spawn);

        void reconcile(Scene& scene, uint32_t confirmedTick);

        void restoreHeld(Scene& scene);
        void correctDraw(EntityId entity, const glm::vec3& drawn, const glm::vec3& simulated);
        void offsetDrawn(Scene& scene, EntityId entity, const glm::vec3& by);
        glm::vec3 drawOffsetFor(EntityId entity) const;

        bool adoptServerTick(uint32_t serverTick);
 
    private:
        NetCore& m_core;
 
        std::unique_ptr<NetConnection> m_connection;
 
        PlayerId m_localPlayer = NO_PLAYER;
        EntityId m_localEntity;
        uint64_t m_token = 0;  
 
        bool m_warnedTickJump = false;  

        Prediction m_prediction;
 
        NetInterpolation      m_interpolation;
        std::vector<uint32_t> m_touched;
};
 
} // namespace Vkm::Engine