command.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <vector>
 
#include "net/wire/bit_stream.h"
#include "platform/input/input_command.h"
 
namespace Vkm::Engine {

constexpr uint32_t NET_COMMAND_REDUNDANCY = 12;

constexpr uint32_t NET_MAX_PACKET_COMMANDS = 16;

constexpr uint32_t NET_COMMAND_MEMORY = 64;

constexpr uint32_t NET_AXIS_BITS = 8;

size_t firstCommandToSend(const std::vector<InputCommand>& unconfirmed, uint32_t heard, uint32_t sent);

size_t writeCommands(
    BitWriter& out,
    const std::vector<InputCommand>& commands,
    size_t first,
    uint32_t actionCount
);

bool readCommands(BitReader& in, uint32_t actionCount, std::vector<InputCommand>& out);

class NetCommandBuffer {
    public:
        static constexpr size_t MAX_DEPTH = 10;

        static constexpr size_t MAX_QUEUED = 256;

        static constexpr uint32_t REPEAT_TICKS = NET_COMMAND_REDUNDANCY * 2;
 
    public:
        NetCommandBuffer() = default;
        ~NetCommandBuffer() = default;
 
        NetCommandBuffer(const NetCommandBuffer& other) = delete;
        NetCommandBuffer& operator=(const NetCommandBuffer& other) = delete;
 
        NetCommandBuffer(NetCommandBuffer && other) = delete;
        NetCommandBuffer& operator=(NetCommandBuffer && other) = delete;
 
    public:
        void accept(const InputCommand& command);

        InputCommand take(uint32_t tick);

        uint32_t newestRunTick() const { return m_ranCommandTick; }

        uint32_t newestSequence() const { return m_newestSequence; }

        size_t pending() const { return m_commands.size(); }

        size_t lowWater() const {
            return m_lowWater == std::numeric_limits<size_t>::max() ? m_commands.size() : m_lowWater;
        }

        void restartLowWater() { m_lowWater = std::numeric_limits<size_t>::max(); }

        uint32_t repeatedTicks() const { return m_repeatedTicks; }

        uint32_t skippedCommands() const { return m_skippedCommands; }
 
        void clear();
 
    private:
        std::vector<InputCommand> m_commands;              
        InputCommand              m_last;                  
        uint32_t                  m_newestSequence   = 0;  
        uint32_t                  m_newestTick       = 0;  
        uint32_t                  m_consumedSequence = 0;  
        uint32_t                  m_ranCommandTick   = 0;  
        uint32_t                  m_carriedPressed   = 0;  
        uint32_t                  m_carriedReleased  = 0;  
        uint32_t                  m_starved          = 0;  
        uint32_t                  m_repeatedTicks    = 0;  
        uint32_t                  m_skippedCommands  = 0;  

        size_t                    m_lowWater = std::numeric_limits<size_t>::max();
 
        bool                      m_ranReal = false;  
        bool                      m_started = false;
};
 
} // namespace Vkm::Engine