ObjectCow.hh

#pragma once
 
#include "game/field/StateManager.hh"
#include "game/field/obj/ObjectCollidable.hh"
 
namespace 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;
 
template <>
class StateManager<ObjectCowLeader> : public StateManagerBase<ObjectCowLeader> {
public:
    StateManager(ObjectCowLeader *obj);
    ~StateManager() override;
 
private:
    static const std::array<StateManagerEntry<ObjectCowLeader>, 3> STATE_ENTRIES;
};
 
class ObjectCowLeader final : public ObjectCow, public StateManager<ObjectCowLeader> {
    friend class ObjectCowHerd;
    friend class StateManager<ObjectCowLeader>;
 
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; 
};
 
class ObjectCowFollower;
 
template <>
class StateManager<ObjectCowFollower> : public StateManagerBase<ObjectCowFollower> {
public:
    StateManager(ObjectCowFollower *obj);
    ~StateManager() override;
 
private:
    static const std::array<StateManagerEntry<ObjectCowFollower>, 3> STATE_ENTRIES;
};
 
class ObjectCowFollower final : public ObjectCow, public StateManager<ObjectCowFollower> {
    friend class ObjectCowHerd;
    friend class StateManager<ObjectCowFollower>;
 
public:
    ObjectCowFollower(const System::MapdataGeoObj &params, const EGG::Vector3f &pos, f32 rot);
    ~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;
};
 
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 checkCollision();
 
    ObjectCowLeader *m_leader;
    std::span<ObjectCowFollower *> m_followers;
};
 
} // namespace Field