KartMove.hh

#pragma once
 
#include "game/kart/KartBoost.hh"
#include "game/kart/KartBurnout.hh"
#include "game/kart/KartHalfPipe.hh"
#include "game/kart/KartObjectProxy.hh"
#include "game/kart/KartParam.hh"
#include "game/kart/KartReject.hh"
#include "game/kart/KartState.hh"
 
#include "game/field/CourseColMgr.hh"
 
#include <egg/core/BitFlag.hh>
 
namespace Kart {
 
class KartMove : protected KartObjectProxy {
public:
    enum class ePadType {
        BoostPanel = 0,
        BoostRamp = 1,
        JumpPad = 2,
    };
 
    enum class DriftState {
        NotDrifting = 0,
        ChargingMt = 1,
        ChargedMt = 2,
        ChargingSmt = 2,
        ChargedSmt = 3,
    };
 
    typedef EGG::TBitFlag<u32, ePadType> PadType;
 
    KartMove();
    virtual ~KartMove();
 
    virtual void createSubsystems(const KartParam::Stats &stats);
    virtual void calcTurn();
    virtual void calcWheelie() {}
    virtual void setTurnParams();
    virtual void init(bool b1, bool b2);
    virtual void clear();
 
    [[nodiscard]] virtual f32 leanRot() const {
        return 0.0f;
    }
 
    void setInitialPhysicsValues(const EGG::Vector3f &position, const EGG::Vector3f &angles);
    void resetDriftManual();
 
    void calc();
    void calcRespawnStart();
    void calcInRespawn();
    void calcRespawnBoost();
    void calcTop();
    void calcAirtimeTop();
    void calcSpecialFloor();
    void calcDirs();
    void calcStickyRoad();
    void calcOffroad();
    void calcRisingWater();
    void calcBoost();
    void calcRampBoost();
    void calcDisableBackwardsAccel();
    void calcSsmt();
    bool calcPreDrift();
    void calcAutoDrift();
    void calcManualDrift();
    void startManualDrift();
    void clearDrift();
    void clearJumpPad();
    void clearRampBoost();
    void clearZipperBoost();
    void clearBoost();
    void clearSsmt();
    void clearOffroadInvincibility();
    void clearRejectRoad();
    void releaseMt();
    void controlOutsideDriftAngle();
    void calcRotation();
    void calcVehicleSpeed();
    void calcDeceleration();
    [[nodiscard]] f32 calcVehicleAcceleration() const;
    void calcAcceleration();
    [[nodiscard]] f32 calcWallCollisionSpeedFactor(f32 &f1);
    void calcWallCollisionStart(f32 param_2);
    void calcStandstillBoostRot();
    void calcDive();
    void calcSsmtStart();
    void calcHopPhysics();
    void calcRejectRoad();
    bool calcZipperCollision(f32 radius, f32 scale, EGG::Vector3f &pos, EGG::Vector3f &upLocal,
            const EGG::Vector3f &prevPos, Field::CollisionInfo *colInfo,
            Field::KCLTypeMask *maskOut, Field::KCLTypeMask flags) const;
    f32 calcSlerpRate(f32 scale, const EGG::Quatf &from, const EGG::Quatf &to) const;
    void applyForce(f32 force, const EGG::Vector3f &hitDir, bool stop);
    virtual void calcVehicleRotation(f32 turn);
    virtual void hop();
    virtual void onHop() {}
    virtual void onWallCollision() {}
    virtual void calcMtCharge();
    virtual void initOob();
 
    [[nodiscard]] virtual f32 getWheelieSoftSpeedLimitBonus() const {
        return 0.0f;
    }
 
    virtual bool canWheelie() const {
        return false;
    }
 
    virtual bool canHop() const {
        const auto &status = KartObjectProxy::status();
 
        if (status.offAnyBit(eStatus::HopStart, eStatus::TouchingGround)) {
            return false;
        }
 
        if (status.onBit(eStatus::InAction)) {
            return false;
        }
 
        return true;
    }
 
    bool canStartDrift() const {
        return m_speed >= MINIMUM_DRIFT_THRESOLD * m_baseSpeed;
    }
 
    void tryStartBoostPanel();
    void tryStartBoostRamp();
    void tryStartJumpPad();
    void tryEndJumpPad();
    void cancelJumpPad();
 
    void activateBoost(KartBoost::Type type, s16 frames);
    void applyStartBoost(s16 frames);
    void activateMushroom();
    void activateZipperBoost();
    void setOffroadInvincibility(s16 timer);
    void calcOffroadInvincibility();
    void calcMushroomBoost();
    void calcZipperBoost();
    void landTrick();
    void activateCrush(u16 timer);
    void calcCrushed();
    void calcScale();
 
    void activateShrink() {
        applyShrink(300);
    }
 
    void applyShrink(u16 timer);
    void calcShock();
    void deactivateShock(bool resetSpeed);
 
    void enterCannon();
    void calcCannon();
    void calcRotCannon(const EGG::Vector3f &forward);
    void exitCannon();
 
    void triggerRespawn();
 
    void setSpeed(f32 val) {
        m_speed = val;
    }
 
    void setSmoothedUp(const EGG::Vector3f &v) {
        m_smoothedUp = v;
    }
 
    void setUp(const EGG::Vector3f &v) {
        m_up = v;
    }
 
    void setDir(const EGG::Vector3f &v) {
        m_dir = v;
    }
 
    void setVel1Dir(const EGG::Vector3f &v) {
        m_vel1Dir = v;
    }
 
    void setFloorCollisionCount(u16 count) {
        m_floorCollisionCount = count;
    }
 
    void setKCLWheelSpeedFactor(f32 val) {
        m_kclWheelSpeedFactor = val;
    }
 
    void setKCLWheelRotFactor(f32 val) {
        m_kclWheelRotFactor = val;
    }
 
    void setKartSpeedLimit() {
        constexpr f32 LIMIT = 120.0f;
        m_hardSpeedLimit = LIMIT;
    }
 
    void setScale(const EGG::Vector3f &v) {
        m_scale = v;
    }
 
    void setPadType(PadType type) {
        m_padType = type;
    }
 
    [[nodiscard]] DriftState driftState() const {
        return m_driftState;
    }
 
    [[nodiscard]] u16 mtCharge() const {
        return m_mtCharge;
    }
 
    [[nodiscard]] f32 kclSpeedFactor() const {
        return m_kclSpeedFactor;
    }
 
    [[nodiscard]] f32 kclRotFactor() const {
        return m_kclRotFactor;
    }
 
    [[nodiscard]] s32 getAppliedHopStickX() const {
        return canStartDrift() ? m_hopStickX : 0;
    }
 
    [[nodiscard]] f32 softSpeedLimit() const {
        return m_softSpeedLimit;
    }
 
    [[nodiscard]] f32 speed() const {
        return m_speed;
    }
 
    [[nodiscard]] f32 acceleration() const {
        return m_acceleration;
    }
 
    [[nodiscard]] const EGG::Vector3f &scale() const {
        return m_scale;
    }
 
    [[nodiscard]] f32 hardSpeedLimit() const {
        return m_hardSpeedLimit;
    }
 
    [[nodiscard]] const EGG::Vector3f &smoothedUp() const {
        return m_smoothedUp;
    }
 
    [[nodiscard]] const EGG::Vector3f &up() const {
        return m_up;
    }
 
    [[nodiscard]] f32 totalScale() const {
        return m_totalScale;
    }
 
    [[nodiscard]] f32 hitboxScale() const {
        return m_hitboxScale;
    }
 
    [[nodiscard]] const EGG::Vector3f &dir() const {
        return m_dir;
    }
 
    [[nodiscard]] const EGG::Vector3f &lastDir() const {
        return m_lastDir;
    }
 
    [[nodiscard]] const EGG::Vector3f &vel1Dir() const {
        return m_vel1Dir;
    }
 
    [[nodiscard]] const EGG::Vector3f &smoothedForward() const {
        return m_smoothedForward;
    }
 
    [[nodiscard]] f32 speedRatioCapped() const {
        return m_speedRatioCapped;
    }
 
    [[nodiscard]] f32 speedRatio() const {
        return m_speedRatio;
    }
 
    [[nodiscard]] u16 floorCollisionCount() const {
        return m_floorCollisionCount;
    }
 
    [[nodiscard]] s32 hopStickX() const {
        return m_hopStickX;
    }
 
    [[nodiscard]] f32 hopPosY() const {
        return m_hopPosY;
    }
 
    [[nodiscard]] s16 respawnTimer() const {
        return m_respawnTimer;
    }
 
    [[nodiscard]] s16 respawnPostLandTimer() const {
        return m_respawnPostLandTimer;
    }
 
    [[nodiscard]] PadType &padType() {
        return m_padType;
    }
 
    [[nodiscard]] KartJump *jump() const {
        return m_jump;
    }
 
    [[nodiscard]] KartHalfPipe *halfPipe() const {
        return m_halfPipe;
    }
 
    [[nodiscard]] KartScale *kartScale() const {
        return m_kartScale;
    }
 
    [[nodiscard]] KartBurnout &burnout() {
        return m_burnout;
    }
 
protected:
    enum class eFlags {
        Respawned = 0,   
        DriftReset = 1,  
        SsmtCharged = 2, 
        LaunchBoost = 4,
        SsmtLeeway = 5,       
        TrickableSurface = 6, 
        WallBounce = 8,       
    };
    typedef EGG::TBitFlag<u16, eFlags> Flags;
 
    enum class DrivingDirection {
        Forwards = 0,
        Braking = 1,
        WaitingForBackwards = 2, 
        Backwards = 3,
    };
 
    struct JumpPadProperties {
        f32 minSpeed;
        f32 maxSpeed;
        f32 velY;
    };
 
    struct DriftingParameters {
        f32 hopVelY;
        f32 stabilizationFactor;
        f32 _8;
        f32 boostRotFactor;
    };
 
    f32 m_baseSpeed;      
    f32 m_softSpeedLimit; 
    f32 m_speed;          
    f32 m_lastSpeed;      
    f32 m_processedSpeed; 
    f32 m_hardSpeedLimit; 
    f32 m_acceleration;   
    f32 m_speedDragMultiplier;  
    EGG::Vector3f m_smoothedUp; 
    EGG::Vector3f m_up;         
    EGG::Vector3f m_landingDir;
    EGG::Vector3f m_dir;
    EGG::Vector3f m_lastDir; 
    EGG::Vector3f m_vel1Dir;
    EGG::Vector3f m_smoothedForward;
    EGG::Vector3f m_dirDiff;
    bool m_hasLandingDir;
    f32 m_outsideDriftAngle; 
    f32 m_landingAngle;
    EGG::Vector3f m_outsideDriftLastDir; 
    f32 m_speedRatioCapped;              
    f32 m_speedRatio;     
    f32 m_kclSpeedFactor; 
    f32 m_kclRotFactor;   
    f32 m_kclWheelSpeedFactor; 
    f32 m_kclWheelRotFactor;   
    u16 m_floorCollisionCount; 
    s32 m_hopStickX;        
    s32 m_hopFrame;         
    EGG::Vector3f m_hopUp;  
    EGG::Vector3f m_hopDir; 
    f32 m_divingRot;        
    f32 m_standStillBoostRot;
    DriftState m_driftState;
    u16 m_mtCharge;          
    u16 m_smtCharge;         
    f32 m_outsideDriftBonus; 
    KartBoost m_boost;
    s16 m_zipperBoostTimer;
    s16 m_zipperBoostMax;
    KartReject m_reject;
    s16 m_offroadInvincibility;  
    s16 m_ssmtCharge;            
    s16 m_ssmtLeewayTimer;       
    s16 m_ssmtDisableAccelTimer; 
    f32 m_realTurn; 
    f32 m_weightedTurn;    
    EGG::Vector3f m_scale; 
    f32 m_totalScale;      
    f32 m_hitboxScale;
    f32 m_shockSpeedMultiplier;
    u16 m_mushroomBoostTimer; 
    f32 m_invScale;
    u16 m_shockTimer;
    u16 m_crushTimer; 
    u32 m_nonZipperAirtime;
    f32 m_jumpPadMinSpeed; 
    f32 m_jumpPadMaxSpeed;
    f32 m_jumpPadBoostMultiplier;
    f32 m_jumpPadSoftSpeedLimit;
    const JumpPadProperties *m_jumpPadProperties;
    u16 m_rampBoost;
    f32 m_autoDriftAngle;
    s16 m_autoDriftStartFrameCounter;
    f32 m_cannonEntryOfsLength;
    EGG::Vector3f m_cannonEntryPos;
    EGG::Vector3f m_cannonEntryOfs;
    EGG::Vector3f m_cannonOrthog;
    EGG::Vector3f m_cannonProgress;
    f32 m_hopVelY;    
    f32 m_hopPosY;    
    f32 m_hopGravity; 
    s16 m_timeInRespawn;        
    s16 m_respawnPreLandTimer;  
    s16 m_respawnPostLandTimer; 
    s16 m_respawnTimer;
    s16 m_bumpTimer;                     
    DrivingDirection m_drivingDirection; 
    s16 m_backwardsAllowCounter;         
    PadType m_padType;
    Flags m_flags;
    KartJump *m_jump;
    KartHalfPipe *m_halfPipe;                   
    KartScale *m_kartScale;                     
    KartBurnout m_burnout;                      
    const DriftingParameters *m_driftingParams; 
    f32 m_rawTurn; 
 
    static constexpr f32 MINIMUM_DRIFT_THRESOLD = 0.55f;
};
 
class KartMoveBike : public KartMove {
public:
    struct TurningParameters {
        f32 leanRotShallowFactor;
        f32 leanRotIncRace;
        f32 leanRotCapRace;
        f32 driftStickXFactor;
        f32 leanRotMaxDrift;
        f32 leanRotMinDrift;
        f32 leanRotIncCountdown;
        f32 leanRotCapCountdown;
        f32 leanRotIncSSMT;
        f32 leanRotCapSSMT;
        f32 leanRotDecayFactor;
        u16 maxWheelieFrames;
    };
 
    KartMoveBike();
    ~KartMoveBike();
 
    virtual void startWheelie();
    virtual void cancelWheelie();
 
    void createSubsystems(const KartParam::Stats &stats) override;
    void calcVehicleRotation(f32 /*turn*/) override;
    void calcWheelie() override;
    void onHop() override;
    void onWallCollision() override;
    void calcMtCharge() override;
    void initOob() override;
    void setTurnParams() override;
    void init(bool b1, bool b2) override;
    void clear() override;
 
    [[nodiscard]] f32 getWheelieSoftSpeedLimitBonus() const override {
        constexpr f32 WHEELIE_SPEED_BONUS = 0.15f;
        return status().onBit(eStatus::Wheelie) ? WHEELIE_SPEED_BONUS : 0.0f;
    }
 
    [[nodiscard]] f32 wheelieRotFactor() const {
        constexpr f32 WHEELIE_ROTATION_FACTOR = 0.2f;
 
        return status().onBit(eStatus::Wheelie) ? WHEELIE_ROTATION_FACTOR : 1.0f;
    }
 
    void tryStartWheelie();
 
    [[nodiscard]] f32 leanRot() const override {
        return m_leanRot;
    }
 
    [[nodiscard]] bool canWheelie() const override {
        constexpr f32 WHEELIE_THRESHOLD = 0.3f;
 
        return m_speedRatioCapped >= WHEELIE_THRESHOLD && m_speed >= 0.0f;
    }
 
 
private:
    f32 m_leanRot;         
    f32 m_leanRotCap;      
    f32 m_leanRotInc;      
    f32 m_wheelieRot;      
    f32 m_maxWheelieRot;   
    u32 m_wheelieFrames;   
    s16 m_wheelieCooldown; 
    f32 m_wheelieRotDec;   
    s16 m_autoHardStickXFrames;
    const TurningParameters *m_turningParams; 
};
 
} // namespace Kart