Server.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ecs/components/ClientId.hpp"
#include "ecs/registry/Registry.hpp"
#include "ecs/systems/PlayerStatusSystem.hpp"
#include "network/MatchStatus.hpp"
#include "network/MessageStream.hpp"
#include "network/NetworkConfig.hpp"
#include "network/OutboundQueue.hpp"
#include "network/ShotEvent.hpp"
#include "network/transport/UdpEndpoint.hpp"
#include "systems/EventQueue.hpp"
 
#include <SDL3/SDL_stdinc.h>
 
#include <SDL3_net/SDL_net.h>
#include <atomic>
#include <deque>
#include <entt/entity/entity.hpp>
#include <mutex>
#include <thread>
#include <vector>

class Server
{
public:
    bool init(const char* addr, Uint16 port, const TransportConfig& transport = {});

    void shutdown();

    void poll() {}

    bool isEmpty();

    Event dequeueEvent();

    bool notifyPlayerClientId(ClientId clientId, entt::entity playerEntity);

    void broadcastRegistry(const Registry& registry);

    void broadcastParticleEvents(const std::vector<NetParticleEvent>& events);

    int getClientCount();

    uint16_t getClientRttMs(ClientId clientId);

    void broadcastMatchStatus(MatchStatePacket packet);

    void broadcastKillEvents(const std::vector<NetKillEvent>& events);

    void flushAllOutbound();
 
private:
    struct Connection
    {
        MessageStream msgStream;    
        ClientId clientId;          
        bool pendingInitialization; 

        uint32_t lastAppliedInputTick = 0;

        OutboundQueue outbound;

        uint32_t connectionId = 0;

        net::UdpEndpointAddr udpAddr;

        uint16_t udpSnapshotSequence = 0;

        uint16_t reliableNextSequence = 0;

        struct PendingReliableEvent
        {
            uint16_t sequence;           
            uint8_t remainingSends;      
            std::vector<uint8_t> framed; 
        };
        std::deque<PendingReliableEvent> reliableQueue;

        uint16_t lastReportedRttMs = 0;
    };

    void handleMessage(Connection& client, const void* data, Uint32 len);

    void acceptClients();

    void disconnectClient(Connection conn);

    void readClients();

    ClientId getNextClientId();

    bool enqueueTo(const ClientId& clientId, uint8_t replaceKey, const void* data, int len);

    void enqueueBroadcast(uint8_t replaceKey, const void* data, int len);

    void enqueueReliableEvent(const void* data, int len);

    void networkLoop();

    void handleUdpUnreliable(uint32_t connId, const net::UdpEndpointAddr& from, const uint8_t* payload, uint32_t len);
 
    NET_Server* server = nullptr;                     
 
    std::unordered_map<ClientId, Connection> clients; 
    EventQueue eventQueue;                            
 
    ClientId nextClientId;                            
 
    // ── Phase 3d: UDP sidecar ─────────────────────────────────────────────
    //
    // Bound during init() to the same port as the TCP listener (different
    // protocol = different socket; OS demuxes). The network thread polls
    // both. Server-assigned 32-bit connection IDs let us match an
    // incoming UDP datagram to a TCP-established Connection — the IDs
    // are minted on TCP accept and shipped to the client in the
    // ASSIGN_CLIENT_ID packet so it can stamp them on outbound UDP.
    net::UdpEndpoint udpEndpoint_;
    TransportConfig transportConfig_;
    std::unordered_map<uint32_t, ClientId> connIdToClient_; 
 
    // ── Stage 3b: dedicated network thread ────────────────────────────────
    //
    // The mutex protects every member above (clients map, eventQueue,
    // nextClientId, NET_Server*) — both the game thread (enqueueTo /
    // enqueueBroadcast / dequeueEvent / notifyPlayerClientId) and the
    // network thread (acceptClients / readClients / flushAllOutbound) hold
    // it during state mutation. Lock holds are kept short (one phase at a
    // time) so the game thread isn't starved.
    std::mutex stateMutex_;
    std::thread networkThread_;
    std::atomic<bool> shouldStop_{false};
};