ObjectChoropu.cc

#include "ObjectChoropu.hh"
 
#include "game/field/ObjectDirector.hh"
#include "game/field/RailManager.hh"
 
#include "game/kart/Reaction.hh"
 
#include "game/system/RaceManager.hh"
 
namespace Kinoko::Field {

ObjectChoropu::ObjectChoropu(const System::MapdataGeoObj &params)
    : ObjectCollidable(params), StateManager(this, STATE_ENTRIES) {
    constexpr f32 MAX_SPEED = 20.0f;
 
    m_startFrameOffset = static_cast<s16>(params.setting(1));
    m_idleDuration = params.setting(0);
    m_isStationary = strcmp(getName(), "choropu") != 0;
 
    s16 railIdx = params.pathId();
    if (railIdx != -1) {
        auto *rail = RailManager::Instance()->rail(railIdx);
        rail->checkSphereFull();
    }
 
    // If the mole moves around, then we need to create the dirt trail.
    if (!m_isStationary) {
        const auto &flowTable = ObjectDirector::Instance()->flowTable();
        const auto *collisionSet =
                flowTable.set(flowTable.slot(flowTable.getIdFromName("choropu_ground")));
        ASSERT(collisionSet);
 
        s16 height = parse<s16>(collisionSet->params.cylinder.height);
        size_t groundCount = static_cast<size_t>(MAX_GROUND_LEN / EGG::Mathf::abs(height * 2)) + 1;
        m_groundObjs = owning_span<ObjectChoropuGround *>(groundCount);
 
        for (auto *&obj : m_groundObjs) {
            obj = EGG::egg_new<ObjectChoropuGround>(pos(), rot(), scale());
            obj->load();
            obj->resize(RADIUS, MAX_SPEED);
        }
 
        m_groundHeight = m_groundObjs.front()->height();
    }
 
    m_objHoll = EGG::egg_new<ObjectChoropuHoll>(params);
    m_objHoll->load();
}

ObjectChoropu::~ObjectChoropu() = default;

void ObjectChoropu::init() {
    if (m_isStationary) {
        disableCollision();
 
        m_objHoll->setScale(EGG::Vector3f(1.0f, m_objHoll->scale().y, 1.0f));
        m_nextStateId = 0;
        m_groundLength = 0.0f;
 
        calcTransform();
        m_transMat = transform();
    } else {
        if (m_mapObj->pathId() == -1) {
            return;
        }
 
        m_railInterpolator->init(0.0f, 0);
        m_railInterpolator->setPerPointVelocities(true);
 
        m_railPos = m_railInterpolator->curPos();
        setPos(m_railPos);
 
        disableCollision();
        m_objHoll->disableCollision();
 
        m_nextStateId = 0;
    }
}

void ObjectChoropu::calc() {
    constexpr u32 START_DELAY = 300;
 
    // Nothing to do if the mole hasn't spawned yet
    u32 t = System::RaceManager::Instance()->timer();
    if (t < m_startFrameOffset + START_DELAY) {
        return;
    }
 
    if (!m_isStationary) {
        if (m_mapObj->pathId() == -1) {
            return;
        }
 
        // Kinoko-specific: the base game computes RailOrthonormalBasis() here, but only its
        // translation is ever used, so we skip computing the rotation.
        m_railPos = m_railInterpolator->curPos();
    }
 
    StateManager::calc();
 
    m_objHoll->setScale(EGG::Vector3f(1.0f, m_objHoll->scale().y, 1.0f));
}

Kart::Reaction ObjectChoropu::onCollision(Kart::KartObject * /*kartObj*/,
        Kart::Reaction reactionOnKart, Kart::Reaction /*reactionOnObj*/,
        EGG::Vector3f & /*hitDepth*/) {
    return m_currentStateId == 1 ? Kart::Reaction::SmallBump : reactionOnKart;
}
 
void ObjectChoropu::enterStateStub() {}

void ObjectChoropu::enterDigging() {
    if (m_isStationary) {
        disableCollision();
    } else {
        for (auto *&obj : m_groundObjs) {
            obj->enableCollision();
        }
 
        disableCollision();
        m_objHoll->disableCollision();
        m_groundLength = 0.0f;
    }
}

void ObjectChoropu::enterPeeking() {
    if (m_isStationary) {
        setPos(m_transMat.base(3));
        setRot(EGG::Vector3f(rot().x, rot().y, 0.0f));
 
        enableCollision();
    } else {
        setPos(m_railPos);
        setRot(EGG::Vector3f(rot().x, 0.0f, 0.0f));
        enableCollision();
 
        const auto &curTanDir = m_railInterpolator->curTangentDir();
        s16 curPointIdx = m_railInterpolator->curPointIdx();
        EGG::Matrix34f mat;
        SetRotTangentHorizontal(mat, m_railInterpolator->floorNrm(curPointIdx), curTanDir);
        mat.setBase(3, m_railInterpolator->curPos());
 
        m_objHoll->setTransform(mat);
        m_objHoll->enableCollision();
    }
}

void ObjectChoropu::enterJumping() {
    enableCollision();
 
    setPos(m_isStationary ? m_transMat.base(3) : m_railPos);
    setRot(EGG::Vector3f(rot().x, rot().y, 0.0f));
}
 
void ObjectChoropu::calcStateStub() {}

void ObjectChoropu::calcDigging() {
    if (m_isStationary) {
        if (m_currentFrame > m_idleDuration) {
            m_nextStateId = 1;
        }
 
        return;
    }
 
    setPos(m_railInterpolator->curPos());
 
    if (m_railInterpolator->calc() == RailInterpolator::Status::SegmentEnd) {
        if (m_railInterpolator->curPoint().setting[1] == 1) {
            m_nextStateId = 1;
        } else {
            calcGround();
        }
    } else {
        bool skipGroundCalc = false;
 
        if (m_railInterpolator->nextPoint().setting[1] == 1) {
            f32 invT = 1.0f - m_railInterpolator->segmentT();
            if (invT * m_railInterpolator->getCurrSegmentLength() < 250.0f) {
                skipGroundCalc = true;
            }
        }
 
        if (!skipGroundCalc) {
            calcGround();
        }
    }
}

void ObjectChoropu::calcPeeking() {
    constexpr s16 PEEK_DURATION = 40;
    constexpr s16 STATE_DURATION = 100;
 
    if (!m_isStationary) {
        m_groundLength = std::max(0.0f, m_groundLength - m_railInterpolator->speed());
 
        calcGroundObjs();
    }
 
    if (m_currentFrame > STATE_DURATION) {
        m_nextStateId = 3;
    }
 
    if (m_currentFrame > PEEK_DURATION) {
        disableCollision();
    }
}

void ObjectChoropu::calcJumping() {
    constexpr f32 JUMP_LINEAR_COEFFICIENT = 65.0f;
    constexpr f32 JUMP_QUADRATIC_COEFFICIENT = 2.7f;
 
    if (!m_isStationary) {
        m_groundLength = std::max(0.0f, m_groundLength - m_railInterpolator->speed());
        calcGroundObjs();
    }
 
    // y = -1.35t^2 + 65.0t
    f32 posY = JUMP_LINEAR_COEFFICIENT * static_cast<f32>(m_currentFrame) -
            static_cast<f32>(m_currentFrame) * 0.5f * JUMP_QUADRATIC_COEFFICIENT *
                    static_cast<f32>(m_currentFrame);
 
    if (posY < 0.0f) {
        m_nextStateId = 0;
    }
 
    posY += (m_isStationary ? m_transMat.base(3).y : m_railInterpolator->curPos().y);
    setPos(EGG::Vector3f(pos().x, posY, pos().z));
}

void ObjectChoropu::calcGround() {
    m_groundLength += m_railInterpolator->getCurrVel();
    if (m_groundLength > MAX_GROUND_LEN) {
        m_groundLength = MAX_GROUND_LEN - 1.0f;
    }
 
    calcGroundObjs();
}

void ObjectChoropu::calcGroundObjs() {
    size_t idx =
            std::min(static_cast<size_t>(m_groundLength / m_groundHeight) + 1, m_groundObjs.size());
 
    for (auto *&obj : m_groundObjs) {
        obj->enableCollision();
    }
 
    for (size_t i = idx; i < m_groundObjs.size(); ++i) {
        m_groundObjs[i]->disableCollision();
    }
 
    if (m_groundLength > RADIUS) {
        f32 height = std::min(m_groundHeight, m_groundLength) - RADIUS;
        m_groundObjs[0]->calcPosAndMat(height, calcInterpolatedPose(RADIUS + 0.5f * height));
    }
 
    for (size_t i = 1; i < idx - 1; ++i) {
        f32 height = 0.5f * m_groundHeight + m_groundHeight * static_cast<f32>(i);
        m_groundObjs[i]->calcPosAndMat(m_groundHeight, calcInterpolatedPose(height));
    }
 
    f32 height = m_groundLength - m_groundHeight * static_cast<f32>(idx - 1);
    EGG::Matrix34f mat =
            calcInterpolatedPose(0.5f * height + m_groundHeight * static_cast<f32>(idx - 1));
    m_groundObjs[idx - 1]->calcPosAndMat(height, mat);
}

EGG::Matrix34f ObjectChoropu::calcInterpolatedPose(f32 t) const {
    EGG::Vector3f curDir;
    EGG::Vector3f curTanDir;
    m_railInterpolator->evalCubicBezierOnPath(t, curDir, curTanDir);
    EGG::Matrix34f mat = OrthonormalBasis(curTanDir);
    mat.setBase(3, curDir);
    return mat;
}

ObjectChoropuGround::ObjectChoropuGround(const EGG::Vector3f &pos, const EGG::Vector3f &rot,
        const EGG::Vector3f &scale)
    : ObjectCollidable("choropu_ground", pos, rot, scale) {
    const auto &flowTable = ObjectDirector::Instance()->flowTable();
    const auto *collisionSet =
            flowTable.set(flowTable.slot(flowTable.getIdFromName("choropu_ground")));
    ASSERT(collisionSet);
 
    s16 height = parse<s16>(collisionSet->params.cylinder.height);
    m_height = 2.0f * EGG::Mathf::abs(static_cast<f32>(height));
}

ObjectChoropuGround::~ObjectChoropuGround() = default;

void ObjectChoropuGround::calcPosAndMat(f32 height, const EGG::Matrix34f &mat) {
    EGG::Matrix34f matTemp;
    SetRotTangentHorizontal(matTemp, mat.base(2), EGG::Vector3f::ey);
    matTemp.setBase(1, matTemp.base(1) * (height / m_height));
    matTemp.setBase(3, mat.base(3));
    setTransform(matTemp);
}

ObjectChoropuHoll::ObjectChoropuHoll(const System::MapdataGeoObj &params)
    : ObjectCollidable(params) {}

ObjectChoropuHoll::~ObjectChoropuHoll() = default;
 
} // namespace Kinoko::Field