ObjectBird.cc

#include "ObjectBird.hh"
 
#include "game/field/CollisionDirector.hh"
 
#include "game/system/RaceManager.hh"
 
namespace Kinoko::Field {

ObjectBird::ObjectBird(const System::MapdataGeoObj &params) : ObjectCollidable(params) {
    m_leader = EGG::egg_new<ObjectBirdLeader>(params, this);
    m_leader->load();
 
    u32 count = params.setting(1);
    if (count == 0) {
        count = 5;
    }
 
    m_followers = owning_span<ObjectBirdFollower *>(count);
 
    for (u32 i = 0; i < count; ++i) {
        auto *bird = EGG::egg_new<ObjectBirdFollower>(params, this, i);
        m_followers[i] = bird;
        bird->load();
    }
}

ObjectBird::~ObjectBird() = default;

void ObjectBird::calc() {
    constexpr f32 MIN_SPACING = 300.0f;
 
    for (u32 i = 0; i < m_followers.size() - 1; ++i) {
        const EGG::Vector3f &firstPos = m_followers[i]->pos();
 
        for (u32 j = i + 1; j < m_followers.size(); ++j) {
            const EGG::Vector3f &secondPos = m_followers[j]->pos();
            EGG::Vector3f posDelta = firstPos - secondPos;
            f32 len = posDelta.length();
 
            if (len >= MIN_SPACING) {
                continue;
            }
 
            posDelta.normalise();
            m_followers[j]->setPos(secondPos - posDelta * (MIN_SPACING - len));
        }
    }
}

ObjectBirdLeader::ObjectBirdLeader(const System::MapdataGeoObj &params, ObjectBird *bird)
    : ObjectCollidable(params), m_bird(bird) {}

ObjectBirdLeader::~ObjectBirdLeader() = default;

void ObjectBirdLeader::init() {
    auto *anmMgr = m_drawMdl->anmMgr();
    anmMgr->playAnim(0.0f, 1.0f, 0);
    f32 frameCount = anmMgr->activeAnim(Render::AnmType::Chr)->frameCount();
 
    auto &rand = System::RaceManager::Instance()->random();
    f32 rate = rand.getF32(static_cast<f32>(frameCount));
    anmMgr->playAnim(rate, 1.0f, 0);
 
    m_railInterpolator->init(0.0f, 0);
    m_railInterpolator->calc();
    setPos(m_railInterpolator->curPos());
    m_railInterpolator->setCurrVel(static_cast<f32>(m_mapObj->setting(0)));
}

void ObjectBirdLeader::calc() {
    m_railInterpolator->calc();
    setPos(m_railInterpolator->curPos());
}

void ObjectBirdLeader::loadAnims() {
    std::array<const char *, 1> names = {{
            "flying",
    }};
 
    std::array<Render::AnmType, 1> types = {{
            Render::AnmType::Chr,
    }};
 
    linkAnims(names, types);
}

ObjectBirdFollower::ObjectBirdFollower(const System::MapdataGeoObj &params, ObjectBird *bird,
        u32 idx)
    : ObjectBirdLeader(params, bird), m_idx(idx) {}

ObjectBirdFollower::~ObjectBirdFollower() = default;

void ObjectBirdFollower::init() {
    constexpr f32 POS_DELTA_RANGE = 1000.0f;
    constexpr f32 POS_DELTA_CENTER = 500.0f;
 
    auto *anmMgr = m_drawMdl->anmMgr();
    anmMgr->playAnim(0.0f, 1.0f, 0);
    f32 frameCount = anmMgr->activeAnim(Render::AnmType::Chr)->frameCount();
 
    auto &rand = System::RaceManager::Instance()->random();
    f32 rate = rand.getF32(static_cast<f32>(frameCount));
    anmMgr->playAnim(rate, 1.0f, 0);
 
    m_baseSpeed = static_cast<f32>(m_mapObj->setting(0));
    m_velocity = EGG::Vector3f::ez * m_baseSpeed;
 
    f32 z = rand.getF32(POS_DELTA_RANGE) - POS_DELTA_CENTER;
    f32 y = rand.getF32(POS_DELTA_RANGE) - POS_DELTA_CENTER;
    f32 x = rand.getF32(POS_DELTA_RANGE) - POS_DELTA_CENTER;
    EGG::Vector3f delta = EGG::Vector3f(x, y, z);
 
    setPos(m_bird->leader()->pos() + delta);
}

void ObjectBirdFollower::calc() {
    calcPos();
 
    CollisionInfo info;
 
    if (CollisionDirector::Instance()->checkSphereFull(100.0f, pos(), EGG::Vector3f::inf,
                KCL_TYPE_FLOOR, &info, nullptr, 0)) {
        addPos(info.tangentOff);
    }
}

void ObjectBirdFollower::calcPos() {
    constexpr f32 MAX_SPEED_FACTOR = 1.2f;
 
    EGG::Vector3f leaderPos = m_bird->leader()->pos();
    const auto &follower = m_bird->followers();
 
    for (u32 i = 0; i < follower.size(); ++i) {
        if (i != m_idx) {
            leaderPos += follower[i]->pos();
        }
    }
 
    EGG::Vector3f posDelta = leaderPos * (1.0f / static_cast<f32>(follower.size())) - pos();
    posDelta.normalise();
    posDelta *= 0.5f;
 
    m_velocity += posDelta;
 
    if (m_velocity.length() > m_baseSpeed * MAX_SPEED_FACTOR) {
        m_velocity.normalise();
        m_velocity *= m_baseSpeed * MAX_SPEED_FACTOR;
    }
 
    addPos(m_velocity);
}
 
} // namespace Kinoko::Field