ObjectCow.hh

#pragma once
 
#include "game/field/StateManager.hh"
#include "game/field/obj/ObjectCollidable.hh"
 
namespace Kinoko::Field {
 
class RailInterpolator;

class ObjectCow : public ObjectCollidable {
public:
    ObjectCow(const System::MapdataGeoObj &params);
    ~ObjectCow() override;
 
    Kart::Reaction onCollision(Kart::KartObject *kartObj, Kart::Reaction reactionOnKart,
            Kart::Reaction reactionOnObj, EGG::Vector3f &hitDepth) override;
 
protected:
    virtual void calcFloor();
 
    void setup();
    void calcPos();
    f32 setTarget(const EGG::Vector3f &v);

    [[nodiscard]] static EGG::Vector3f Interpolate(f32 t, const EGG::Vector3f &v0,
            const EGG::Vector3f &v1) {
        return v0 + (v1 - v0) * t;
    }
 
    u32 m_startFrame; 
    EGG::Vector3f m_tangent;
    EGG::Vector3f m_prevTangent;
    EGG::Vector3f m_up;
    EGG::Vector3f m_velocity;
    f32 m_xzSpeed; 
    f32 m_tangentFactor;
    EGG::Vector3f m_floorNrm;
    EGG::Vector3f m_state1TargetPos; 
    EGG::Vector3f m_targetDir;
    EGG::Vector3f m_upForce; 
    f32 m_interpRate;
 
    static constexpr EGG::Vector3f GRAVITY_FORCE = EGG::Vector3f(0.0f, 2.0f, 0.0f);
};

class ObjectCowLeader final : public ObjectCow, public StateManager {
    friend class ObjectCowHerd;
 
public:
    ObjectCowLeader(const System::MapdataGeoObj &params);
    ~ObjectCowLeader() override;
 
    void init() override;
    void calc() override;

    [[nodiscard]] u32 loadFlags() const override {
        return 1;
    }
 
private:
    enum class AnmType {
        EatST = 0,
        Eat = 1,
        EatED = 2,
    };
 
    void calcFloor() override;
 
    void enterWait();
    void enterEat();
    void enterRoam();
 
    void calcWait();
    void calcEat();
    void calcRoam();
 
    f32 m_railSpeed;
    bool m_endedRailSegment;
    AnmType m_state1AnmType;
    u16 m_eatFrames; 
 
    static constexpr std::array<StateManagerEntry, 3> STATE_ENTRIES = {{
            {StateEntry<ObjectCowLeader, &ObjectCowLeader::enterWait, &ObjectCowLeader::calcWait>(
                    0)},
            {StateEntry<ObjectCowLeader, &ObjectCowLeader::enterEat, &ObjectCowLeader::calcEat>(1)},
            {StateEntry<ObjectCowLeader, &ObjectCowLeader::enterRoam, &ObjectCowLeader::calcRoam>(
                    2)},
    }};
};

class ObjectCowFollower final : public ObjectCow, public StateManager {
    friend class ObjectCowHerd;
 
public:
    ObjectCowFollower(const System::MapdataGeoObj &params, const EGG::Vector3f &pos, f32 initRot);
    ~ObjectCowFollower() override;
 
    void init() override;
    void calc() override;

    [[nodiscard]] u32 loadFlags() const override {
        return 1;
    }

    void loadRail() override {}
 
private:
    void enterWait();
    void enterFreeRoam();
    void enterFollowLeader();
 
    void calcWait();
    void calcFreeRoam();
    void calcFollowLeader();
 
    const EGG::Vector3f m_posOffset;
    RailInterpolator *m_rail;
    u16 m_waitFrames;       
    f32 m_topSpeed;         
    bool m_bStopping;       
    f32 m_railSegThreshold; 
 
    static constexpr f32 BASE_TOP_SPEED = 2.0f;
    static constexpr f32 TOP_SPEED_VARIANCE = 4.0f - 2.0f;

    static constexpr f32 DIST_THRESHOLD = 200.0f;
 
    static constexpr std::array<StateManagerEntry, 3> STATE_ENTRIES = {{
            {StateEntry<ObjectCowFollower, &ObjectCowFollower::enterWait,
                    &ObjectCowFollower::calcWait>(0)},
            {StateEntry<ObjectCowFollower, &ObjectCowFollower::enterFreeRoam,
                    &ObjectCowFollower::calcFreeRoam>(1)},
            {StateEntry<ObjectCowFollower, &ObjectCowFollower::enterFollowLeader,
                    &ObjectCowFollower::calcFollowLeader>(2)},
    }};
};

class ObjectCowHerd final : public ObjectCollidable {
public:
    ObjectCowHerd(const System::MapdataGeoObj &params);
    ~ObjectCowHerd() override;
 
    void init() override;
    void calc() override;

    [[nodiscard]] u32 loadFlags() const override {
        return 1;
    }

    void createCollision() override {}

    void loadRail() override {}
 
private:
    void checkIntraCollision();
 
    ObjectCowLeader *m_leader;
    owning_span<ObjectCowFollower *> m_followers;
};
 
} // namespace Kinoko::Field