net_session.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
#include "ecs/component/core/transform.h"
#include "ecs/entity.h"
#include "net/net_client.h"
#include "net/net_server.h"
#include "net/prediction/command.h"
#include "net/transport/connection.h"
#include "net/wire/bit_stream.h"
#include "net/wire/protocol.h"
#include "platform/net/udp_socket.h"
 
namespace Vkm::Engine {
 
class Scene;
class ResourceManager;

constexpr float NET_SNAPSHOT_RATE = 64.0f;

constexpr float NET_COMMAND_RATE = 64.0f;

constexpr uint32_t NET_MAX_TICK_RATE = static_cast<uint32_t>(2.0f * NET_COMMAND_RATE);

struct NetCore {
    static constexpr size_t MAX_READS_PER_FRAME = 512;
 
    UdpSocket socket;
    uint32_t  tickRate = 0;  
 
    uint32_t actionCount = 0;

    uint64_t actionNames = 0;
    bool     ticked      = false;  
 
    uint64_t world = 0;  

    uint32_t serverTick = 0;
 
    std::string lastError;
 
    std::vector<uint8_t>  scratch;
    std::vector<uint8_t>  payload;   
    std::vector<uint8_t>  datagram;  
    std::vector<uint16_t> acknowledged;
};

void sendBare(NetCore& core, NetConnection& connection, NetMessage message, uint64_t token);

BitReader receivedPayload(const NetCore& core);

class NetSession {
    public:
        class Drawn {
            public:
                Drawn(NetSession& session, Scene& scene, float deltaTime);
                ~Drawn();
 
                Drawn(const Drawn& other) = delete;
                Drawn& operator=(const Drawn& other) = delete;
 
                Drawn(Drawn && other) = delete;
                Drawn& operator=(Drawn && other) = delete;
 
            private:
                NetSession& m_session;
                Scene&      m_scene;
        };

        class Rewind {
            public:
                Rewind(NetSession& session, Scene& scene, EntityId shooter);
                ~Rewind();
 
                Rewind(const Rewind& other) = delete;
                Rewind& operator=(const Rewind& other) = delete;
 
                Rewind(Rewind && other) = delete;
                Rewind& operator=(Rewind && other) = delete;
 
            private:
                NetSession& m_session;
                Scene&      m_scene;
        };
 
    public:
        NetSession();
        ~NetSession();
 
        NetSession(const NetSession& other) = delete;
        NetSession& operator=(const NetSession& other) = delete;
 
        NetSession(NetSession && other) = delete;
        NetSession& operator=(NetSession && other) = delete;
 
    public:
        void setWorld(uint64_t fingerprint) { m_core.world = fingerprint; }

        bool host(uint16_t port, uint32_t maxPlayers, uint32_t tickRate);

        bool connect(const NetAddress& server, uint32_t tickRate);

        void close();

        void onSpawn(NetServer::SpawnPlayer spawn, NetServer::DespawnPlayer despawn);
 
    public:
        NetRole  role() const { return m_role; }
        bool     isOffline() const { return m_role == NetRole::Offline; }

        bool     isDisconnected() const { return m_role == NetRole::Disconnected; }

        bool isPlaying() const;

        const std::string& lastError() const { return m_core.lastError; }
 
        PlayerId localPlayer() const { return m_client.localPlayer(); }

        NetAddress localAddress() const { return m_core.socket.localAddress(); }

        EntityId localEntity() const { return m_client.localEntity(); }

        float roundTrip() const;

        size_t playerCount() const;
 
    public:
        bool simulates(EntityId entity) const;

        void lease(const std::vector<EntityId>& entities) { m_client.lease(entities); }

        size_t leaseCount() const { return m_client.leaseCount(); }

        bool isMine(EntityId entity) const;

        const InputCommand& commandFor(EntityId entity) const;
 
    public:
        void receive(Scene& scene, ResourceManager& resources);

        const std::vector<InputCommand>& replayCommands() const { return m_client.replayCommands(); }

        void beginReplayTick(const InputCommand& command);

        void endReplay(Scene& scene) { m_client.endReplay(scene); }

        bool replaying() const { return m_client.replaying(); }

        void endTick(Scene& scene, uint32_t tick);

        void beginTick(
            uint32_t tick,
            const InputCommand& command,
            uint32_t actionCount,
            uint64_t actionNames = 0
        );

        void send(Scene& scene, uint32_t tick);

        EntityId spawn(
            Scene& scene,
            ResourceManager& resources,
            const std::string& prefab,
            const Transform& at
        );

        void advance(float seconds);

        void interpolate(Scene& scene, float deltaTime);

        float renderDelay() const;

        float pacing() const;

        float predictionError() const { return m_client.predictionError(); }
 
    public:
        std::string describe() const;
 
    private:
        bool acceptsTickRate(uint32_t tickRate);

        void disconnect();

        void forgetWorld();
 
        void beginRewind(Scene& scene, EntityId shooter);
        void endRewind(Scene& scene);
 
    private:
        NetCore   m_core;
        NetServer m_server;
        NetClient m_client;
        NetRole   m_role = NetRole::Offline;

        InputCommand m_currentCommand;

        float m_sendAccumulator = 1.0f;
 
        uint32_t m_rewindDepth = 0;  
        EntityId m_rewoundFor;       
 
        uint64_t m_worldEpoch = 0;  
};
 
} // namespace Vkm::Engine