KartBurnout.cc

#include "KartBurnout.hh"
 
#include "game/kart/KartPhysics.hh"
#include "game/kart/KartState.hh"
 
#include <egg/math/Math.hh>
 
namespace Kinoko::Kart {

KartBurnout::KartBurnout() = default;

KartBurnout::~KartBurnout() = default;

void KartBurnout::start() {
    activate();
    m_timer = 0;
    m_phase = 0;
    m_amplitude = 1.0f;
}

void KartBurnout::calc() {
    constexpr u32 BURNOUT_DURATION = 120;
 
    if (!isActive()) {
        return;
    }
 
    calcRotation();
 
    if (calcEnd(BURNOUT_DURATION)) {
        deactivate();
    }
}
 
f32 KartBurnout::pitch() const {
    return m_pitch;
}

void KartBurnout::calcRotation() {
    constexpr u16 PHASE_INCREMENT = 800;
    constexpr f32 PHASE_TO_FIDX = 1.0f / 256.0f;
    constexpr f32 AMPLITUDE_FACTOR = 40.0f;
    constexpr f32 DAMPENING_THRESHOLD = 30.0f;
    constexpr f32 DAMPENING_FACTOR = 0.97f;
 
    m_phase += PHASE_INCREMENT;
 
    f32 sin = EGG::Mathf::SinFIdx(static_cast<f32>(m_phase) * PHASE_TO_FIDX);
 
    // Apply a dampening effect after burning out for 30 frames
    if (static_cast<f32>(m_timer) > DAMPENING_THRESHOLD) {
        m_amplitude *= DAMPENING_FACTOR;
    }
 
    m_pitch = DEG2RAD * (AMPLITUDE_FACTOR * sin) * m_amplitude;
 
    physics()->composeStuntRot(EGG::Quatf::FromRPY(0.0f, m_pitch, 0.0f));
}

bool KartBurnout::calcEnd(u32 duration) {
    return ++m_timer >= duration;
}

void KartBurnout::activate() {
    status().setBit(eStatus::Burnout);
}

void KartBurnout::deactivate() {
    status().resetBit(eStatus::Burnout);
}

bool KartBurnout::isActive() const {
    return status().onBit(eStatus::Burnout);
}
 
} // namespace Kinoko::Kart