Petari/source/Game/MapObj/MapPartsFloatingForce.cpp

#include "Game/MapObj/MapPartsFloatingForce.hpp"
#include "Game/MapObj/FloaterFunction.hpp"
#include "Game/LiveActor/LiveActor.hpp"
#include "Game/Util.hpp"

SpringStep::SpringStep(f32 cond, f32 speed, f32 angle) {
    mSpringValue = 0;
    mCondition = cond;
    mSpeed = speed;
    mAngle = angle;
    mSpringValue = new SpringValue(cond, 0.0f, speed, angle, 0.0f);
}

void SpringStep::addSpringVelocity(f32 vel) {
    mSpringValue->_10 += vel;
}

void SpringStep::setSpringBaseValue(f32 val) {
    mCondition = val;
    mSpringValue->setParam((f64)val, 0.0f, mSpeed, mAngle, 0.0f);
}

MapPartsFloatingForce::MapPartsFloatingForce(LiveActor *pActor) : MapPartsFunction(pActor, "浮力") {
    mSpringStep = 0;
    mObjectName = 0;
    _20 = 0.0f;
    mRotateAngle = 0.0f;
    mRotateSpeed = 0.0f;
    mRotateAccelType = 0;
    _30.setZero();
    _3C = 0.0f;
    _40 = 1.0f;
    _44 = 0.0f;
    _48 = 0.0f;
    _5C = 0.0f;
}

void MapPartsFloatingForce::init(const JMapInfoIter &rIter) {
    initNerve(&NrvMapPartsFloatingForce::HostTypeWait::sInstance);
    MR::getMapPartsArgRotateAccelType(&mRotateAccelType, rIter);

    if (mRotateAccelType != 1) {
        initForNormalMotion(rIter);
    }
    else {
        initForSpringMotion(rIter);
    }

    MR::useStageSwitchReadA(mHost, rIter);
}

void MapPartsFloatingForce::setObjectName(const char *pName) {
    mObjectName = pName;
}

void MapPartsFloatingForce::initForNormalMotion(const JMapInfoIter &rIter) {
    s32 condition_type = 0;
    MR::getMapPartsArgMoveConditionType(&condition_type, rIter);
    _20 = condition_type;
    MR::getMapPartsArgRotateSpeed(&mRotateSpeed, rIter);
    MR::getMapPartsArgRotateAngle(&mRotateAngle, rIter);
}

void MapPartsFloatingForce::initForSpringMotion(const JMapInfoIter &rIter) {
    s32 condition_type = 0;
    MR::getMapPartsArgMoveConditionType(&condition_type, rIter);
    _20 = condition_type;
    f32 rotate_speed = 0.0f;
    MR::getMapPartsArgRotateSpeed(&rotate_speed, rIter);
    rotate_speed *= 0.001f;
    f32 rotate_angle = 0.0f;
    MR::getMapPartsArgRotateAngle(&rotate_angle, rIter);
    rotate_angle *= 0.001f;
    s32 rotate_axis = 0;
    MR::getMapPartsArgRotateAxis(&rotate_axis, rIter);
    _5C = 0.1f * rotate_axis;
    mSpringStep = new SpringStep(-condition_type, rotate_speed, rotate_angle);
}

void MapPartsFloatingForce::updateVelocity() {
    if (MR::isOnPlayer(MR::getBodySensor(mHost))) {
        if (_20 <= _48) {
            _4C = MR::converge<f32>(_4C, 0.0f, 0.050000001f);
        }
        else {
            _4C = _4C + (0.000099999997f * mRotateSpeed);
        }
    }
    else {
        if (_48 <= 0.0f) {
            _4C = MR::converge<f32>(_4C, 0.0f, 0.050000001f);
        }
        else {
            _4C = _4C - (0.000099999997f * mRotateAngle);
        }
    }

    _4C *= 0.98000002f;
    _4C = MR::clamp(_4C, -50.0f, 50.0f);
}

// void MapPartsFloatingForce::updateVelocitySpring()

bool MapPartsFloatingForce::tryOn() {
    bool isSwitchOn = false;

    if (MR::isValidSwitchA(mHost) && MR::isOnSwitchA(mHost)) {
        isSwitchOn = true;
    }

    if (isSwitchOn) {
        return false;
    }

    if (MR::isOnPlayer(MR::getBodySensor(mHost))) {
        const char* ground_sound = FloaterFunction::getSeGroundOn(mObjectName);
        if (ground_sound) {
            MR::startSound(mHost, ground_sound, -1, -1);
        }

        setNerve(&NrvMapPartsFloatingForce::HostTypeMoveSpring::sInstance);
        return true;
    }

    return false;
}

bool MapPartsFloatingForce::tryReturn() {
    bool isSwitchOn = false;

    if (MR::isValidSwitchA(mHost) && MR::isOnSwitchA(mHost)) {
        isSwitchOn = true;
    }

    if (!isSwitchOn) {
        if (MR::isOnPlayer(MR::getBodySensor(mHost))) {
            return false;
        }
    }

    setNerve(&NrvMapPartsFloatingForce::HostTypeMoveReturn::sInstance);
    return true;
}

void MapPartsFloatingForce::exeWait() {
    if (isFirstStep()) {
        _48 = 0.0f;
    }

    if (mRotateAccelType == 1) {
        tryOn();
    }
}

// MapPartsFloatingForce::exeMove

void MapPartsFloatingForce::exeMoveSpring() {
    if (isFirstStep()) {
        mSpringStep->setSpringBaseValue(-_20);
        mSpringStep->addSpringVelocity(-_5C);
    }

    updateVelocitySpring();
    mHost->mVelocity.set(_50);
    tryReturn();
}

// MapPartsFloatingForce::exeMoveReturn

MapPartsFloatingForce::~MapPartsFloatingForce() {

}

namespace NrvMapPartsFloatingForce {
    INIT_NERVE(HostTypeWait);
    INIT_NERVE(HostTypeMove);
    INIT_NERVE(HostTypeMoveSpring);
    INIT_NERVE(HostTypeMoveReturn);

    void HostTypeMoveReturn::execute(Spine *pSpine) const {
        MapPartsFloatingForce* force = reinterpret_cast<MapPartsFloatingForce*>(pSpine->mExecutor);
        force->exeMoveReturn();
    }

    void HostTypeMoveSpring::execute(Spine *pSpine) const {
        MapPartsFloatingForce* force = reinterpret_cast<MapPartsFloatingForce*>(pSpine->mExecutor);
        force->exeMoveSpring();
    }

    void HostTypeMove::execute(Spine *pSpine) const {
        MapPartsFloatingForce* force = reinterpret_cast<MapPartsFloatingForce*>(pSpine->mExecutor);
        force->exeMove();
    }

    void HostTypeWait::execute(Spine *pSpine) const {
        MapPartsFloatingForce* force = reinterpret_cast<MapPartsFloatingForce*>(pSpine->mExecutor);
        force->exeWait();
    }
};