ObjectChoropu.hh

#pragma once
 
#include "game/field/ObjectCollisionSphere.hh"
#include "game/field/StateManager.hh"
#include "game/field/obj/ObjectCollidable.hh"
 
#include "game/kart/KartCollide.hh"
 
#include <vector>
 
namespace Kinoko::Field {
 
class ObjectChoropuGround;
class ObjectChoropuHoll;

class ObjectChoropu : public ObjectCollidable, public StateManager {
public:
    ObjectChoropu(const System::MapdataGeoObj &params);
    ~ObjectChoropu() override;
 
    void init() override;
    void calc() override;

    [[nodiscard]] u32 loadFlags() const override {
        return 1;
    }
 
    Kart::Reaction onCollision(Kart::KartObject *kartObj, Kart::Reaction reactionOnKart,
            Kart::Reaction reactionOnObj, EGG::Vector3f &hitDepth) override;
 
private:
    void enterStateStub();
    void enterDigging();
    void enterPeeking();
    void enterJumping();
    void calcStateStub();
    void calcDigging();
    void calcPeeking();
    void calcJumping();
 
    void calcGround();
    void calcGroundObjs();
    [[nodiscard]] EGG::Matrix34f calcInterpolatedPose(f32 t) const;
 
    owning_span<ObjectChoropuGround *> m_groundObjs;
    ObjectChoropuHoll *m_objHoll;
    s16 m_startFrameOffset;
    u16 m_idleDuration;
    f32 m_groundHeight;
    bool m_isStationary; 
    EGG::Matrix34f m_transMat;
    EGG::Matrix34f m_railMat;
    f32 m_groundLength;
 
    static constexpr f32 RADIUS = 300.0f;
    static constexpr f32 MAX_GROUND_LEN = 3000.0f; 
 
    static constexpr std::array<StateManagerEntry, 5> STATE_ENTRIES = {{
            StateEntry<ObjectChoropu, &ObjectChoropu::enterDigging, &ObjectChoropu::calcDigging>(0),
            StateEntry<ObjectChoropu, &ObjectChoropu::enterPeeking, &ObjectChoropu::calcPeeking>(1),
            StateEntry<ObjectChoropu, &ObjectChoropu::enterStateStub,
                    &ObjectChoropu::calcStateStub>(2),
            StateEntry<ObjectChoropu, &ObjectChoropu::enterJumping, &ObjectChoropu::calcJumping>(3),
            StateEntry<ObjectChoropu, &ObjectChoropu::enterStateStub,
                    &ObjectChoropu::calcStateStub>(4),
    }};
};
 
class ObjectChoropuGround : public ObjectCollidable {
public:
    ObjectChoropuGround(const EGG::Vector3f &pos, const EGG::Vector3f &rot,
            const EGG::Vector3f &scale);
    ~ObjectChoropuGround() override;

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

    Kart::Reaction onCollision(Kart::KartObject * /*kartObj*/, Kart::Reaction reactionOnKart,
            Kart::Reaction /*reactionOnObj*/, EGG::Vector3f &hitDepth) override {
        hitDepth.setZero();
        return reactionOnKart;
    }
 
    void calcPosAndMat(f32 height, const EGG::Matrix34f &mat);
 
    [[nodiscard]] f32 height() const {
        return m_height;
    }
 
private:
    f32 m_height;
};
 
class ObjectChoropuHoll : public ObjectCollidable {
public:
    ObjectChoropuHoll(const System::MapdataGeoObj &params);
    ~ObjectChoropuHoll() override;

    void init() override {
        resize(RADIUS, 0.0f);
    }

    [[nodiscard]] const char *getName() const override {
        return "holl";
    }

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

    [[nodiscard]] const char *getKclName() const override {
        return "holl";
    }

    void createCollision() override {
        m_collision = EGG::egg_new<ObjectCollisionSphere>(RADIUS, EGG::Vector3f::zero);
    }

    void loadRail() override {}

    Kart::Reaction onCollision(Kart::KartObject * /*kartObj*/, Kart::Reaction /*reactionOnKart*/,
            Kart::Reaction /*reactionOnObj*/, EGG::Vector3f &hitDepth) override {
        hitDepth.setZero();
        return Kart::Reaction::Wall;
    }
 
private:
    static constexpr f32 RADIUS = 300.0f;
};
 
} // namespace Kinoko::Field