KartParam.hh

#pragma once
 
#include <egg/math/Vector.hh>
 
namespace Kinoko::Kart {
 
struct BSP {
    struct Hitbox {
        u16 enable; 
        EGG::Vector3f position; 
        f32 radius;
        u16 wallsOnly;
        u16 tireCollisionIdx;
    };
    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;
    };
    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;  
};
STATIC_ASSERT(sizeof(BSP) == 0x25c);
 
class KartParam {
public:
    struct BikeDisp {
        BikeDisp();
        BikeDisp(EGG::RamStream &stream);
 
        void read(EGG::RamStream &stream);
 
        f32 m_cameraDistY;
        u8 _04[0x0c - 0x04];
        EGG::Vector3f m_handlePos;
        EGG::Vector3f m_handleRot;
        u8 _24[0xb0 - 0x24];
    };
    STATIC_ASSERT(sizeof(BikeDisp) == 0xB0);
 
    struct KartDisp {
        KartDisp();
        KartDisp(EGG::RamStream &stream);
 
        void read(EGG::RamStream &stream);
 
        f32 m_cameraDistY;
        u8 _004[0x150 - 0x004];
    };
    STATIC_ASSERT(sizeof(KartDisp) == 0x150);
 
    struct Stats {
        enum class Body {
            Four_Wheel_Kart = 0,       
            Handle_Relative_Bike = 1,  
            Vehicle_Relative_Bike = 2, 
            Three_Wheel_Kart = 3,      
        };
 
        enum class DriftType {
            Outside_Drift_Kart = 0,
            Outside_Drift_Bike = 1,
            Inside_Drift_Bike = 2,
        };
 
        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 shrinkScale;
    };
    STATIC_ASSERT(sizeof(Stats) == 0x18c);
 
    struct KartCameraParam {
        KartCameraParam();
        KartCameraParam(EGG::RamStream &stream);
 
        void read(EGG::RamStream &stream);
 
        f32 fov;
        f32 dist;
        f32 posY;
        f32 targetPosY;
    };
 
    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]] const KartDisp &kartDisp() const {
        return m_kartDisp;
    }
 
    [[nodiscard]] const KartCameraParam &camera() const {
        return m_camera;
    }
 
    [[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 initKartDispParams(Vehicle vehicle);
    void initHitboxes(Vehicle vehicle);
    void initCameraParams(Character character);
 
    Stats m_stats;
    BikeDisp m_bikeDisp;
    KartDisp m_kartDisp;
    BSP m_bsp;
    KartCameraParam m_camera;
    u8 m_playerIdx;
    bool m_isBike;
    u16 m_suspCount;
    u16 m_tireCount;
};
 
} // namespace Kinoko::Kart