KartState.cc

#include "KartState.hh"
 
#include "game/kart/CollisionGroup.hh"
#include "game/kart/KartCollide.hh"
#include "game/kart/KartDynamics.hh"
#include "game/kart/KartJump.hh"
#include "game/kart/KartMove.hh"
 
#include "game/system/RaceManager.hh"
 
namespace Kart {
 
struct StartBoostEntry {
    f32 range;
    s16 frames;
};
 
static constexpr std::array<StartBoostEntry, 6> START_BOOST_ENTRIES = {{
        {0.85f, 0},
        {0.88f, 10},
        {0.905f, 20},
        {0.925f, 30},
        {0.94f, 45},
        {0.95f, 70},
}};
 
KartState::KartState() {
    m_status.makeAllZero();
 
    m_status.changeBit(inputs()->driftIsAuto(), eStatus::AutoDrift);
 
    m_airtime = 0;
    m_cannonPointId = 0;
    m_startBoostIdx = 0;
}
 
void KartState::init() {
    reset();
}
 
void KartState::reset() {
    // In the base game, we only wipe bitfield 0, 1, 2, and 3, so we need to bring back bitfield4.
    bool isAutoDrift = m_status.onBit(eStatus::AutoDrift);
    m_status.makeAllZero().changeBit(isAutoDrift, eStatus::AutoDrift);
 
    m_airtime = 0;
    m_top.setZero();
    m_hwgTimer = 0;
    m_boostRampType = -1;
    m_jumpPadVariant = -1;
    m_halfPipeInvisibilityTimer = 0;
    m_startBoostCharge = 0.0f;
    m_stickX = 0.0f;
    m_wallBonkTimer = 0;
    m_trickableTimer = 0;
}
 
void KartState::calcInput() {
    const auto *raceMgr = System::RaceManager::Instance();
    if (raceMgr->isStageReached(System::RaceManager::Stage::Race)) {
        if (m_status.offBit(eStatus::InAction, eStatus::BeforeRespawn, eStatus::CannonStart,
                    eStatus::InCannon, eStatus::OverZipper)) {
            const auto &currentState = inputs()->currentState();
            const auto &lastState = inputs()->lastState();
            m_stickX = currentState.stick.x;
            m_stickY = currentState.stick.y;
 
            if (m_status.offBit(eStatus::RejectRoadTrigger)) {
                if (m_stickX < 0.0f) {
                    m_status.setBit(eStatus::StickLeft);
                } else if (m_stickX > 0.0f) {
                    m_status.setBit(eStatus::StickRight);
                }
            }
 
            if (m_status.offBit(eStatus::Burnout)) {
                m_status.changeBit(currentState.accelerate(), eStatus::Accelerate)
                        .changeBit(currentState.accelerate() && !lastState.accelerate(),
                                eStatus::AccelerateStart)
                        .changeBit(currentState.brake(), eStatus::Brake);
 
                if (m_status.offBit(eStatus::AutoDrift)) {
                    m_status.changeBit(currentState.drift(), eStatus::DriftInput)
                            .changeBit(currentState.drift() && !lastState.drift(),
                                    eStatus::HopStart);
                }
            }
        }
 
        calcHandleStartBoost();
    } else {
        if (!raceMgr->isStageReached(System::RaceManager::Stage::Countdown)) {
            return;
        }
 
        const auto &currentState = inputs()->currentState();
        m_stickX = currentState.stick.x;
        m_status.changeBit(currentState.accelerate(), eStatus::ChargeStartBoost);
 
        calcStartBoost();
    }
}
 
void KartState::calc() {
    resetFlags();
 
    collide()->calcBeforeRespawn();
 
    calcCollisions();
    collide()->calcBoundingRadius();
}
 
void KartState::resetFlags() {
    m_status.resetBit(eStatus::Accelerate, eStatus::Brake, eStatus::DriftInput, eStatus::HopStart,
            eStatus::AccelerateStart, eStatus::GroundStart, eStatus::StickLeft,
            eStatus::WallCollisionStart, eStatus::AirStart, eStatus::StickRight,
            eStatus::ZipperInvisibleWall, eStatus::JumpPadDisableYsusForce,
            eStatus::CollidingOffroad, eStatus::JumpPadDisableYsusForce);
 
    m_stickY = 0.0f;
    m_stickX = 0.0f;
}
 
void KartState::calcCollisions() {
    bool wasTouchingGround = m_status.onBit(eStatus::TouchingGround);
    bool wasWallCollision = m_status.onBit(eStatus::WallCollision, eStatus::Wall3Collision);
 
    m_status.resetBit(eStatus::Wall3Collision, eStatus::WallCollision,
            eStatus::VehicleBodyFloorCollision, eStatus::AnyWheelCollision,
            eStatus::AllWheelsCollision, eStatus::TouchingGround);
 
    if (m_hwgTimer > 0) {
        if (--m_hwgTimer == 0) {
            m_status.resetBit(eStatus::UNK2, eStatus::SomethingWallCollision);
        }
    }
 
    m_top.setZero();
    bool softWallCollision = false;
 
    if (collide()->someSoftWallTimer() > 0) {
        if (collide()->someNonSoftWallTimer() == 0) {
            softWallCollision = true;
        } else {
            f32 softSusp = collide()->suspBottomHeightSoftWall() /
                    static_cast<f32>(collide()->someSoftWallTimer());
            f32 nonSusp = collide()->suspBottomHeightNonSoftWall() /
                    static_cast<f32>(collide()->someNonSoftWallTimer());
 
            if (softSusp - nonSusp >= 40.0f) {
                m_status.resetBit(eStatus::SoftWallDrift);
            } else {
                softWallCollision = true;
            }
        }
    }
 
    u16 wheelCollisions = 0;
    u16 softWallCount = 0;
    EGG::Vector3f wallNrm = EGG::Vector3f::zero;
    bool trickable = false;
 
    for (u16 tireIdx = 0; tireIdx < tireCount(); ++tireIdx) {
        const auto &colData = collisionData(tireIdx);
        if (hasFloorCollision(tirePhysics(tireIdx))) {
            m_top += colData.floorNrm;
            trickable = trickable || colData.bTrickable;
            ++wheelCollisions;
        }
 
        if (softWallCollision && colData.bSoftWall) {
            ++softWallCount;
            wallNrm += colData.noBounceWallNrm;
        }
    }
 
    if (wheelCollisions > 0) {
        m_status.setBit(eStatus::AnyWheelCollision);
        if (wheelCollisions == tireCount()) {
            m_status.setBit(eStatus::AllWheelsCollision);
        }
    }
 
    CollisionData &colData = collisionData();
    if (colData.bFloor) {
        m_status.setBit(eStatus::VehicleBodyFloorCollision);
        m_top += colData.floorNrm;
        trickable = trickable || colData.bTrickable;
 
        if (m_status.onBit(eStatus::OverZipper) && m_status.offBit(eStatus::HalfpipeMidair)) {
            halfPipe()->end(true);
        }
    }
 
    bool hitboxGroupSoftWallCollision = false;
    if (softWallCollision && colData.bSoftWall) {
        hitboxGroupSoftWallCollision = true;
        ++softWallCount;
        wallNrm += colData.wallNrm;
    }
 
    bool bVar3 = colData.bInvisibleWallOnly && m_halfPipeInvisibilityTimer > 0;
    m_halfPipeInvisibilityTimer = std::max(0, m_halfPipeInvisibilityTimer - 1);
 
    m_wallBonkTimer = std::max(0, m_wallBonkTimer - 1);
 
    bool hwg = false;
 
    if ((colData.bWall || colData.bWall3) && !bVar3) {
        if (colData.bWall) {
            status().setBit(eStatus::WallCollision);
        }
 
        if (colData.bWall3) {
            m_status.setBit(eStatus::Wall3Collision);
        }
 
        if (!wasWallCollision) {
            m_status.setBit(eStatus::WallCollisionStart);
 
            if (wallKclType() == COL_TYPE_SPECIAL_WALL && wallKclVariant() == 0) {
                if (m_status.offBit(eStatus::TriggerRespawn, eStatus::InRespawn,
                            eStatus::AfterRespawn, eStatus::BeforeRespawn, eStatus::InAction,
                            eStatus::CannonStart, eStatus::InCannon)) {
                    action()->start(Kart::Action::UNK_1);
                }
            }
        }
 
        m_wallBonkTimer = 2;
 
        if (m_hwgTimer == 0 && colData.movement.y > 1.0f) {
            EGG::Vector3f movement = colData.movement;
            movement.normalise();
 
            if (movement.dot(EGG::Vector3f::ey) > 0.8f &&
                    colData.wallNrm.dot(EGG::Vector3f::ey) > 0.85f &&
                    (movement.x * colData.wallNrm.x + movement.z * colData.wallNrm.z < 0.0f ||
                            collide()->colPerpendicularity() >= 1.0f)) {
                colData.wallNrm.y = 0.0f;
                colData.wallNrm.normalise();
                wallNrm = colData.wallNrm;
 
                if (wallNrm.length() < 0.05f) {
                    wallNrm = movement;
                    wallNrm.y = 0.0f;
                }
 
                hwg = true;
            }
        }
    }
 
    if (colData.bInvisibleWall && m_status.onBit(eStatus::HalfPipeRamp) &&
            collide()->surfaceFlags().offBit(KartCollide::eSurfaceFlags::StopHalfPipeState)) {
        m_status.setBit(eStatus::ZipperInvisibleWall);
    }
 
    if (softWallCount > 0 || hwg) {
        m_status.setBit(eStatus::UNK2);
        m_softWallSpeed = wallNrm;
        m_softWallSpeed.normalise();
        if (softWallCount > 0 && m_status.offBit(eStatus::Hop)) {
            m_status.setBit(eStatus::SoftWallDrift);
        }
 
        if (hwg) {
            m_status.setBit(eStatus::HWG);
        }
 
        if (hitboxGroupSoftWallCollision || hwg || isBike()) {
            m_status.setBit(eStatus::SomethingWallCollision);
            m_hwgTimer = 10;
 
            if (hwg) {
                m_hwgTimer *= 2;
            }
        }
    }
 
    m_status.resetBit(eStatus::AirtimeOver20);
    m_trickableTimer = std::max(0, m_trickableTimer - 1);
 
    if (wheelCollisions < 1 && !colData.bFloor) {
        if (wasTouchingGround) {
            m_status.setBit(eStatus::AirStart);
        }
 
        if (++m_airtime > 20) {
            m_status.setBit(eStatus::AirtimeOver20);
        }
    } else {
        m_top.normalise();
 
        m_status.setBit(eStatus::TouchingGround).resetBit(eStatus::AfterCannon);
 
        if (m_status.offBit(eStatus::InAction)) {
            m_status.resetBit(eStatus::ActionMidZipper, eStatus::EndHalfPipe);
        }
 
        if (m_status.onBit(eStatus::OverZipper)) {
            halfPipe()->end(true);
        }
 
        if (trickable) {
            m_trickableTimer = 3;
        }
 
        m_status.changeBit(m_trickableTimer > 0, eStatus::Trickable);
 
        if (m_status.offBit(eStatus::JumpPad)) {
            m_status.resetBit(eStatus::JumpPadMushroomCollision);
        }
 
        if (!wasTouchingGround) {
            m_status.setBit(eStatus::GroundStart);
        }
 
        if (m_status.onBit(eStatus::InATrick) && jump()->cooldown() == 0) {
            move()->landTrick();
            dynamics()->setForceUpright(true);
            jump()->end();
        }
 
        m_airtime = 0;
    }
}
 
void KartState::calcStartBoost() {
    constexpr f32 START_BOOST_DELTA_ONE = 0.02f;
    constexpr f32 START_BOOST_DELTA_TWO = 0.002f;
    constexpr f32 START_BOOST_FALLOFF = 0.96f;
 
    if (m_status.onBit(eStatus::ChargeStartBoost)) {
        m_startBoostCharge += START_BOOST_DELTA_ONE -
                (START_BOOST_DELTA_ONE - START_BOOST_DELTA_TWO) * m_startBoostCharge;
    } else {
        m_startBoostCharge *= START_BOOST_FALLOFF;
    }
 
    m_startBoostCharge = std::max(0.0f, std::min(1.0f, m_startBoostCharge));
}
 
void KartState::calcHandleStartBoost() {
    if (System::RaceManager::Instance()->getCountdownTimer() != 0) {
        return;
    }
 
    if (m_status.onBit(eStatus::Accelerate)) {
        if (m_startBoostCharge > START_BOOST_ENTRIES.back().range) {
            m_startBoostIdx = std::numeric_limits<size_t>::max();
        } else if (m_startBoostCharge > START_BOOST_ENTRIES.front().range) {
            // Ranges are exclusive on the lower bound and inclusive on the upper bound
            for (size_t i = 1; i < START_BOOST_ENTRIES.size(); ++i) {
                if (m_startBoostCharge > START_BOOST_ENTRIES[i - 1].range &&
                        m_startBoostCharge <= START_BOOST_ENTRIES[i].range) {
                    m_startBoostIdx = i;
                    break;
                }
            }
        }
    }
 
    if (m_startBoostIdx <= 0) {
        return;
    }
 
    handleStartBoost(m_startBoostIdx);
    m_status.resetBit(eStatus::ChargeStartBoost);
}
 
void KartState::handleStartBoost(size_t idx) {
    if (m_startBoostIdx == std::numeric_limits<size_t>::max()) {
        move()->burnout().start();
    } else {
        move()->applyStartBoost(START_BOOST_ENTRIES[idx].frames);
    }
}
 
void KartState::resetEjection() {
    m_status.resetBit(eStatus::HalfPipeRamp, eStatus::RejectRoad);
}
 
} // namespace Kart