GravityUtil.cpp

#include "Game/Gravity.hpp"
#include "Game/Util/GravityUtil.hpp"
#include "Game/Util/JMapInfo.hpp"
#include "Game/Scene/SceneObjHolder.hpp"
#include "Game/LiveActor/LiveActor.hpp"
#include <cstring>
 
namespace {
    void getJMapInfoArgPlus(const JMapInfoIter &rIter, const char *pFieldName, f32 *pDest) {
 
    }
 
    void getJMapInfoArgPlus(const JMapInfoIter &rIter, const char *pFieldName, s32 *pDest) {
        // Get row and column of data
        s32 row = rIter._4;
        JMapInfo* pInfo = rIter.mInfo;
        s32 column = pInfo->searchItemInfo(pFieldName);
 
        // Try to read value
        s32 result;
        bool read = column < 0 ? false : pInfo->getValueFast(row, column, &result);
 
        // Set result if applicable
        if (read && result >= 0.0f) {
            *pDest = result;
        }
    }
 
    bool calcGravityVectorOrZero(const NameObj *pActor, const TVec3f &rPosition, u32 gravityType, TVec3f * pDest, GravityInfo *pInfo, u32 host) {
        if (!host) {
            host = (u32)pActor;
        }
 
        PlanetGravityManager* pManager
            = static_cast<PlanetGravityManager*>(MR::getSceneObjHolder()->getObj(SceneObj_PlanetGravityManager));
        return pManager->calcTotalGravityVector(pDest, pInfo, rPosition, gravityType, host);
    }
}
 
namespace MR {
    void registerGravity(PlanetGravity *pGravity) {
        PlanetGravityManager* pManager
            = static_cast<PlanetGravityManager*>(MR::getSceneObjHolder()->getObj(SceneObj_PlanetGravityManager));
        pManager->registerGravity(pGravity);
    }
 
    bool calcGravityVector(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityVector(const NameObj *pActor, const TVec3f &rPosition, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL;
        return ::calcGravityVectorOrZero(pActor, rPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcDropShadowVector(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_SHADOW;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcDropShadowVector(const NameObj *pActor, const TVec3f &rPosition, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_SHADOW;
        return ::calcGravityVectorOrZero(pActor, rPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityAndDropShadowVector(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL | GRAVITY_TYPE_SHADOW;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityAndMagnetVector(const NameObj *pActor, const TVec3f &rPosition, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL | GRAVITY_TYPE_MAGNET;
        return ::calcGravityVectorOrZero(pActor, rPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityVectorOrZero(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityVectorOrZero(const NameObj *pActor, const TVec3f &rPosition, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL;
        return ::calcGravityVectorOrZero(pActor, rPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcDropShadowVectorOrZero(const NameObj *pActor, const TVec3f &rPosition, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_SHADOW;
        return ::calcGravityVectorOrZero(pActor, rPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcGravityAndDropShadowVectorOrZero(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_NORMAL | GRAVITY_TYPE_SHADOW;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool calcAttractMarioLauncherOrZero(const LiveActor *pActor, TVec3f *pDest, GravityInfo *pInfo, u32 host) {
        u32 typeFlags = GRAVITY_TYPE_MARIO_LAUNCHER;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, typeFlags, pDest, pInfo, host);
    }
 
    bool isZeroGravity(const LiveActor *pActor) {
        TVec3f dummyGravity;
        return ::calcGravityVectorOrZero(pActor, pActor->mPosition, GRAVITY_TYPE_NORMAL, &dummyGravity, nullptr, 0) == false;
    }
 
    bool isLightGravity(const GravityInfo &rInfo) {
        PlanetGravity* pGravity = rInfo.mGravityInstance;
        return !pGravity ? false : pGravity->mGravityPower == GRAVITY_POWER_LIGHT;
    }
 
    void settingGravityParamFromJMap(PlanetGravity *pGravity, const JMapInfoIter &rIter) {
        // Get range, distant and priority
        f32 argRange = pGravity->mRange;
        ::getJMapInfoArgPlus(rIter, "Range", &argRange);
        f32 distant = pGravity->mDistant;
        pGravity->mRange = argRange;
        f32 argDistant = distant;
        ::getJMapInfoArgPlus(rIter, "Distant", &argDistant);
        s32 priority = pGravity->mPriority;
        pGravity->mDistant = argDistant;
        s32 argPriority = priority;
        ::getJMapInfoArgPlus(rIter, "Priority", &argPriority);
        pGravity->setPriority(argPriority);
 
        // Get gravity ID
        s32 gravityId = pGravity->mGravityId;
        ::getJMapInfoArgPlus(rIter, "Gravity_id", &gravityId);
        pGravity->mGravityId = gravityId;
 
        // Get gravity type and power
        getJMapInfoGravityType(rIter, pGravity);
        getJMapInfoGravityPower(rIter, pGravity);
 
        // Check if gravity is inverse
        s32 inverse = pGravity->mIsInverse != false;
        ::getJMapInfoArgPlus(rIter, "Inverse", &inverse);
        pGravity->mIsInverse = inverse;
    }
 
    void getJMapInfoGravityType(const JMapInfoIter &rIter, PlanetGravity *pGravity) {
        const char *pType = nullptr;
 
        if (rIter.getValue("Gravity_type", &pType)) {
            if (!strcmp(pType, "Normal")) {
                pGravity->mGravityType = GRAVITY_TYPE_NORMAL;
            }
            else if (!strcmp(pType, "Shadow")) {
                pGravity->mGravityType = GRAVITY_TYPE_SHADOW;
            }
            else if (!strcmp(pType, "Magnet")) {
                pGravity->mGravityType = GRAVITY_TYPE_MAGNET;
            }
        }
    }
 
    void getJMapInfoGravityPower(const JMapInfoIter &rIter, PlanetGravity *pGravity) {
        const char *pPower = nullptr;
 
        if (rIter.getValue("Power", &pPower)) {
            if (!strcmp(pPower, "Light")) {
                pGravity->mGravityPower = GRAVITY_POWER_LIGHT;
            }
            else if (!strcmp(pPower, "Normal")) {
                pGravity->mGravityPower = GRAVITY_POWER_NORMAL;
            }
            else if (!strcmp(pPower, "Heavy")) {
                pGravity->mGravityPower = GRAVITY_POWER_HEAVY;
            }
        }
    }
}