ObjectPillar.cc

 
#include "ObjectPillar.hh"
 
#include "game/field/ObjectDirector.hh"
 
#include "game/kart/Reaction.hh"
 
namespace Kinoko::Field {

ObjectPillarBase::ObjectPillarBase(const System::MapdataGeoObj &params) : ObjectKCL(params) {}

ObjectPillarBase::~ObjectPillarBase() = default;

ObjectPillarC::ObjectPillarC(const System::MapdataGeoObj &params)
    : ObjectCollidable(params), m_fallStart(static_cast<u32>(params.setting(0))) {}

ObjectPillarC::~ObjectPillarC() = default;

void ObjectPillarC::calcCollisionTransform() {
    constexpr f32 HEIGHT = 1900.0f;
 
    if (!m_collision) {
        return;
    }
 
    EGG::Matrix34f mat = EGG::Matrix34f::zero;
    mat.makeT(EGG::Vector3f(0.0f, 2.0f * (HEIGHT * scale().y) / 3.0f, 0.0f));
 
    calcTransform();
 
    EGG::Vector3f speed = transform().ps_multVector(EGG::Vector3f::ez * 1000.0f);
    m_collision->transform(transform().multiplyTo(mat), scale(), speed);
}

ObjectPillar::ObjectPillar(const System::MapdataGeoObj &params)
    : ObjectKCL(params), m_state(State::Upright), m_fallStart(static_cast<u32>(params.setting(0))),
      m_targetRotation(F_PI * static_cast<f32>(params.setting(1)) / 180.0f), m_initRot(rot().x),
      m_setupRot(EGG::Vector3f::zero) {
    m_base = EGG::egg_new<ObjectPillarBase>(params);
    m_collidable = EGG::egg_new<ObjectPillarC>(params);
 
    m_base->load();
    m_collidable->load();
 
    m_groundFrame = std::numeric_limits<s32>::max();
}

ObjectPillar::~ObjectPillar() = default;

void ObjectPillar::init() {
    ObjectBase::init();
 
    m_collidable->disableCollision();
    m_setupRot = rot();
    disableCollision();
}

void ObjectPillar::calc() {
    u32 time = System::RaceManager::Instance()->timer();
 
    if (m_state == State::Upright && time < m_fallStart) {
        m_collidable->enableCollision();
    } else if (m_state == State::Upright && time == m_fallStart) {
        // The pillar has now started to fall.
        m_state = State::Break;
    } else if (m_state == State::Break) {
        f32 rot = calcRot(static_cast<s32>(time));
        if (rot < m_targetRotation) {
            setTransform(getUpdatedMatrix(0));
            m_collidable->setTransform(transform());
 
            setRot(EGG::Vector3f(rot, m_setupRot.y, m_setupRot.z));
        } else {
            // The pillar has finished falling.
            // We can now drive on top of the base and on the pillar itself.
            m_state = State::Ground;
 
            m_collidable->disableCollision();
            enableCollision();
            m_groundFrame = time;
        }
 
    } else {
        m_state = State::Ground;
    }
}

const EGG::Matrix34f &ObjectPillar::getUpdatedMatrix(u32 timeOffset) {
    f32 rot = calcRot(System::RaceManager::Instance()->timer() - timeOffset);
    m_workMat.makeRT(EGG::Vector3f(rot, m_setupRot.y, m_setupRot.z), pos());
    return m_workMat;
}

f32 ObjectPillar::calcRot(s32 frame) const {
    constexpr f32 STEP = 1e-7f;
 
    if (m_groundFrame < frame) {
        return m_targetRotation;
    }
 
    frame -= m_fallStart;
    return std::min(m_targetRotation, m_initRot + STEP * static_cast<f32>(frame * frame * frame));
}
 
} // namespace Kinoko::Field