KPadController.cc

#include "KPadController.hh"
 
#include <cstring>
 
namespace System {
 
KPadController::KPadController() : m_connected(false) {}
 
void KPadController::calc() {
    calcImpl();
}
 
KPadGhostController::KPadGhostController() : m_acceptingInputs(false) {
    m_buttonsStreams[0] = new KPadGhostFaceButtonsStream;
    m_buttonsStreams[1] = new KPadGhostDirectionButtonsStream;
    m_buttonsStreams[2] = new KPadGhostTrickButtonsStream;
}
 
KPadGhostController::~KPadGhostController() = default;
 
void KPadGhostController::reset(bool driftIsAuto) {
    m_driftIsAuto = driftIsAuto;
    m_raceInputState.reset();
 
    for (auto &stream : m_buttonsStreams) {
        stream->currentSequence = 0;
        stream->readSequenceFrames = 0;
        stream->state = 1;
    }
 
    m_acceptingInputs = false;
    m_connected = true;
}
 
void KPadGhostController::readGhostBuffer(const u8 *buffer, bool driftIsAuto) {
    constexpr u32 SEQUENCE_SIZE = 0x2;
 
    m_ghostBuffer = buffer;
    m_driftIsAuto = driftIsAuto;
 
    EGG::RamStream stream = EGG::RamStream(buffer, RKG_UNCOMPRESSED_INPUT_DATA_SECTION_SIZE);
 
    u16 faceCount = stream.read_u16();
    u16 directionCount = stream.read_u16();
    u16 trickCount = stream.read_u16();
 
    stream.skip(2);
 
    m_buttonsStreams[0]->buffer = stream.split(faceCount * SEQUENCE_SIZE);
    m_buttonsStreams[1]->buffer = stream.split(directionCount * SEQUENCE_SIZE);
    m_buttonsStreams[2]->buffer = stream.split(trickCount * SEQUENCE_SIZE);
}
 
void KPadGhostController::calcImpl() {
    if (!m_ghostBuffer || !m_acceptingInputs) {
        return;
    }
 
    m_raceInputState.buttons = m_buttonsStreams[0]->readFrame();
    u8 sticks = m_buttonsStreams[1]->readFrame();
    m_raceInputState.stickXRaw = sticks >> 4 & 0xF;
    m_raceInputState.stickYRaw = sticks & 0xF;
    m_raceInputState.stick = EGG::Vector2f(RawStickToState(m_raceInputState.stickXRaw),
            RawStickToState(m_raceInputState.stickYRaw));
    m_raceInputState.trickRaw = m_buttonsStreams[2]->readFrame();
 
    switch (m_raceInputState.trickRaw >> 4) {
    case 1:
        m_raceInputState.trick = Trick::Up;
        break;
    case 2:
        m_raceInputState.trick = Trick::Down;
        break;
    case 3:
        m_raceInputState.trick = Trick::Left;
        break;
    case 4:
        m_raceInputState.trick = Trick::Right;
        break;
    default:
        m_raceInputState.trick = Trick::None;
        break;
    }
}
 
RaceInputState::RaceInputState() {
    reset();
}
 
void RaceInputState::reset() {
    buttons = 0;
    buttonsRaw = 0;
    stick = EGG::Vector2f::zero;
    stickXRaw = 7;
    stickYRaw = 7;
    trick = Trick::None;
    trickRaw = 0;
}
 
bool RaceInputState::isValid() const {
    if (!isButtonsValid()) {
        return false;
    }
 
    if (!isStickValid(stick.x) || !isStickValid(stick.y)) {
        return false;
    }
 
    if (!isTrickValid()) {
        return false;
    }
 
    return true;
}
 
bool RaceInputState::isStickValid(f32 stick) const {
    if (stick > 1.0f || stick < -1.0f) {
        return false;
    }
 
    for (size_t i = 0; i <= 14; ++i) {
        auto cond = stick <=> RawStickToState(i);
        ASSERT(cond != std::partial_ordering::unordered);
 
        if (cond == std::partial_ordering::equivalent) {
            return true;
        } else if (cond == std::partial_ordering::less) {
            return false;
        }
    }
 
    // This is unreachable
    return false;
}
 
KPadGhostButtonsStream::KPadGhostButtonsStream()
    : currentSequence(std::numeric_limits<u32>::max()), state(2) {}
 
KPadGhostButtonsStream::~KPadGhostButtonsStream() = default;
 
u8 KPadGhostButtonsStream::readFrame() {
    if (state != 1) {
        return 0;
    }
 
    if (currentSequence == std::numeric_limits<u32>::max()) {
        readSequenceFrames = 0;
        currentSequence = buffer.read_u16();
    } else {
        if (readIsNewSequence()) {
            readSequenceFrames = 0;
            currentSequence = buffer.read_u16();
        }
    }
 
    ++readSequenceFrames;
 
    // In the base game, this check normally occurs before a new sequence is read. As a result, the
    // base game does not know that it has run out of inputs until the frame that it tries to access
    // past the last valid input. We stray from this behavior so that we can know when we are on the
    // last frame of input.
    if (buffer.eof() && readIsNewSequence()) {
        state = 2;
    }
 
    return readVal();
}
 
KPadGhostFaceButtonsStream::KPadGhostFaceButtonsStream() = default;
 
KPadGhostFaceButtonsStream::~KPadGhostFaceButtonsStream() = default;
 
KPadGhostDirectionButtonsStream::KPadGhostDirectionButtonsStream() = default;
 
KPadGhostDirectionButtonsStream::~KPadGhostDirectionButtonsStream() = default;
 
KPadGhostTrickButtonsStream::KPadGhostTrickButtonsStream() = default;
 
KPadGhostTrickButtonsStream::~KPadGhostTrickButtonsStream() = default;
 
/* ================================ *
 *     HOST CONTROLLER
 * ================================ */
 
KPadHostController::KPadHostController() = default;
 
KPadHostController::~KPadHostController() = default;
 
void KPadHostController::reset(bool driftIsAuto) {
    m_driftIsAuto = driftIsAuto;
    m_raceInputState.reset();
    m_connected = true;
}
 
/* ================================ *
 *     PADS
 * ================================ */
 
KPad::KPad() : m_controller(nullptr) {
    reset();
}
 
KPad::~KPad() = default;
 
void KPad::calc() {
    m_lastInputState = m_currentInputState;
    m_currentInputState = m_controller->raceInputState();
}
 
void KPad::reset() {
    if (m_controller) {
        m_controller->reset(m_controller->driftIsAuto());
    }
}
 
KPadPlayer::KPadPlayer() = default;
 
KPadPlayer::~KPadPlayer() = default;
 
void KPadPlayer::setGhostController(KPadGhostController *controller, const u8 *inputs,
        bool driftIsAuto) {
    m_controller = controller;
 
    if (inputs) {
        memcpy(m_ghostBuffer, inputs, RKG_UNCOMPRESSED_INPUT_DATA_SECTION_SIZE);
    }
 
    controller->readGhostBuffer(m_ghostBuffer, driftIsAuto);
}
 
void KPadPlayer::setHostController(KPadHostController *controller, bool driftIsAuto) {
    m_controller = controller;
    m_controller->setDriftIsAuto(driftIsAuto);
}
 
void KPadPlayer::startGhostProxy() {
    if (!m_controller || m_controller->controlSource() != ControlSource::Ghost) {
        return;
    }
 
    KPadGhostController *ghostController = reinterpret_cast<KPadGhostController *>(m_controller);
    ghostController->setAcceptingInputs(true);
}
 
void KPadPlayer::endGhostProxy() {
    if (!m_controller || m_controller->controlSource() != ControlSource::Ghost) {
        return;
    }
 
    KPadGhostController *ghostController = reinterpret_cast<KPadGhostController *>(m_controller);
    ghostController->setAcceptingInputs(false);
}
 
} // namespace System