KPadController.hh

#pragma once
 
#include "game/system/GhostFile.hh"
 
#include <egg/math/Vector.hh>
 
namespace Kinoko::System {

[[nodiscard]] static constexpr f32 RawStickToState(u8 rawStick) {
    return (static_cast<f32>(rawStick) - 7.0f) / 7.0f;
}
 
enum class ControlSource {
    Unknown = -1,
    Core = 0,      // WiiMote
    Freestyle = 1, // WiiMote + Nunchuk
    Classic = 2,
    Gamecube = 3,
    Ghost = 4,
    AI = 5,
    Host = 6, // Added in Kinoko, represents an external program
};
 
enum class Trick {
    None = 0,
    Up = 1,
    Down = 2,
    Left = 3,
    Right = 4,
};

struct RaceInputState {
    RaceInputState();
    virtual ~RaceInputState() {}
 
    void reset();
 
    [[nodiscard]] bool isValid() const;

    [[nodiscard]] bool isButtonsValid() const {
        return !(buttons & ~0xf);
    }
 
    [[nodiscard]] bool isStickValid(f32 stick) const;

    [[nodiscard]] bool isTrickValid() const {
        switch (trick) {
        case Trick::None:
        case Trick::Up:
        case Trick::Down:
        case Trick::Left:
        case Trick::Right:
            return true;
        default:
            return false;
        }
    }
 
    [[nodiscard]] bool accelerate() const {
        return !!(buttons & 0x1);
    }
 
    [[nodiscard]] bool brake() const {
        return !!(buttons & 0x2);
    }
 
    [[nodiscard]] bool item() const {
        return !!(buttons & 0x4);
    }
 
    [[nodiscard]] bool drift() const {
        return !!(buttons & 0x8);
    }
 
    [[nodiscard]] bool trickUp() const {
        return trick == Trick::Up;
    }
 
    [[nodiscard]] bool trickDown() const {
        return trick == Trick::Down;
    }
 
    u16 buttons;
    u16 buttonsRaw;
    EGG::Vector2f stick;
    u8 stickXRaw;
    u8 stickYRaw;
    Trick trick;
    u8 trickRaw;
};

struct KPadGhostButtonsStream {
    KPadGhostButtonsStream();
    ~KPadGhostButtonsStream();
 
    [[nodiscard]] virtual u8 readFrame();

    [[nodiscard]] virtual bool readIsNewSequence() const {
        return readSequenceFrames >= (currentSequence & 0xFF);
    }

    [[nodiscard]] virtual u8 readVal() const {
        return currentSequence >> 8;
    }
 
    EGG::RamStream buffer;
    u32 currentSequence;
    u16 readSequenceFrames;
    u32 state;
};

struct KPadGhostFaceButtonsStream : public KPadGhostButtonsStream {
    KPadGhostFaceButtonsStream();
    ~KPadGhostFaceButtonsStream();
};

struct KPadGhostDirectionButtonsStream : public KPadGhostButtonsStream {
    KPadGhostDirectionButtonsStream();
    ~KPadGhostDirectionButtonsStream();
};

struct KPadGhostTrickButtonsStream : public KPadGhostButtonsStream {
    KPadGhostTrickButtonsStream();
    ~KPadGhostTrickButtonsStream();

    [[nodiscard]] bool readIsNewSequence() const override {
        u16 duration = currentSequence & 0xFF;
        duration += 256 * (currentSequence >> 8 & 0xF);
        return duration <= readSequenceFrames;
    }

    [[nodiscard]] u8 readVal() const override {
        return currentSequence >> 0x8 & ~0x80;
    }
};

class KPadController {
public:
    KPadController();
    virtual ~KPadController() {}

    [[nodiscard]] virtual ControlSource controlSource() const {
        return ControlSource::Unknown;
    }
 
    virtual void reset(bool /*driftIsAuto*/) {}
    virtual void calcImpl() {}
 
    void calc();
 
    [[nodiscard]] const RaceInputState &raceInputState() const {
        return m_raceInputState;
    }

    void setDriftIsAuto(bool driftIsAuto) {
        m_driftIsAuto = driftIsAuto;
    }
 
    [[nodiscard]] bool driftIsAuto() const {
        return m_driftIsAuto;
    }
 
protected:
    RaceInputState m_raceInputState; 
    bool m_connected;                
    bool m_driftIsAuto;              
};

class KPadGhostController : public KPadController {
public:
    KPadGhostController();
    ~KPadGhostController() override;

    [[nodiscard]] ControlSource controlSource() const override {
        return ControlSource::Ghost;
    }
 
    void reset(bool driftIsAuto) override;
 
    void readGhostBuffer(const u8 *buffer, bool driftIsAuto);
 
    void calcImpl() override;
 
    void setAcceptingInputs(bool set) {
        m_acceptingInputs = set;
    }
 
private:
    const u8 *m_ghostBuffer;
    std::array<KPadGhostButtonsStream *, 3> m_buttonsStreams;
    bool m_acceptingInputs;
};

class KPadHostController : public KPadController {
public:
    KPadHostController();
    ~KPadHostController() override;
 
    [[nodiscard]] ControlSource controlSource() const override {
        return ControlSource::Host;
    }
 
    void reset(bool driftIsAuto) override;

    bool setInputs(const RaceInputState &state) {
        return setInputs(state.buttons, state.stick, state.trick);
    }

    bool setInputs(u16 buttons, const EGG::Vector2f &stick, Trick trick) {
        m_raceInputState.buttons = buttons;
        m_raceInputState.stick = stick;
        m_raceInputState.trick = trick;
 
        return m_raceInputState.isValid();
    }

    bool setInputs(u16 buttons, f32 stickX, f32 stickY, Trick trick) {
        m_raceInputState.buttons = buttons;
        m_raceInputState.stick.x = stickX;
        m_raceInputState.stick.y = stickY;
        m_raceInputState.trick = trick;
 
        return m_raceInputState.isValid();
    }

    bool setInputsRawStick(u16 buttons, u8 stickXRaw, u8 stickYRaw, Trick trick) {
        return setInputs(buttons, RawStickToState(stickXRaw), RawStickToState(stickYRaw), trick);
    }

    bool setInputsRawStickZeroCenter(u16 buttons, s8 stickXRaw, s8 stickYRaw, Trick trick) {
        return setInputsRawStick(buttons, stickXRaw + 7, stickYRaw + 7, trick);
    }
};
 
class KPad {
public:
    KPad();
    ~KPad();
 
    void calc();
    void reset();
 
    [[nodiscard]] const RaceInputState &currentState() const {
        return m_currentInputState;
    }
 
    [[nodiscard]] const RaceInputState &lastState() const {
        return m_lastInputState;
    }
 
    [[nodiscard]] bool driftIsAuto() const {
        return m_controller->driftIsAuto();
    }
 
protected:
    KPadController *m_controller;
    RaceInputState m_currentInputState;
    RaceInputState m_lastInputState; 
};

class KPadPlayer : public KPad {
public:
    KPadPlayer();
    ~KPadPlayer();
 
    void setGhostController(KPadGhostController *controller, const u8 *inputs, bool driftIsAuto);
    void setHostController(KPadHostController *controller, bool driftIsAuto);
 
    void startGhostProxy(); 
    void endGhostProxy();   
 
private:
    u8 m_ghostBuffer[RKG_UNCOMPRESSED_INPUT_DATA_SECTION_SIZE];
};
 
} // namespace Kinoko::System