KartObjectManager.cc

#include "KartObjectManager.hh"
 
#include "game/kart/KartCollide.hh"
#include "game/kart/KartParamFileManager.hh"
#include "game/system/RaceConfig.hh"
 
#include <abstract/g3d/ResFile.hh>
 
namespace Kinoko::Kart {
 
void KartObjectManager::init() {
    for (size_t i = 0; i < m_count; ++i) {
        m_objects[i]->initImpl();
        m_objects[i]->prepare();
    }
}
 
void KartObjectManager::calc() {
    for (size_t i = 0; i < m_count; ++i) {
        KartObject *object = m_objects[i];
        object->collide()->setTangentOff(EGG::Vector3f::zero);
        object->collide()->setMovement(EGG::Vector3f::zero);
    }
 
    for (size_t i = 0; i < m_count; ++i) {
        KartObject *object = m_objects[i];
        object->calcSub();
        object->calc();
    }
}
 
KartObjectManager *KartObjectManager::CreateInstance() {
    ASSERT(!s_instance);
    s_instance = new KartObjectManager;
    return s_instance;
}
 
void KartObjectManager::DestroyInstance() {
    ASSERT(s_instance);
    auto *instance = s_instance;
    s_instance = nullptr;
    delete instance;
}
 
KartObjectManager::KartObjectManager() {
    const auto &raceScenario = System::RaceConfig::Instance()->raceScenario();
    m_count = raceScenario.playerCount;
    m_objects = new KartObject *[m_count];
    KartParamFileManager::CreateInstance();
 
    loadScaleAnimations();
 
    for (size_t i = 0; i < m_count; ++i) {
        const auto &player = raceScenario.players[i];
        KartObject *object = KartObject::Create(player.character, player.vehicle, i);
        object->createModel();
        m_objects[i] = object;
    }
}
 
KartObjectManager::~KartObjectManager() {
    if (s_instance) {
        s_instance = nullptr;
        WARN("KartObjectManager instance not explicitly handled!");
    }
 
    KartParamFileManager::DestroyInstance();
 
    for (size_t i = 0; i < m_count; ++i) {
        delete m_objects[i];
    }
 
    delete[] m_objects;
 
    delete s_thunderScaleUpAnmChr;
    delete s_thunderScaleDownAnmChr;
    delete s_pressScaleUpAnmChr;
 
    // If the proxy list is not cleared when we're done with the KartObjectManager, the list's
    // destructor calls delete on all of the links remaining in the list. Since the heaps are
    // gone by that point, this results in a segmentation fault. So, we clear the links here.
    KartObjectProxy::proxyList().clear();
}
 
void KartObjectManager::loadScaleAnimations() {
    auto *resMgr = System::ResourceManager::Instance();
    const void *file = resMgr->getFile("driver.brres", nullptr, System::ArchiveId::Core);
    ASSERT(file);
 
    // Copy construct onto the heap
    auto resAnmChr = Abstract::g3d::ResFile(file).resAnmChr("thunder_scale_up");
    s_thunderScaleUpAnmChr = new Abstract::g3d::ResAnmChr(resAnmChr);
    resAnmChr = Abstract::g3d::ResFile(file).resAnmChr("thunder_scale_down");
    s_thunderScaleDownAnmChr = new Abstract::g3d::ResAnmChr(resAnmChr);
    resAnmChr = Abstract::g3d::ResFile(file).resAnmChr("press_scale_up");
    s_pressScaleUpAnmChr = new Abstract::g3d::ResAnmChr(resAnmChr);
}
 
Abstract::g3d::ResAnmChr *KartObjectManager::s_thunderScaleUpAnmChr = nullptr;
Abstract::g3d::ResAnmChr *KartObjectManager::s_thunderScaleDownAnmChr = nullptr;
Abstract::g3d::ResAnmChr *KartObjectManager::s_pressScaleUpAnmChr = nullptr;
KartObjectManager *KartObjectManager::s_instance = nullptr;
 
} // namespace Kinoko::Kart