ObjectFlamePoleFoot.hh

#pragma once
 
#include "game/field/StateManager.hh"
#include "game/field/obj/ObjectFlamePole.hh"
#include "game/field/obj/ObjectKCL.hh"
 
namespace Kinoko::Field {
 
class ObjectFlamePole;
 
class ObjectFlamePoleFoot final : public ObjectKCL, public StateManager {
    friend class Host::Context;
 
public:
    ObjectFlamePoleFoot(const System::MapdataGeoObj &params);
    ~ObjectFlamePoleFoot() override;
 
    void init() override;
    void calc() override;
 
    [[nodiscard]] u32 loadFlags() const override {
        return 1;
    }
 
    [[nodiscard]] f32 getCollisionRadius() const override {
        return 245.0f * static_cast<f32>(m_mapObj->setting(2));
    }
 
    [[nodiscard]] const EGG::Matrix34f &getUpdatedMatrix(u32 /*timeOffset*/) override {
        calcTransform();
        m_workMatrix = m_transform;
        return m_transform;
    }
 
    [[nodiscard]] f32 getScaleY(u32 timeOffset) const override;
    [[nodiscard]] bool checkCollision(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask mask, CollisionInfo *info,
            KCLTypeMask *maskOut, u32 timeOffset) override;
    [[nodiscard]] bool checkCollisionCached(f32 radius, const EGG::Vector3f &pos,
            const EGG::Vector3f &prevPos, KCLTypeMask mask, CollisionInfo *info,
            KCLTypeMask *maskOut, u32 timeOffset) override;
 
private:
    void enterExpanding() {
        m_heightOffset = 0.0f;
    }
 
    void enterEruptingUp();
 
    void enterEruptingStay() {
        m_scaledHeight = m_initScaledHeight;
    }
 
    void enterEruptingDown() {
        m_scaledHeight = m_heightOffset;
    }
 
    void enterDormant() {
        m_pole->setActive(false);
        m_pole->disableCollision();
    }
 
    void enterState5() {}
 
    void calcExpanding() {}
 
    void calcEruptingUp();
    void calcEruptingStay();
 
    void calcEruptingDown() {
        m_heightOffset =
                m_scaledHeight - m_scaleDelta * static_cast<f32>(m_cycleFrame - m_stateStart[3]);
    }
 
    void calcDormant() {}
 
    void calcState5() {}
 
    void calcStates();
 
    EGG::Matrix34f m_workMatrix;
    ObjectFlamePole *m_pole;
    u32 m_extraCycleFrames; 
    u32 m_initDelay;
    f32 m_poleScale;
    s32 m_eruptUpDuration;
    s32 m_eruptDownDuration;
    std::array<s32, 6> m_stateStart;
    f32 m_eruptDownVel;
    f32 m_initScaledHeight;
    s32 m_cycleFrame;
    f32 m_heightOffset; 
    f32 m_scaledHeight;
    f32 m_scaleDelta; 
    f32 m_eruptAccel;
    f32 m_initEruptVel;
 
    static u32 s_flamePoleCount;
 
    static constexpr std::array<StateManagerEntry, 6> STATE_ENTRIES = {{
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterExpanding,
                    &ObjectFlamePoleFoot::calcExpanding>(0)},
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterEruptingUp,
                    &ObjectFlamePoleFoot::calcEruptingUp>(1)},
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterEruptingStay,
                    &ObjectFlamePoleFoot::calcEruptingStay>(2)},
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterEruptingDown,
                    &ObjectFlamePoleFoot::calcEruptingDown>(3)},
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterDormant,
                    &ObjectFlamePoleFoot::calcDormant>(4)},
            {StateEntry<ObjectFlamePoleFoot, &ObjectFlamePoleFoot::enterState5,
                    &ObjectFlamePoleFoot::calcState5>(5)},
    }};
 
    static constexpr u32 CYCLE_FRAMES = 540;
};
 
} // namespace Kinoko::Field