KartParam.hh

#pragma once
 
#include <egg/math/Vector.hh>
 
namespace Kart {
 
struct BSP {
    struct Hitbox {
        u16 enable; 
        EGG::Vector3f position; 
        f32 radius;
        u16 wallsOnly;
        u16 tireCollisionIdx;
    };
    struct Hitbox {…};
    STATIC_ASSERT(sizeof(Hitbox) == 0x18);
 
    struct Wheel {
        u16 enable;
        f32 springStiffness;
        f32 dampingFactor;
        f32 maxTravel;
        EGG::Vector3f relPosition;
        f32 xRot;
        f32 wheelRadius;
        f32 sphereRadius;
        u32 _28;
    };
    struct Wheel {…};
    STATIC_ASSERT(sizeof(Wheel) == 0x2c);
 
    BSP();
    BSP(EGG::RamStream &stream);
 
    void read(EGG::RamStream &stream);
 
    f32 initialYPos;
    std::array<Hitbox, 16> hitboxes; 
    EGG::Vector3f cuboids[2];        
    f32 angVel0Factor;
    f32 _1a0;
    std::array<Wheel, 4> wheels;
    f32 rumbleHeight; 
    u16 rumbleSpeed;  
};
struct BSP {…};
STATIC_ASSERT(sizeof(BSP) == 0x25c);
 
class KartParam {
public:
    struct BikeDisp {
        BikeDisp();
        BikeDisp(EGG::RamStream &stream);
 
        void read(EGG::RamStream &stream);
 
        u8 _00[0x0c - 0x00];
        EGG::Vector3f m_handlePos;
        EGG::Vector3f m_handleRot;
        u8 _24[0xb0 - 0x24];
    };
    struct BikeDisp {…};
    STATIC_ASSERT(sizeof(BikeDisp) == 0xB0);
 
    struct Stats {
        enum class Body {
            Four_Wheel_Kart = 0,       
            Handle_Relative_Bike = 1,  
            Vehicle_Relative_Bike = 2, 
            Three_Wheel_Kart = 3,      
        };
        enum class Body {…};
 
        enum class DriftType {
            Outside_Drift_Kart = 0,
            Outside_Drift_Bike = 1,
            Inside_Drift_Bike = 2,
        };
        enum class DriftType {…};
 
        Stats();
        Stats(EGG::RamStream &stream);
 
        void read(EGG::RamStream &stream);
        void applyCharacterBonus(EGG::RamStream &stream);
 
        Body body;
        DriftType driftType;
        WeightClass weightClass;
        f32 _00c; 
 
        f32 weight; 
        f32 bumpDeviationLevel;
        f32 speed;        
        f32 turningSpeed; 
        f32 tilt;
        std::array<f32, 4> accelerationStandardA;
        std::array<f32, 3> accelerationStandardT;
        std::array<f32, 2> accelerationDriftA;
        std::array<f32, 1> accelerationDriftT;
        f32 handlingManualTightness;    
        f32 handlingAutomaticTightness; 
        f32 handlingReactivity;         
        f32 driftManualTightness;       
        f32 driftAutomaticTightness;    
        f32 driftReactivity;            
        f32 driftOutsideTargetAngle;
        f32 driftOutsideDecrement;
        u32 miniTurbo;                
        std::array<f32, 32> kclSpeed; 
        std::array<f32, 32> kclRot;   
        f32 itemUnk170;               
        f32 itemUnk174;               
        f32 itemUnk178;               
        f32 itemUnk17c;               
        f32 maxNormalAcceleration;
        f32 megaScale;
        f32 wheelDistance;
    };
    struct Stats {…};
    STATIC_ASSERT(sizeof(Stats) == 0x18c);
 
    KartParam(Character character, Vehicle vehicle, u8 playerIdx);
    ~KartParam();
 
    void setTireCount(u16 tireCount) {
        m_tireCount = tireCount;
    }
 
    void setSuspCount(u16 suspCount) {
        m_suspCount = suspCount;
    }
 
    [[nodiscard]] const BSP &bsp() const {
        return m_bsp;
    }
 
    [[nodiscard]] const Stats &stats() const {
        return m_stats;
    }
 
    [[nodiscard]] const BikeDisp &bikeDisp() const {
        return m_bikeDisp;
    }
 
    [[nodiscard]] u8 playerIdx() const {
        return m_playerIdx;
    }
 
    [[nodiscard]] bool isBike() const {
        return m_isBike;
    }
 
    [[nodiscard]] bool isVehicleRelativeBike() const {
        return m_stats.body == Stats::Body::Vehicle_Relative_Bike;
    }
 
    [[nodiscard]] u16 suspCount() const {
        return m_suspCount;
    }
 
    [[nodiscard]] u16 tireCount() const {
        return m_tireCount;
    }
 
private:
    void initStats(Character character, Vehicle vehicle);
    void initBikeDispParams(Vehicle vehicle);
    void initHitboxes(Vehicle vehicle);
 
    Stats m_stats;
    BikeDisp m_bikeDisp;
    BSP m_bsp;
    u8 m_playerIdx;
    bool m_isBike;
    u16 m_suspCount;
    u16 m_tireCount;
};
class KartParam {…};
 
} // namespace Kart