More PlacementMap functions

1 files changed, 230 insertions, 4 deletions

diff --git a/src/KingSystem/Map/mapPlacementMap.cpp b/src/KingSystem/Map/mapPlacementMap.cpp
index dbadb05f..8bc0988b 100644
--- a/src/KingSystem/Map/mapPlacementMap.cpp
+++ b/src/KingSystem/Map/mapPlacementMap.cpp
@@ -2,6 +2,9 @@
 #include "KingSystem/Map/mapPlacementMap.h"
 #include <prim/seadScopedLock.h>
 #include <thread/seadReadWriteLock.h>
+#include "Game/DLC/aocManager.h"
+#include "KingSystem/Map/mapObject.h"
+#include "KingSystem/Resource/resLoadRequest.h"
 
 namespace ksys::map {
 
@@ -37,17 +40,240 @@ PlacementMap::~PlacementMap() {
         r.cleanup();
     }
 }
+bool PlacementMap::parseStaticMap_(sead::Heap* heap, u8* data) {
+    if (!mMubinPath.isEmpty()) {
+        if (!mSkipLoadStaticMap) {
+            parseMap_(heap, data, 0, mIdx);
+        }
+        mStaticMapLoaded = true;
+        mStaticMapParsed = false;
+        return true;
+    }
+    mStaticMapLoaded = true;
+    return false;
+}
+
+int PlacementMap::getStaticCompoundIdFromPosition(const sead::Vector3f& pos) const {
+    if (mMgr->isShrineOrDivineBeast()) {
+        return 0;
+    }
+    float dx = (pos.x - (1000 * mCol - 5000));
+    float dz = (pos.z - (1000 * mRow - 4000));
+    return (2 * (dz > 500.0)) + (dx > 500.0);
+}
+
+bool PlacementMap::isDynamicLoaded(const sead::Vector3f& pos) {
+    int idx = getStaticCompoundIdFromPosition(pos);
+    return mRes[idx].mStatus == HkscRes::Status::_3;  // Likely InitStatus::DynamicLoaded
+}
+
+bool PlacementMap::x_6() {
+    if (mDynamicGroupIdx < 0) {
+        return true;
+    }
+    bool ret = true;
+    int num_objs = mPa->getNumObjs(mDynamicGroupIdx);
+
+    for (int i = 0; i < num_objs; i++) {
+        Object* obj = mPa->getObj(mDynamicGroupIdx, i);
+        obj->setFlags0(Object::Flag0::_4000);
+
+        const auto& flags = obj->getFlags0();
+        if (flags.isOn(Object::Flag0::_2) || flags.isOn(Object::Flag0::_4)) {
+            ret &= flags.isOn(Object::Flag0::_80);
+        }
+        if (flags.isOn(Object::Flag0::_10000) || flags.isOn(Object::Flag0::_80000000)) {
+            ret = false;
+        }
+    }
+
+    return ret;
+}
+
+bool PlacementMap::loadDynamicMap() {
+    if (mDynamicGroupIdx >= 0) {
+        return true;
+    }
+
+    sead::ReadWriteLock* lock = &mPa->mLock;
+    lock->writeLock();
+    mDynamicGroupIdx = mPa->allocGroupForDynamicMap(this);
+    lock->writeUnlock();
+
+    if (mDynamicGroupIdx < 0) {
+        return false;
+    }
+
+    res::LoadRequest arg;
+    arg.mRequester = "PlacementMap";
+    arg._22 = 1;
+
+    sead::FixedSafeString<128> path;
+
+    int path_len = mMubinPath.findIndex(".");
+    path.copy(mMubinPath, path_len);
+    if (act::ActorDebug::instance() &&
+        (act::ActorDebug::instance()->hasFlag(act::ActorDebug::Flag::_10000000))) {
+        path.append("_DynamicPast.mubin");
+    } else if (Patrol::instance() && Patrol::instance()->mLoadStaticPhysUnstableMapUnit) {
+        path.append("_Dynamic_PhysUnstable.mubin");
+    } else if (PlacementMgr::instance()->isGrudgeMerge() || mMgr->isShrineOrDivineBeast()) {
+        path.append("_Dynamic.mubin");
+    } else {
+        path.append("_Dynamic_NoGrudgeMerge.mubin");
+    }
+    if (uking::aoc::Manager::instance()) {
+        arg.mAocFileDevice = uking::aoc::Manager::instance()->getFileDeviceForMapFile(path);
+    }
+    return mDynamicMubinRes.requestLoad(path, &arg, 0);
+}
+
+// Objects: Static and Dynamic
+PlacementMap::MapObjStatus PlacementMap::x_2(int hksc_idx) {
+    res::Handle* handle = &mRes[hksc_idx].mRes;
+    if (!handle->isReadyOrNeedsParse()) {
+        return MapObjStatus::NotReady;
+    }
+    handle->parseResource(nullptr);
+    if (handle->checkLoadStatus()) {
+        return MapObjStatus::Ready;
+    }
+
+    auto* resource = handle->getResource();
+    auto* sc = sead::DynamicCast<phys::StaticCompound>(resource);
+
+    sc->sub_7100FCAD0C(mMat);
+    for (int i = mParsedNumStaticObjs; i <= mNumStaticObjs; i++) {
+        x_0(hksc_idx, mPa->getStaticObj_0(i));
+    }
+    const int gid = mDynamicGroupIdx;
+    if (gid >= 0) {
+        int n = mPa->getNumObjs(gid);
+        for (int i = 0; i < n; i++) {
+            x_0(hksc_idx, mPa->getObj(gid, i));
+        }
+    }
+    return MapObjStatus::Loading;
+}
+
+void PlacementMap::doDisableObjStaticCompound(Object* obj, bool disable) {
+    if ((s16)obj->getStaticCompoundId() < 0) {
+        return;
+    }
+    const auto lock = sead::makeScopedLock(mCs);
+
+    // Is Flag0::_200000 a flag to disable an object?
+    if (disable == obj->getFlags0().isOn(Object::Flag0::_200000)) {
+        return;
+    }
+    if (disable) {
+        obj->setFlags0(Object::Flag0::_200000);
+    } else {
+        obj->resetFlags0(Object::Flag0::_200000);
+    }
+
+    int idx = getStaticCompoundIdFromPosition(obj->getTranslate());
+    auto* resource = mRes[idx].mRes.getResource();
+    if (auto* sc = sead::DynamicCast<ksys::phys::StaticCompound>(resource)) {
+        s16 sc_id = obj->getStaticCompoundId();
+        sc->disableCollision(sc_id, disable);
+    }
+}
+
+// Should this be renamed to what x_3() and/or x_4() does
+int PlacementMap::doSomethingStaticCompound(int hksc_idx) {
+    auto* resource = mRes[hksc_idx].mRes.getResource();
+    if (auto* sc = sead::DynamicCast<phys::StaticCompound>(resource)) {
+        if (!sc->calledFromMapDtor() && !sc->x_3()) {
+            sc->x_4();
+        }
+    }
+    return 1;
+}
+bool PlacementMap::loadStaticCompound(int hksc_idx, bool auto_gen_mu, bool req_arg_8) {
+    sead::FixedSafeString<0x100> path;
+    res::LoadRequest arg;
+
+    arg.mRequester = "PlacementMgr";
+    arg._8 = req_arg_8;
+    arg._22 = 1;
+
+    const auto lock = sead::makeScopedLock(mCs);
+
+    if (auto_gen_mu) {
+        path.format("Physics/StaticCompoundForAutoGenMU/%s-%d.hksc", mFolderAndFile.cstr(),
+                    hksc_idx);
+    } else {
+        if (mMgr->isShrineOrDivineBeast()) {
+            path.format("Physics/StaticCompound/%d.hksc", mFolderAndFile.cstr());
+        } else {
+            path.format("Physics/StaticCompound/%s-%d.hksc", mFolderAndFile.cstr(), hksc_idx);
+        }
+    }
+    if (uking::aoc::Manager::instance()) {
+        arg.mAocFileDevice = uking::aoc::Manager::instance()->getFileDeviceForStaticCompound(path);
+    }
+
+    return mRes[hksc_idx].mRes.requestLoad(path, &arg, 0);
+}
+
+// Should this be cleanupStaticCompound, unloadStaticCompound
+void PlacementMap::cleanupPhysics() {
+    const auto lock = sead::makeScopedLock(mCs);
+
+    for (int i = 0; i < 4; i++) {
+        auto resource = mRes[i].mRes.getResource();
+        if (auto* sc = sead::DynamicCast<phys::StaticCompound>(resource)) {
+            sc->cleanUp();
+        }
+        mRes[i].mRes.requestUnload2();
+        mRes[i].mStatus = HkscRes::Status::_0;
+    }
+    mInitStatus = InitStatus::StaticLoaded;
+}
+
+PlacementMap::MapObjStatus PlacementMap::parseDynamicMap() {
+    if (!mDynamicMubinRes.isReadyOrNeedsParse()) {
+        return MapObjStatus::NotReady;
+    }
+    mDynamicMubinRes.parseResource(nullptr);
+    if (mDynamicMubinRes.checkLoadStatus()) {
+        sead::ReadWriteLock* lock = &mPa->mLock;
+        lock->writeLock();
+        mPa->resetGroup(mDynamicGroupIdx);
+        mDynamicGroupIdx = 0xFFFFFFFF;
+        lock->writeUnlock();
+        return MapObjStatus::Ready;
+    }
+    auto* r = mDynamicMubinRes.getResource();
+    auto* resource = sead::DynamicCast<sead::DirectResource>(r);
 
-void PlacementMap::unload() {
     sead::ReadWriteLock* lock = &mPa->mLock;
     lock->writeLock();
+    parseMap_(0, resource->getRawData(), mDynamicGroupIdx, mIdx);
+    lock->writeUnlock();
+    return MapObjStatus::Loading;
+}
+
+bool PlacementMap::loadStaticMap_(bool load) {
+    if (!mMubinPath.isEmpty()) {
+        mStaticMapParsed = true;
+        if (!mSkipLoadStaticMap) {
+            doLoadStaticMap_(load);
+        }
+    }
+    return true;
+}
+
+void PlacementMap::unload() {
+    sead::ReadWriteLock* rw_lock = &mPa->mLock;
+    rw_lock->writeLock();
     mPa->resetGroup(mDynamicGroupIdx);
     mDynamicGroupIdx = 0xFFFFFFFF;
-    lock->writeUnlock();
+    rw_lock->writeUnlock();
 
-    mCs.lock();
+    const auto lock = sead::makeScopedLock(mCs);
     mDynamicMubinRes.requestUnload();
-    mCs.unlock();
 }
 
 phys::BodyGroup* PlacementMap::getFieldBodyGroup(int field_group_idx) {