ItemBlock.cpp

#include "Game/MapObj/ItemBlock.hpp"
#include "Game/Util.hpp"
#include "JSystem/JGeometry/TVec.hpp"
 
namespace NrvItemBlock {
    INIT_NERVE(ItemBlockNrvStandby);
    INIT_NERVE(ItemBlockNrvWait);
    INIT_NERVE(ItemBlockNrvAppearItem);
    INIT_NERVE(ItemBlockNrvAppearItemSplash);
 
    void ItemBlockNrvAppearItemSplash::execute(Spine *pSpine) const {
        ItemBlock *block = reinterpret_cast<ItemBlock *>(pSpine->mExecutor);
        block->exeAppearItemSplash();
    }
 
    void ItemBlockNrvAppearItem::execute(Spine *pSpine) const {
        ItemBlock *block = reinterpret_cast<ItemBlock *>(pSpine->mExecutor);
        block->exeAppearItem();
    }
 
    void ItemBlockNrvWait::execute(Spine *pSpine) const {
        ItemBlock *block = reinterpret_cast<ItemBlock *>(pSpine->mExecutor);
        block->exeWait();
    }
 
    void ItemBlockNrvStandby::execute(Spine *pSpine) const {
        ItemBlock *block = reinterpret_cast<ItemBlock *>(pSpine->mExecutor);
        if (MR::isFirstStep(block)) {
            MR::startBck(block, "Wait", nullptr);
        }
    }
};
 
namespace {
    static Color8 hPointLight(0xFF, 0xE6, 0, 0xFF);
};
 
ItemBlock::ItemBlock(const char *pName) : LiveActor(pName) {
    mKind = 0;
    mTimer = 0;
    mItemCount = 8;
    _98 = 0;
    mCalcShadowOneTime = false;
}
 
void ItemBlock::init(const JMapInfoIter &rIter) {
    MR::initDefaultPos(this, rIter);
    checkKind(rIter);
    initBlock();
    MR::connectToSceneMapObjStrongLight(this);
    MR::useStageSwitchSleep(this, rIter);
    initEffectKeeper(1, "CoinBlock", false);
    initSound(4, false);
    initNerve(&NrvItemBlock::ItemBlockNrvStandby::sInstance);
    s32 arg = -1;
    MR::getJMapInfoArg4NoInit(rIter, &arg);
    MR::initShadowVolumeBox(this, TVec3f(150.0f, 150.0f, 150.0f));
    MR::setShadowVolumeStartDropOffset(this, 0, 77.0f);
 
    if (arg != -1) {
        MR::setShadowDropLength(this, nullptr, arg);
    }
 
    MR::onShadowVolumeCutDropLength(this, nullptr);
    MR::excludeCalcShadowToMyCollision(this, nullptr);
 
    if (mCalcShadowOneTime) {
        MR::onCalcShadowOneTime(this, nullptr);
    } else {
        MR::onCalcShadow(this, nullptr);
    }
 
    if (MR::isZeroGravity(this)) {
        TVec3f upVec;
        MR::calcUpVec(&upVec, this);
        MR::setShadowDropDirection(this, 0, -upVec);
    } else {
        MR::calcGravity(this);
    }
 
    MR::offCalcGravity(this);
    MR::setGroupClipping(this, rIter, 16);
    MR::validateClipping(this);
 
    appear();
}
 
void ItemBlock::startClipped() {
    LiveActor::startClipped();
    MR::forceDeleteEffect(this, "Glow");
}
 
void ItemBlock::endClipped() {
    LiveActor::endClipped();
    MR::emitEffect(this, "Glow");
}
 
void ItemBlock::checkKind(const JMapInfoIter &rIter) {
    const char *name = nullptr;
    MR::getObjectName(&name, rIter);
 
    if (MR::isEqualString(name, "ItemBlockSwitch")) {
        MR::needStageSwitchWriteDead(this, rIter);
        mKind = 5;
    } else if (MR::isEqualString(name, "TimerCoinBlock")) {
        mKind = 1;
        MR::declareCoin(this, 10);
    } else if (MR::isEqualString(name, "SplashCoinBlock")) {
        mKind = 2;
        MR::declareCoin(this, mItemCount);
    } else if (MR::isEqualString(name, "TimerPieceBlock")) {
        mKind = 3;
        MR::declareStarPiece(this, 20);
    } else if (MR::isEqualString(name, "SplashPieceBlock")) {
        mKind = 4;
        MR::declareStarPiece(this, mItemCount);
    }
 
    s32 arg = -1;
 
    if (mKind == 2 || mKind == 4) {
        arg = -1;
        MR::getJMapInfoArg0NoInit(rIter, &arg);
 
        if (arg >= 0) {
            mItemCount = arg;
        } else {
            mItemCount = 8;
        }
    }
 
    if (mKind == 1 || mKind == 3) {
        MR::getJMapInfoArg1NoInit(rIter, &arg);
 
        if (arg == -1) {
            mTimer = 240;
        } else {
            mTimer = arg;
        }
    }
 
    arg = -1;
    MR::getJMapInfoArg2NoInit(rIter, &arg);
    mCalcShadowOneTime = !(arg - 1);
}
 
/*void ItemBlock::initBlock() {
    initHitSensor(1);
 
    if (mKind >= 6 || mKind < 1) {
        return;
    }
 
    initModelManagerWithAnm("CoinBlock", nullptr, false);
    TVec3f *mtx = new TVec3f(0.0f, 100.0f, 0.0f);
    MR::addHitSensorMtxMapObj(this, "body", 8, 100.0f, MR::getJointMtx(this, "CoinBlock"), *mtx);
    MR::initCollisionPartsAutoEqualScale(this, "CoinBlock", getSensor("body"), (MtxPtr)mtx);
}*/
 
void ItemBlock::appear() {
    LiveActor::appear();
    initNerve(&NrvItemBlock::ItemBlockNrvStandby::sInstance);
 
    if (mKind > 6 || mKind < 1) {
        return;
    }
 
    MR::startBrk(this, "CoinBlock");
}
 
void ItemBlock::kill() {
    MR::startSound(this, "SE_EM_EXPLODE_S", -1, -1);
    MR::emitEffect(this, "Break");
    LiveActor::kill();
}
 
/*void ItemBlock::control() {
    TVec3f upVec;
    MR::calcUpVec(&upVec, this);
    MR::requestPointLight(this, TVec3f(upVec * 100.0f), hPointLight, 0.998646f, -1);
}*/
 
bool ItemBlock::receiveMsgPlayerAttack(u32 msg, HitSensor *a1, HitSensor *a2) {
    if (MR::isMsgPlayerUpperPunch(msg) && MR::isPlayerExistDown(this, 0.0f, 0.25f) && tryStartJumpPunch()) {
        MR::sendArbitraryMsg(64, a1, a2);
        return true;
    }
 
    return false;
}
 
bool ItemBlock::tryStartJumpPunch() {
    if (isNerve(&NrvItemBlock::ItemBlockNrvStandby::sInstance)) {
        if (mKind == 1 || mKind == 3) {
            MR::startBck(this, "Appear", nullptr);
            calcAnim();
            mNoCalcAnim = true;
            setNerve(&NrvItemBlock::ItemBlockNrvAppearItem::sInstance);
        } else if (mKind == 2 || (u32)(mKind - 4) <= 1) {
            setNerve(&NrvItemBlock::ItemBlockNrvAppearItemSplash::sInstance);
        }
 
        return true;
    }
 
    if (isNerve(&NrvItemBlock::ItemBlockNrvWait::sInstance)) {
        if (mKind == 1 || mKind == 3) {
            if (mKind == 1) {
                if (MR::getDeclareRemnantCoinCount(this) == 1) {
                    mTimer = 0;
                }
            } else {
                if (!(MR::getDeclareRemnantStarPieceCountNotExist(this) - 11)) {
                    mTimer = 0;
                }
            }
 
            MR::startBck(this, "Appear", nullptr);
            calcAnim();
            mNoCalcAnim = true;
            setNerve(&NrvItemBlock::ItemBlockNrvAppearItem::sInstance);
 
            return true;
        }
    }
 
    return false;
}
 
void ItemBlock::exeWait() {
    if (MR::isFirstStep(this)) {
        MR::startBck(this, "Wait", nullptr);
        MR::invalidateClipping(this);
    }
 
    decTimer();
}
 
/*void ItemBlock::exeAppearItem() {
    if (MR::isFirstStep(this)) {
        if (!mTimer) {
            MR::forceDeleteEffect(this, "Glow");
            MR::startBck(this, "Bomb", nullptr);
        }
 
        MR::invalidateClipping(this);
    }
 
    if (MR::isStep(this, 1)) {
        TVec3f gravVec;
        TVec3f position(mPosition);
        MR::calcGravityVector(this, &gravVec, nullptr, 0);
 
        position.subInline(mPosition, gravVec * 100.0f);
 
        if (mKind == 2) {
            MR::startSystemSE("SE_SY_ITEM_APPEAR", -1, -1);
        }
 
        if (mKind >= 1) {
            MR::hopCoin(this, position, -gravVec);
        }
 
        if (mKind >= 4) {
        } else {
            if (mTimer || MR::getDeclareRemnantStarPieceCountNotExist(this) != 11) {
                MR::appearStarPieceToDirection(this, position, -gravVec, 11, 10.0f, 40.0f, false);
            } else {
                MR::hopStarPiece(this, position, -gravVec);
            }
 
            MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1);
        }
    }
 
    decTimer();
 
    if (!MR::isBckStopped(this)) {
        return;
    }
 
    if (mTimer) {
        setNerve(&NrvItemBlock::ItemBlockNrvWait::sInstance);
    } else {
        kill();
    }
}*/
 
void ItemBlock::exeAppearItemSplash() {
    if (MR::isFirstStep(this)) {
        MR::forceDeleteEffect(this, "Glow");
        MR::startBck(this, "Bomb", nullptr);
    }
 
    if (!MR::isBckStopped(this)) {
        return;
    }
 
    if (mKind == 2) {
        if (mItemCount == 1) {
            MR::appearCoinPop(this, mPosition, 1);
        } else {
            MR::appearCoinCircle(this, mPosition, mItemCount);
        }
    } else if (mKind == 4) {
        MR::appearStarPiece(this, mPosition, mItemCount, 10.0f, 40.0f, false);
        MR::startSound(this, "SE_OJ_STAR_PIECE_BURST", -1, -1);
    } else if (mKind == 5) {
        MR::onSwitchDead(this);
    }
 
    mTimer = 0;
    kill();
}
 
void ItemBlock::decTimer() {
    --mTimer;
    if (mTimer > 0) {
        return;
    }
    mTimer = 0;
}
 
void ItemBlock::calcAnim() {
    if (!mNoCalcAnim) {
        LiveActor::calcAnim();
    }
    mNoCalcAnim = false;
}
 
ItemBlock::~ItemBlock() {
 
}