KartHalfPipe.cc

#include "KartHalfPipe.hh"
 
#include "game/kart/KartCollide.hh"
#include "game/kart/KartDynamics.hh"
#include "game/kart/KartMove.hh"
#include "game/kart/KartParam.hh"
#include "game/kart/KartPhysics.hh"
#include "game/kart/KartState.hh"
 
#include <egg/math/Math.hh>
 
namespace Kart {
 
KartHalfPipe::KartHalfPipe() : m_prevPos(EGG::Vector3f::zero) {}
 
KartHalfPipe::~KartHalfPipe() = default;
 
void KartHalfPipe::reset() {
    m_stunt = StuntType::None;
    m_touchingZipper = false;
    m_timer = 0;
}
 
void KartHalfPipe::calc() {
    constexpr s16 LANDING_BOOST_DELAY = 3;
 
    auto &status = KartObjectProxy::status();
 
    if (state()->airtime() > 15 && status.onBit(eStatus::OverZipper)) {
        m_timer = LANDING_BOOST_DELAY;
    }
 
    bool isLanding = status.onBit(eStatus::HalfPipeRamp) && m_timer <= 0;
 
    calcTrick();
 
    if (status.offBit(eStatus::InAction) &&
            collide()->surfaceFlags().offBit(KartCollide::eSurfaceFlags::StopHalfPipeState)) {
        if (m_touchingZipper && status.onBit(eStatus::AirStart)) {
            dynamics()->setExtVel(EGG::Vector3f::zero);
            status.setBit(eStatus::OverZipper);
 
            EGG::Vector3f upXZ = move()->up();
            upXZ.y = 0.0f;
            upXZ.normalise();
            EGG::Vector3f up = move()->dir().perpInPlane(upXZ, true);
 
            EGG::Vector3f local_64 = up.cross(bodyUp().perpInPlane(up, true));
            m_nextSign = local_64.dot(EGG::Vector3f::ey) > 0.0f ? 1.0f : -1.0f;
 
            EGG::Vector3f velNorm = velocity();
            velNorm.normalise();
            EGG::Vector3f rot = dynamics()->mainRot().rotateVectorInv(velNorm);
 
            m_rot.makeVectorRotation(rot, EGG::Vector3f::ez);
            m_prevPos = prevPos();
 
            calcLanding(false);
 
            f32 scaledDir = std::min(65.0f, move()->dir().y * move()->speed());
            m_attemptedTrickTimer = std::max<s32>(0, scaledDir * 2.0f / 1.3f - 1.0f);
        } else if (status.onBit(eStatus::OverZipper)) {
            dynamics()->setGravity(-1.3f);
 
            EGG::Vector3f side = mainRot().rotateVector(EGG::Vector3f::ez);
            EGG::Vector3f velNorm = velocity();
            velNorm.normalise();
 
            EGG::Quatf sideRot;
            sideRot.makeVectorRotation(side, velNorm);
            sideRot = sideRot.multSwap(mainRot()).multSwap(m_rot);
 
            f32 t = move()->calcSlerpRate(DEG2RAD360, mainRot(), sideRot);
            EGG::Quatf slerp = mainRot().slerpTo(sideRot, t);
            dynamics()->setFullRot(slerp);
            dynamics()->setMainRot(slerp);
 
            --m_attemptedTrickTimer;
 
            calcRot();
            calcLanding(false);
        } else if (status.onBit(eStatus::HalfPipeRamp)) {
            calcLanding(true);
        } else {
            status.resetBit(eStatus::HalfpipeMidair);
        }
    }
 
    m_timer = std::max(0, m_timer - 1);
    m_touchingZipper = isLanding;
}
 
void KartHalfPipe::calcTrick() {
    constexpr s16 TRICK_COOLDOWN = 10;
 
    auto &trick = inputs()->currentState().trick;
 
    if (trick != System::Trick::None) {
        m_nextTimer = TRICK_COOLDOWN;
        m_trick = trick;
    }
 
    const auto &status = KartObjectProxy::status();
 
    if (status.onBit(eStatus::OverZipper)) {
        if (status.offBit(eStatus::ZipperTrick) && m_nextTimer > 0 && state()->airtime() > 3 &&
                state()->airtime() < 10) {
            activateTrick(m_attemptedTrickTimer, m_trick);
        }
    }
 
    m_nextTimer = std::max(0, m_nextTimer - 1);
}
 
void KartHalfPipe::calcRot() {
    if (m_stunt == StuntType::None) {
        return;
    }
 
    m_stuntManager.calcAngle();
 
    f32 angle = m_rotSign * (DEG2RAD * m_stuntManager.angle);
 
    switch (m_stunt) {
    case StuntType::Side360:
    case StuntType::Side720:
        m_stuntRot.setRPY(0.0f, angle, 0.0f);
        break;
    case StuntType::Backside: {
        auto rpy = EGG::Quatf::FromRPY(0.0f, DEG2RAD * (0.25f * -m_rotSign * m_stuntManager.angle),
                0.0f);
        EGG::Vector3f rot = rpy.rotateVector(EGG::Vector3f::ez);
        m_stuntRot.setAxisRotation(angle, rot);
    } break;
    case StuntType::Frontside: {
        EGG::Quatf rpy = EGG::Quatf::FromRPY(0.0f, 0.0f,
                DEG2RAD * (0.2f * -m_rotSign * m_stuntManager.angle));
        EGG::Vector3f rot = rpy.rotateVector(EGG::Vector3f::ey);
        m_stuntRot.setAxisRotation(angle, rot);
    } break;
    case StuntType::Frontflip:
        m_stuntRot.setRPY(m_rotSign * angle, 0.0f, 0.0f);
        break;
    case StuntType::Backflip:
        m_stuntRot.setRPY(-m_rotSign * angle, 0.0f, 0.0f);
        break;
    default:
        break;
    }
 
    physics()->composeStuntRot(m_stuntRot);
}
 
void KartHalfPipe::calcLanding(bool notAirborne) {
    constexpr f32 LANDING_RADIUS = 150.0f;
    constexpr f32 PREVIOUS_RADIUS = 200.0f;
    constexpr f32 MIDAIR_RADIUS = 50.0f;
    constexpr f32 WALL_RADIUS = 100.0f;
 
    constexpr f32 COS_PI_OVER_4 = 0.707f;
 
    Field::CollisionInfo colInfo;
    Field::CollisionInfo colInfo2;
    Field::KCLTypeMask maskOut;
    EGG::Vector3f pos;
    EGG::Vector3f upLocal;
 
    auto &status = KartObjectProxy::status();
    Field::KCLTypeMask mask = KCL_TYPE_ANY_INVISIBLE_WALL;
    bool overZipper = status.onBit(eStatus::OverZipper);
    if (!overZipper) {
        if (notAirborne && velocity().y < 0.0f) {
            mask = KCL_NONE;
        } else {
            mask = KCL_TYPE_BIT(COL_TYPE_HALFPIPE_INVISIBLE_WALL);
        }
    }
 
    status.resetBit(eStatus::HalfpipeMidair);
 
    EGG::Vector3f prevPos = m_prevPos + EGG::Vector3f::ey * PREVIOUS_RADIUS;
 
    bool hasDriverFloorCollision = move()->calcZipperCollision(LANDING_RADIUS, bsp().initialYPos,
            pos, upLocal, prevPos, &colInfo, &maskOut, KCL_TYPE_DRIVER_FLOOR);
 
    prevPos = hasDriverFloorCollision ? EGG::Vector3f::inf : prevPos;
 
    if (overZipper) {
        if (!move()->calcZipperCollision(MIDAIR_RADIUS, bsp().initialYPos, pos, upLocal, prevPos,
                    &colInfo2, &maskOut, mask)) {
            mask |= KCL_TYPE_DRIVER_WALL;
        }
    }
 
    if (move()->calcZipperCollision(WALL_RADIUS, bsp().initialYPos, pos, upLocal, prevPos,
                &colInfo2, &maskOut, mask)) {
        if ((maskOut & ~KCL_TYPE_BIT(COL_TYPE_HALFPIPE_INVISIBLE_WALL)) == 0) {
            status.setBit(eStatus::HalfpipeMidair);
        }
 
        EGG::Vector3f up = move()->up();
        move()->setUp(up + (colInfo2.wallNrm - up) * 0.2f);
        move()->setSmoothedUp(move()->up());
 
        f32 yScale = bsp().initialYPos * scale().y;
        EGG::Vector3f newPos =
                pos + colInfo2.tangentOff + -WALL_RADIUS * colInfo2.wallNrm + yScale * upLocal;
        newPos.y += move()->hopPosY();
 
        dynamics()->setPos(newPos);
        move()->setDir(move()->dir().perpInPlane(move()->up(), true));
        move()->setVel1Dir(move()->dir());
 
        if (overZipper) {
            status.setBit(eStatus::ZipperStick);
        }
 
        m_prevPos = newPos;
    } else {
        if (overZipper) {
            status.resetBit(eStatus::ZipperStick);
        }
    }
 
    if (!hasDriverFloorCollision || status.onBit(eStatus::HalfpipeMidair) ||
            state()->airtime() <= 5) {
        return;
    }
 
    if (colInfo.floorNrm.dot(EGG::Vector3f::ey) <= COS_PI_OVER_4) {
        return;
    }
 
    if (status.onBit(eStatus::OverZipper)) {
        status.resetBit(eStatus::ZipperStick);
    }
}
 
void KartHalfPipe::activateTrick(s32 duration, System::Trick trick) {
    if (duration < 51 || trick == System::Trick::None) {
        m_stunt = StuntType::None;
    } else {
        m_rotSign = m_nextSign;
        bool timerThreshold = duration > 70;
 
        switch (trick) {
        case System::Trick::Up:
            m_stunt = timerThreshold ? StuntType::Backside : StuntType::Backflip;
            break;
        case System::Trick::Down:
            m_stunt = timerThreshold ? StuntType::Frontside : StuntType::Frontflip;
            break;
        case System::Trick::Left:
        case System::Trick::Right:
            m_stunt = timerThreshold ? StuntType::Side720 : StuntType::Side360;
            m_rotSign = trick == System::Trick::Left ? 1.0f : -1.0f;
            break;
        default:
            break;
        }
 
        m_stuntManager.setProperties(static_cast<size_t>(m_stunt));
 
        status().setBit(eStatus::ZipperTrick);
    }
 
    m_stuntRot = EGG::Quatf::ident;
}
 
void KartHalfPipe::end(bool boost) {
    auto &status = KartObjectProxy::status();
    bool overZipper = status.onBit(eStatus::OverZipper);
 
    if (overZipper && state()->airtime() > 5 && boost) {
        move()->activateZipperBoost();
    }
 
    if (status.onBit(eStatus::ZipperTrick)) {
        physics()->composeDecayingStuntRot(m_stuntRot);
    }
 
    if (overZipper) {
        move()->setDir(mainRot().rotateVector(EGG::Vector3f::ez));
        move()->setVel1Dir(move()->dir());
    }
 
    status.resetBit(eStatus::OverZipper, eStatus::ZipperTrick, eStatus::ZipperStick,
            eStatus::HalfpipeMidair);
 
    m_stunt = StuntType::None;
}
 
void KartHalfPipe::StuntManager::calcAngle() {
    if (finalAngle * properties.finalAngleScalar < angle) {
        angleDelta = std::max(properties.angleDeltaMin, angleDelta * angleDeltaFactor);
        angleDeltaFactor = std::max(properties.angleDeltaFactorMin,
                angleDeltaFactor - properties.angleDeltaFactorDecr);
    }
 
    angle = std::min(finalAngle, angle + angleDelta);
}
 
void KartHalfPipe::StuntManager::setProperties(size_t idx) {
    static constexpr std::array<StuntProperties, 6> STUNT_PROPERTIES = {{
            {6.0f, 2.5f, 0.955f, 0.01f, 0.7f, 360.0f},
            {7.0f, 3.0f, 0.955f, 0.01f, 0.7f, 360.0f},
            {7.0f, 3.0f, 0.95f, 0.01f, 0.7f, 360.0f},
            {12.0f, 2.5f, 0.955f, 0.01f, 0.0f, 360.0f},
            {4.0f, 4.0f, 0.98f, 0.01f, 0.0f, 360.0f},
            {9.0f, 3.0f, 0.92f, 0.01f, 0.8f, 720.0f},
    }};
 
    ASSERT(idx < STUNT_PROPERTIES.size());
 
    properties = STUNT_PROPERTIES[idx];
    finalAngle = properties.finalAngle;
    angleDelta = properties.angleDelta;
    angleDeltaFactorDecr = properties.angleDeltaFactorDecr;
    angle = 0.0f;
    angleDeltaFactor = 1.0f;
}
 
} // namespace Kart