// WebSocket client (browser)
const ws = new WebSocket("wss://game-server.example.com");
ws.binaryType = "arraybuffer"; // Use binary, not text!
 
ws.onmessage = (event) => {
    const buffer = new DataView(event.data);
    const packetType = buffer.getUint8(0);
    // Deserialize based on packet type...
};
 
// Send binary packet
const packet = new Uint8Array([0x01, ...encodedPlayerInput]);
ws.send(packet.buffer);

// NTP-style clock sync (simplified)
int64_t syncClock(NetworkSocket& socket) {
    auto t0 = Clock::now();
    
    socket.send(PingPacket{});
    PongPacket pong = socket.receive();
    
    auto t3 = Clock::now();
    int64_t rtt = (t3 - t0).milliseconds();
    int64_t serverNow = pong.serverSendTime + rtt / 2;
    int64_t clockOffset = serverNow - t3;
    
    return clockOffset; // Add this to local time to get server time
}

// Server game loop — fixed tick rate
const double TICK_RATE = 64.0;
const double TICK_DURATION = 1.0 / TICK_RATE; // 15.625ms
 
double accumulator = 0.0;
double lastTime = getTime();
uint64_t tickNumber = 0;
 
while (serverRunning) {
    double now = getTime();
    accumulator += (now - lastTime);
    lastTime = now;
 
    while (accumulator >= TICK_DURATION) {
        // 1. Collect all inputs received this tick
        auto inputs = inputBuffer.consumeTick(tickNumber);
        
        // 2. Simulate
        for (auto& [clientId, input] : inputs) {
            applyInput(clients[clientId], input);
        }
        physicsWorld.step(TICK_DURATION);
        gameLogic.update(TICK_DURATION);
        
        // 3. Send state snapshot to all clients
        broadcastWorldState(tickNumber);
        
        accumulator -= TICK_DURATION;
        tickNumber++;
    }
 
    // Sleep to avoid burning CPU
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
}

// Client prediction loop
struct PlayerInput {
    uint32_t sequence; // Monotonically increasing input ID
    float moveX, moveY;
    bool jump;
    double timestamp;
};
 
// Client side
class PredictedPlayer {
    std::deque<PlayerInput> inputHistory; // Keep last N inputs
    PlayerState localState;
 
public:
    void processInput(PlayerInput input) {
        input.sequence = nextSequence++;
        
        // 1. Apply locally (IMMEDIATELY — don't wait for server)
        applyInputToState(localState, input);
        
        // 2. Store for reconciliation
        inputHistory.push_back(input);
        
        // 3. Send to server
        network.sendInput(input);
    }
 
    void onServerCorrection(uint32_t ackSequence, PlayerState serverState) {
        // Server acknowledged input #ackSequence
        // Discard all inputs up to and including ackSequence
        while (!inputHistory.empty() && 
               inputHistory.front().sequence <= ackSequence) {
            inputHistory.pop_front();
        }
 
        // If server state differs, reconcile
        if (serverState != localState) {
            // Rewind to server's authoritative state
            localState = serverState;
            
            // Re-apply all unacknowledged inputs
            for (const auto& input : inputHistory) {
                applyInputToState(localState, input);
            }
        }
    }
};

// Entity interpolation
struct Snapshot {
    uint64_t tick;
    double   timestamp;
    glm::vec3 position;
    glm::quat rotation;
};
 
class InterpolatedEntity {
    std::deque<Snapshot> snapshotBuffer; // Receive buffer
    const double INTERP_DELAY = 0.1; // 100ms behind server time
 
public:
    void addSnapshot(Snapshot s) {
        snapshotBuffer.push_back(s);
        // Keep only last 32 snapshots
        if (snapshotBuffer.size() > 32)
            snapshotBuffer.pop_front();
    }
 
    glm::vec3 getInterpolatedPosition(double currentServerTime) {
        double renderTime = currentServerTime - INTERP_DELAY;
 
        // Find two snapshots that bracket renderTime
        for (size_t i = 0; i + 1 < snapshotBuffer.size(); i++) {
            auto& s0 = snapshotBuffer[i];
            auto& s1 = snapshotBuffer[i + 1];
 
            if (s0.timestamp <= renderTime && renderTime <= s1.timestamp) {
                float t = (renderTime - s0.timestamp) / 
                          (s1.timestamp - s0.timestamp);
                return glm::mix(s0.position, s1.position, t);
            }
        }
 
        // Extrapolate if we run out of snapshots (packet loss)
        if (!snapshotBuffer.empty())
            return snapshotBuffer.back().position; // Dead reckoning fallback
        return {};
    }
};

struct DeadReckoning {
    glm::vec3 lastKnownPosition;
    glm::vec3 lastKnownVelocity;
    double    lastUpdateTime;
 
    glm::vec3 predictPosition(double currentTime) {
        double dt = currentTime - lastUpdateTime;
        return lastKnownPosition + lastKnownVelocity * (float)dt;
    }
 
    void onNewData(glm::vec3 pos, glm::vec3 vel, double time) {
        lastKnownPosition = pos;
        lastKnownVelocity = vel;
        lastUpdateTime    = time;
    }
};

class LagCompensationManager {
    // Ring buffer of world state snapshots (keep last 1 second = 64 ticks @ 64Hz)
    struct HistoricalState {
        uint64_t tick;
        std::unordered_map<EntityId, ColliderShape> entityColliders;
    };
    CircularBuffer<HistoricalState, 128> history;
 
public:
    void recordTick(uint64_t tick) {
        HistoricalState state;
        state.tick = tick;
        for (auto& [id, entity] : world.entities) {
            state.entityColliders[id] = entity.getCollider();
        }
        history.push(state);
    }
 
    HitResult performLagCompensatedRaycast(
            EntityId shooterId, Ray ray, 
            uint64_t clientTick,    // The tick the client was on when they shot
            double   clientLatency) // The shooter's ping (seconds)
    {
        // Find the historical snapshot closest to when the client fired
        uint64_t rewindTick = clientTick - 
                              (uint64_t)(clientLatency * SERVER_TICK_RATE);
        
        auto* historicalState = history.findNearest(rewindTick);
        if (!historicalState) return {}; // Too far in the past
 
        // Temporarily move all entities to their historical positions
        ScopedStateOverride override(world, *historicalState);
 
        // Perform the raycast in rewound world
        return world.raycast(ray, /*excludeId=*/shooterId);
    }
};

// GGPO integration pseudocode
GGPOSession* ggpo;
GGPOCallbacks callbacks;
 
// You implement these callbacks:
callbacks.save_game_state = [](unsigned char** buffer, int* len, int* checksum, int frame) {
    *buffer = new unsigned char[sizeof(GameState)];
    memcpy(*buffer, &gameState, sizeof(GameState));
    *len = sizeof(GameState);
    *checksum = calculateChecksum(gameState); // For desync detection
    return true;
};
 
callbacks.load_game_state = [](unsigned char* buffer, int len) {
    memcpy(&gameState, buffer, len);
    return true;
};
 
callbacks.advance_frame = [](int flags) {
    // Run one frame of game logic
    GGPOPlayerHandle handles[2];
    uint32_t inputs[2];
    GGPOErrorCode result = ggpo_synchronize_input(ggpo, inputs, sizeof(inputs), nullptr);
    
    gameState.update(inputs[0], inputs[1], FRAME_DELTA);
    ggpo_advance_frame(ggpo);
    return true;
};
 
// Main loop
while (running) {
    uint32_t localInput = getLocalInput();
    ggpo_add_local_input(ggpo, localPlayerHandle, &localInput, sizeof(localInput));
    ggpo_idle(ggpo, 0); // Process network messages
}

// Delta compression example
struct PlayerStateDelta {
    uint8_t  changedFields; // Bitmask: bit 0=position, bit 1=health, bit 2=animation, ...
    // Only the changed fields follow
    glm::vec3 position;   // Only if bit 0 set
    float     health;     // Only if bit 1 set
    uint8_t   animation;  // Only if bit 2 set
};
 
// Serializer with dirty tracking
void serializeDelta(BitWriter& writer, 
                     const PlayerState& current, 
                     const PlayerState& baseline) 
{
    uint8_t mask = 0;
    if (current.position  != baseline.position)  mask |= 0x01;
    if (current.health    != baseline.health)    mask |= 0x02;
    if (current.animation != baseline.animation) mask |= 0x04;
    
    writer.writeByte(mask);
    if (mask & 0x01) writer.writeVec3Quantized(current.position, -4096, 4096);
    if (mask & 0x02) writer.writeFloat16(current.health);
    if (mask & 0x04) writer.writeByte(current.animation);
}

// Compact input packet (fits in ~4 bytes)
struct InputPacket {
    uint16_t sequence;     // Input sequence number (wrap around OK)
    uint8_t  moveFlags;    // Bitfield: bit0=W, bit1=S, bit2=A, bit3=D
    uint8_t  actionFlags;  // bit0=jump, bit1=crouch, bit2=shoot, bit3=reload
    int8_t   aimX;        // Quantized aim delta (-127 to 127)
    int8_t   aimY;        // Quantized aim delta
    uint8_t  tick;        // Local tick this input was generated on (low 8 bits)
}; // Total: 7 bytes
 
// Reliability: include last 8 inputs in each packet
// (redundant sending prevents input loss from causing issues)
struct InputPacketBundle {
    InputPacket inputs[8]; // Current + 7 previous
}; // Total: 56 bytes — still small

// Interest management — spatial grid approach
class InterestManager {
    static const float VIEW_DISTANCE = 150.0f;
 
public:
    std::vector<EntityId> getRelevantEntities(EntityId clientPlayer) {
        auto& playerPos = world.getPosition(clientPlayer);
        std::vector<EntityId> relevant;
 
        // Always include: self, priority entities (bosses, projectiles near player)
        relevant.push_back(clientPlayer);
 
        // Spatial query for nearby entities
        auto nearby = spatialGrid.query(playerPos, VIEW_DISTANCE);
        relevant.insert(relevant.end(), nearby.begin(), nearby.end());
 
        // Sort by distance — closer = higher priority
        std::sort(relevant.begin(), relevant.end(), [&](EntityId a, EntityId b) {
            return glm::distance(world.getPosition(a), playerPos) <
                   glm::distance(world.getPosition(b), playerPos);
        });
 
        // Cap at max entities per update
        if (relevant.size() > MAX_ENTITIES_PER_UPDATE)
            relevant.resize(MAX_ENTITIES_PER_UPDATE);
 
        return relevant;
    }
};

# ELO implementation
def expected_score(player_elo: float, opponent_elo: float) -> float:
    """Probability of player winning."""
    return 1.0 / (1.0 + 10 ** ((opponent_elo - player_elo) / 400))
 
def update_elo(player_elo: float, opponent_elo: float, 
                score: float,  # 1.0 = win, 0.5 = draw, 0.0 = loss
                k: float = 32) -> float:
    """Update player's ELO after a game."""
    expected = expected_score(player_elo, opponent_elo)
    return player_elo + k * (score - expected)
 
# Example:
# Player (1500 ELO) beats Opponent (1600 ELO)
new_elo = update_elo(1500, 1600, score=1.0)  # → ~1520

// Authoritative movement validation
void ServerPlayerController::validateMovement(
        EntityId playerId, 
        const InputPacket& input, 
        float deltaTime)
{
    PlayerState& state = world.getState(playerId);
    glm::vec3 requestedPos = simulateMovement(state, input, deltaTime);
    
    // Maximum speed check
    float maxDistanceThisFrame = MAX_PLAYER_SPEED * deltaTime * 1.1f; // 10% tolerance
    float movedDistance = glm::distance(requestedPos, state.position);
    
    if (movedDistance > maxDistanceThisFrame) {
        // Teleport/speed hack detected
        log("Speed violation: player {} moved {:.2f}m in {:.3f}s",
            playerId, movedDistance, deltaTime);
        
        // Apply server-authoritative position (don't trust client)
        state.position = state.position + 
                         glm::normalize(requestedPos - state.position) * maxDistanceThisFrame;
        
        // Increment violation counter
        violationLog[playerId]++;
        if (violationLog[playerId] > VIOLATION_THRESHOLD) {
            kickPlayer(playerId, "Movement violation");
        }
    } else {
        state.position = requestedPos;
    }
}

// Don't send position data for invisible enemies
bool isEnemyVisible(EntityId viewer, EntityId target) {
    auto& viewerPos = world.getPosition(viewer);
    auto& targetPos = world.getPosition(target);
 
    // Distance check first (cheap)
    if (glm::distance(viewerPos, targetPos) > MAX_VISIBILITY_DISTANCE)
        return false;
 
    // FOV check
    glm::vec3 toTarget = glm::normalize(targetPos - viewerPos);
    if (glm::dot(world.getForward(viewer), toTarget) < FOV_DOT_THRESHOLD)
        return false;
 
    // Raycast (expensive — do last)
    return !world.raycastBlocked(viewerPos, targetPos);
}
 
// Build server → client snapshot
WorldSnapshot buildSnapshot(EntityId clientPlayer) {
    WorldSnapshot snap;
    for (auto& [id, entity] : world.entities) {
        if (id == clientPlayer || isEnemyVisible(clientPlayer, id)) {
            snap.entities.push_back(entity.getState());
        }
        // ← Enemy is NOT in the snapshot if invisible
        // → Wallhack can't show what the server doesn't send
    }
    return snap;
}

// Quantize a position float to 16 bits
// Range: [-4096, 4096] meters → precision: ~0.125m = 12.5cm
uint16_t quantizePosition(float value, float min, float max) {
    float normalized = (value - min) / (max - min); // 0.0 to 1.0
    return (uint16_t)(normalized * 65535.0f);        // 0 to 65535
}
float dequantizePosition(uint16_t quantized, float min, float max) {
    float normalized = quantized / 65535.0f;
    return min + normalized * (max - min);
}
 
// Quantize rotation to quaternion with 16-bit components (smallest-3)
// Largest component is implicit (can be derived from the other 3)
// This gives ~0.1 degree precision at only 6 bytes (vs 16 for full quat)

# server.gd — Authoritative server
extends Node
 
const PORT = 7777
const MAX_PLAYERS = 32
 
var players: Dictionary = {} # peer_id → PlayerState
 
func _ready():
    var peer = ENetMultiplayerPeer.new()
    var err = peer.create_server(PORT, MAX_PLAYERS)
    if err != OK:
        push_error("Failed to create server: %s" % err)
        return
    
    multiplayer.multiplayer_peer = peer
    multiplayer.peer_connected.connect(_on_peer_connected)
    multiplayer.peer_disconnected.connect(_on_peer_disconnected)
    print("Server listening on port %d" % PORT)
 
func _on_peer_connected(id: int):
    print("Player connected: %d" % id)
    players[id] = PlayerState.new()
    # Send current world state to new player
    sync_full_state.rpc_id(id, get_full_state())
 
func _on_peer_disconnected(id: int):
    players.erase(id)
    broadcast_player_left.rpc(id)
 
# Receive player input (unreliable, called each tick)
@rpc("any_peer", "unreliable_ordered")
func receive_input(seq: int, move_x: float, move_y: float, 
                    jump: bool, aim_x: float, aim_y: float):
    var sender_id = multiplayer.get_remote_sender_id()
    if sender_id not in players:
        return
    
    # Validate + apply input server-side
    var player = players[sender_id]
    player.apply_input(move_x, move_y, jump, get_process_delta_time())
    
# Broadcast world state every tick
@rpc("call_local", "unreliable_ordered")
func broadcast_state(tick: int, state_data: PackedByteArray):
    pass # Clients process received state

# client.gd — Client with prediction
extends Node
 
@onready var server_ip = "127.0.0.1"
@onready var server_port = 7777
 
var input_sequence: int = 0
var pending_inputs: Array = [] # For reconciliation
 
func connect_to_server():
    var peer = ENetMultiplayerPeer.new()
    peer.create_client(server_ip, server_port)
    multiplayer.multiplayer_peer = peer
 
func _physics_process(delta):
    if not multiplayer.is_server():
        _handle_client_frame(delta)
 
func _handle_client_frame(delta: float):
    # 1. Sample input
    var input = {
        "seq": input_sequence,
        "move_x": Input.get_axis("move_left", "move_right"),
        "move_y": Input.get_axis("move_up", "move_down"),
        "jump": Input.is_action_just_pressed("jump"),
    }
    
    # 2. Apply locally (client-side prediction)
    local_player.apply_input(input.move_x, input.move_y, input.jump, delta)
    
    # 3. Store for reconciliation 
    pending_inputs.append(input)
    if pending_inputs.size() > 128:
        pending_inputs.pop_front()
    
    # 4. Send to server (unreliable — high frequency)
    server.receive_input.rpc_id(1, 
        input.seq, input.move_x, input.move_y, input.jump, 0.0, 0.0)
    
    input_sequence += 1

# Modern Godot 4 approach — scene replication
# Add MultiplayerSynchronizer node to your scene
 
# player.gd
extends CharacterBody3D
 
# These variables are automatically synced by MultiplayerSynchronizer
# Configure in MultiplayerSynchronizer inspector: add position, velocity to sync list
 
@rpc("any_peer", "unreliable_ordered", "call_remote")
func set_target_position(pos: Vector3):
    # Server validates and sets position
    if multiplayer.is_server():
        if _is_valid_position(pos):
            global_position = pos
 
func _is_valid_position(new_pos: Vector3) -> bool:
    # Validate max movement speed etc.
    var max_dist = MAX_SPEED * get_process_delta_time() * 1.15
    return global_position.distance_to(new_pos) <= max_dist

# ENet (recommended for most games)
var enet_peer = ENetMultiplayerPeer.new()
enet_peer.create_server(7777)
multiplayer.multiplayer_peer = enet_peer
 
# WebSocket (for browser/web export)
var ws_peer = WebSocketMultiplayerPeer.new()
ws_peer.create_server(7777)
multiplayer.multiplayer_peer = ws_peer

// Typical game server lifecycle
int main() {
    // 1. Read config from environment (injected by orchestrator)
    std::string serverIp   = getenv("SERVER_IP");
    int         serverPort = std::stoi(getenv("SERVER_PORT") ?: "7777");
    int         maxPlayers = std::stoi(getenv("MAX_PLAYERS") ?: "20");
    
    // 2. Initialize systems
    NetworkServer server(serverIp, serverPort, maxPlayers);
    GameWorld world;
    
    // 3. Register with orchestrator (signal ready to receive players)
    orchestrator.notifyReady(serverIp, serverPort);
    
    // 4. Health check HTTP endpoint (orchestrators ping this)
    httpServer.get("/health", [](Request& req, Response& res) {
        res.json({
            {"status", "ok"},
            {"players", world.getPlayerCount()},
            {"tick", world.getCurrentTick()},
            {"uptime_s", getUptimeSeconds()}
        });
    });
    
    // 5. Main game loop
    while (server.isRunning()) {
        server.processNetworkEvents();
        world.tick();
        server.broadcastSnapshot(world.getSnapshot());
    }
    
    // 6. Graceful shutdown — notify orchestrator, save any state
    orchestrator.notifyShutdown(serverIp, serverPort);
    return 0;
}