net_server.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include "ecs/component/core/transform.h"
#include "ecs/entity.h"
#include "net/prediction/command.h"
#include "net/prediction/rewind.h"
#include "net/replication/silence.h"
#include "net/replication/snapshot.h"
#include "net/transport/connection.h"
#include "net/transport/join_cookie.h"
#include "net/wire/bit_stream.h"
#include "net/wire/protocol.h"
 
namespace Vkm::Engine {
 
class Scene;
class ResourceManager;
struct NetCore;

class NetServer {
    public:
        using SpawnPlayer = std::function<EntityId(Scene&, ResourceManager&, PlayerId)>;

        using DespawnPlayer = std::function<void(Scene&, ResourceManager&, PlayerId, EntityId)>;
 
    public:
        explicit NetServer(NetCore& core);
        ~NetServer();
 
        NetServer(const NetServer& other) = delete;
        NetServer& operator=(const NetServer& other) = delete;
 
        NetServer(NetServer && other) = delete;
        NetServer& operator=(NetServer && other) = delete;
 
    public:
        void onSpawn(SpawnPlayer spawn, DespawnPlayer despawn);

        void open(uint32_t maxPlayers);

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

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

        void beginTick(uint32_t tick);

        void endTick(const Scene& scene, uint32_t tick);

        void send(Scene& scene, uint32_t tick);

        const InputCommand* commandFor(EntityId entity) const;

        void rewind(Scene& scene, EntityId shooter);

        void restore(Scene& scene);

        void forgetWorld();
 
        size_t playerCount() const { return m_peers.size(); }
 
        std::string describe() const;
 
    private:
        struct Peer;

        struct Rewound {
            EntityId  entity;
            Transform transform;
        };
 
    private:
        NetSnapshotStats sendSnapshot(Scene& scene, const NetSchema& schema, Peer& peer, uint32_t tick);

        void holdScalesToTheWire(Scene& scene);

        bool vetHello(
            const NetAddress& from,
            uint64_t echoed,
            BitReader& reader,
            uint32_t& actions,
            uint64_t& actionNames
        );

        void acceptCommands(Peer& peer, BitReader& reader);

        void greet(
            const NetAddress& from,
            uint64_t echoed,
            BitReader& hello,
            Scene& scene,
            ResourceManager& resources
        );
 
        void challenge(const NetAddress& to);
        void refuse(const NetAddress& from, NetRefusal reason, uint64_t token);
        void welcome(Peer& peer, const NetAddress& to);

        PlayerId freePlayerId() const;
        void dropPeer(Scene& scene, ResourceManager& resources, size_t index, const char* why);
 
        Peer* findPeer(const NetAddress& address);
 
    private:
        NetCore& m_core;
 
        std::vector<std::unique_ptr<Peer>> m_peers;
 
        SpawnPlayer   m_spawn;
        DespawnPlayer m_despawn;
 
        uint32_t m_maxPlayers = 0;  
        PlayerId m_nextPlayer = 1;
 
        NetSnapshotStats m_lastSnapshot;
        bool             m_warnedScale = false;  
 
        NetRewind            m_rewind;  
        std::vector<Rewound> m_rewound;
 
        NetSilenceMap m_silence;  
 
        NetJoinCookie m_cookie;         
        double        m_seconds = 0.0;  
 
        uint32_t m_refusedMismatch = 0;  
        uint32_t m_refusedFull     = 0;  
 
        std::vector<InputCommand> m_received;  

        NetConnection m_unseated;
};
 
} // namespace Vkm::Engine