RailMoveObj.cpp

#include "Game/MapObj/RailMoveObj.hpp"
#include "Game/MapObj/MapPartsRailMover.hpp"
#include "Game/MapObj/MapPartsRailRotator.hpp"
#include "Game/MapObj/StageEffectDataTable.hpp"
 
RailMoveObj::RailMoveObj(const char *pName) : MapObjActor(pName) {
    _C4.setZero();
    _D0 = 0;
}
 
void RailMoveObj::init(const JMapInfoIter &rIter) {
    MapObjActor::init(rIter);
    MapObjActorInitInfo info;
    info.setupHioNode("地形オブジェ");
    info.setupDefaultPos();
    info.setupConnectToScene();
    info.setupEffect(0);
    info.setupSound(0x6);
    info.setupSoundPos(getSoundCalcPos());
    info.setupGroupClipping(0x20);
    info.setupSeAppear();
    info.setupRailMover();
    info.setupRailPosture();
    info.setupShadow(0);
    info.setupBaseMtxFollowTarget();
    info.setupNerve(&NrvRailMoveObj::HostTypeMove::sInstance);
    MapObjActorUtil::setupInitInfoTypical(&info, mObjectName);
    setupInitInfo(rIter, &info);
    initialize(rIter, info);
 
    if (MR::isConnectedWithRail(rIter)) {
        f32 radius = 0.0f;
        MR::calcModelBoundingRadius(&radius, this);
        MR::initAndSetRailClipping(&_C4, this, 100.0f, radius);
    }
    else {
        setNerve(&NrvRailMoveObj::HostTypeDone::sInstance);
    }
 
    s32 condition_type = 0;
    MR::getMapPartsArgMoveConditionType(&condition_type, rIter);
 
    if (!MR::isMoveStartUnconditional(condition_type)) {
        setNerve(&NrvRailMoveObj::HostTypeWaitForPlayerOn::sInstance);
    }
 
    if (MR::isDemoCast(this, 0) && MR::tryRegisterDemoActionNerve(this, &NrvRailMoveObj::HostTypeMove::sInstance, 0)) {
        setNerve(&NrvRailMoveObj::HostTypeWait::sInstance);
    }
}
 
TVec3f* RailMoveObj::getSoundCalcPos() {
    return 0;
}
 
void RailMoveObj::startClipped() {
    MapObjActor::startClipped();
 
    if (mRailMover) {
        if (MR::StageEffect::isExistStageEffectData(mObjectName)) {
            MR::StageEffect::stopShakingCameraMoving(this, mObjectName);
        }
    }
}
 
void RailMoveObj::endClipped() {
    MapObjActor::endClipped();
 
    if (mRailMover) {
        if (MapObjActorUtil::isRailMoverWorking(this)) {
            if (!isNerve(&NrvRailMoveObj::HostTypeDone::sInstance)) {
                if (MR::StageEffect::isExistStageEffectData(mObjectName)) {
                    MR::StageEffect::shakeCameraMoving(this, mObjectName);
                }
            }
        }
    }
}
 
void RailMoveObj::initCaseUseSwitchB(const MapObjActorInitInfo &rInitInfo) {
    MapObjActor::initCaseUseSwitchB(rInitInfo);
    setNerve(&NrvRailMoveObj::HostTypeWait::sInstance);
}
 
void RailMoveObj::initCaseNoUseSwitchB(const MapObjActorInitInfo &) {
 
}
 
void RailMoveObj::startMoveInner() {
    MR::StageEffect::tryStageEffectStart(this, mObjectName);
 
    if (MR::isExistBck(this, cMoveBckName)) {
        MR::startBck(this, cMoveBckName, 0);
    }
 
    if (MR::StageEffect::isExistStageEffectData(mObjectName)) {
        MR::StageEffect::shakeCameraMoving(this, mObjectName);
    }
}
 
void RailMoveObj::move() {
    if (MapObjActorUtil::isRailMoverWorking(this)) {
        MR::StageEffect::tryStageEffectMoving(this, mObjectName);
    }
}
 
void RailMoveObj::doAtEndPoint() {
    MR::StageEffect::tryStageEffectStop(this, mObjectName);
 
    if (MR::isExistBck(this, cMoveBckName) && MR::isBckPlaying(this, cMoveBckName)) {
        MR::stopBck(this);
    }
 
    if (MR::StageEffect::isExistStageEffectData(mObjectName)) {
        MR::StageEffect::stopShakingCameraMoving(this, mObjectName);
    }
}
 
bool RailMoveObj::endMove() {
    doAtEndPoint();
    return true;
}
 
bool RailMoveObj::isMoving() const {
    return MapObjActorUtil::isRailMoverWorking(this);
}
 
bool RailMoveObj::receiveOtherMsg(u32 msg, HitSensor *, HitSensor *) {
    if (msg == 0xCF && isNerve(&NrvRailMoveObj::HostTypeMove::sInstance)) {
        kill();
        return true;
    }
 
    return false;
}
 
void RailMoveObj::exeWait() {
    if (!isNerve(&NrvRailMoveObj::HostTypeDone::sInstance) && (!MR::isDemoCast(this, 0) || !MR::isRegisteredDemoActionNerve(this)) && (!MR::isValidSwitchB(this) || MR::isOnSwitchB(this)) && (!isNerve(&NrvRailMoveObj::HostTypeWaitForPlayerOn::sInstance) || MR::isOnPlayer(this))) {
        tryStartMove();
    }
}
 
bool RailMoveObj::tryStartMove() {
    setNerve(&NrvRailMoveObj::HostTypeMove::sInstance);
    return true;
}
 
void RailMoveObj::exeMove() {
    if (MR::isFirstStep(this)) {
        startMapPartsFunctions();
    }
 
    if (!_D0 && MapObjActorUtil::isRailMoverWorking(this)) {
        startMoveInner();
    }
 
    _D0 = MapObjActorUtil::isRailMoverWorking(this);
    move();
 
    if (mRailMover->isReachedEnd()) {
        if (mRailMover->isDone() && endMove()) {
            setNerve(&NrvRailMoveObj::HostTypeDone::sInstance);
        }
        else {
            doAtEndPoint();
        }
    }
}
 
RailMoveObjPress::RailMoveObjPress(const char *pName) : RailMoveObj(pName) {
 
}
 
void RailMoveObjPress::init(const JMapInfoIter &rIter) {
    RailMoveObj::init(rIter);
    MR::setBodySensorType(this, 0x76);
}
 
RailMoveObjBreakAtEnd::RailMoveObjBreakAtEnd(const char *pName) : RailMoveObj(pName) {
 
}
 
void RailMoveObjBreakAtEnd::doAtEndPoint() {
    RailMoveObj::doAtEndPoint();
 
    if (MR::isRegisteredEffect(this, "Break")) {
        MR::emitEffect(this, "Break");
    }
 
    kill();
}
 
void RailMoveIndirectObj::connectToScene(const MapObjActorInitInfo &rInfo) {
    MR::connectToSceneIndirectMapObj(this);
}
 
void RailMoveObjSwitchShadow::init(const JMapInfoIter &rIter) {
    RailMoveObj::init(rIter);
    MR::invalidateShadow(this, 0);
}
 
void RailMoveObjSwitchShadow::initCaseUseSwitchA(const MapObjActorInitInfo &rInfo) {
    void (RailMoveObjSwitchShadow::*startFunc)(void) = &RailMoveObjSwitchShadow::startOnShadow;
    MR::listenStageSwitchOnA(this, MR::Functor(this, startFunc));
}
 
void RailMoveObjSwitchShadow::startOnShadow() {
    MR::validateShadow(this, 0);
}
 
RailDemoMoveObj::RailDemoMoveObj(const char *pName) : RailMoveObj(pName) {
    mDemoControl = 0;
}
 
void RailDemoMoveObj::init(const JMapInfoIter &rIter) {
    RailMoveObj::init(rIter);
    mDemoControl = new DemoCtrlBase(this, mObjectName);
    mDemoControl->init(rIter);
    makeActorAppeared();
}
 
bool RailDemoMoveObj::tryStartMove() {
    if (!mDemoControl->tryStart()) {
        return false;
    }
 
    setNerve(&NrvRailMoveObj::HostTypeMove::sInstance);
    return true;
}
 
void RailDemoMoveObj::startMoveInner() {
    const char* start_sound = MR::StageEffect::getStartSe(mObjectName);
 
    if (start_sound) {
        MR::startSound(this, start_sound, -1, -1);
    }
}
 
void RailDemoMoveObj::move() {
    mDemoControl->update();
 
    if (MapObjActorUtil::isRailMoverWorking(this)) {
        const char* moving_sound = MR::StageEffect::getMovingSe(mObjectName);
 
        if (moving_sound) {
            MR::startLevelSound(this, moving_sound, -1, -1, -1);
        }
    }
}
 
bool RailDemoMoveObj::endMove() {
    MR::validateClipping(this);
 
    if (!mDemoControl->isExistEndFrame()) {
        mDemoControl->end();
    }
 
    const char* stop_sound = MR::StageEffect::getStopSe(mObjectName);
    if (stop_sound) {
        MR::startSound(this, stop_sound, -1, -1);
    }
 
    return mDemoControl->isDone();
}
 
RailRotateMoveObj::RailRotateMoveObj(const char *pName) : RailMoveObj(pName) {
 
}
 
void RailRotateMoveObj::setupInitInfo(const JMapInfoIter &rIter, MapObjActorInitInfo *pInfo) {
    pInfo->setupRailRotator();
}
 
bool RailRotateMoveObj::receiveOtherMsg(u32 msg, HitSensor *a2, HitSensor *a3) {
    if (msg == 0xCB) {
        return tryStartRotateAtPoint();
    }
 
    if (msg == 0xCC) {
        mRailMover->endRotateAtPoint();
        return true;
    }
 
    if (msg == 0xCD) {
        return tryStartRotateBetweenPoints();
    }
 
    return RailMoveObj::receiveOtherMsg(msg, a2, a3);
}
 
void RailRotateMoveObj::initCaseUseSwitchB(const MapObjActorInitInfo &rInfo) {
    setNerve(&NrvRailMoveObj::HostTypeWait::sInstance);
    void (RailRotateMoveObj::*pauseFunc)(void) = &MapObjActor::pauseMapPartsFunctions;
    MR::listenStageSwitchOffB(this, MR::Functor(this, pauseFunc));
}
 
bool RailRotateMoveObj::tryStartRotateAtPoint() {
    s32 cur_point = MR::getCurrentRailPointNo(this);
    if (!mRailRotator->hasRotation(cur_point)) {
        return false;
    }
 
    if (mRailRotator->hasRotationBetweenPoints(cur_point)) {
        return false;
    }
 
    mRailRotator->rotateAtPoint(cur_point);
    return true;
}
 
bool RailRotateMoveObj::tryStartRotateBetweenPoints() {
    MapPartsRailRotator* rail_rotator = mRailRotator;
    s32 cur_point = MR::getCurrentRailPointNo(this);
 
    if (!rail_rotator->hasRotationBetweenPoints(cur_point)) {
        return false;
    }
 
    f32 next_time = 0.0f;
    mRailMover->calcTimeToNextRailPoint(&next_time);
    MapPartsRailRotator* uhm = mRailRotator;
    s32 new_point = MR::getCurrentRailPointNo(this);
    uhm->rotateBetweenPoints(new_point, next_time);
    return true;
}
 
namespace NrvRailMoveObj {
    INIT_NERVE(HostTypeWait);
    INIT_NERVE(HostTypeWaitForPlayerOn);
    INIT_NERVE(HostTypeMove);
    INIT_NERVE(HostTypeDone);
 
    void HostTypeDone::execute(Spine *pSpine) const {
        RailMoveObj* obj = reinterpret_cast<RailMoveObj*>(pSpine->mExecutor);
        obj->exeWait();
    }
 
    void HostTypeMove::execute(Spine *pSpine) const {
        RailMoveObj* obj = reinterpret_cast<RailMoveObj*>(pSpine->mExecutor);
        obj->exeMove();
    }
 
    void HostTypeWaitForPlayerOn::execute(Spine *pSpine) const {
        RailMoveObj* obj = reinterpret_cast<RailMoveObj*>(pSpine->mExecutor);
        obj->exeWait();
    }
 
    void HostTypeWait::execute(Spine *pSpine) const {
        RailMoveObj* obj = reinterpret_cast<RailMoveObj*>(pSpine->mExecutor);
        obj->exeWait();
    }
};
 
RailMoveObjPress::~RailMoveObjPress() {
 
}
 
RailMoveObjBreakAtEnd::~RailMoveObjBreakAtEnd() {
 
}
 
RailMoveIndirectObj::~RailMoveIndirectObj() {
 
}
 
RailMoveObjSwitchShadow::~RailMoveObjSwitchShadow() {
 
}
 
RailDemoMoveObj::~RailDemoMoveObj() {
 
}
 
RailRotateMoveObj::~RailRotateMoveObj() {
 
}