Implement LazyTraverseList

1 files changed, 112 insertions, 0 deletions

diff --git a/src/KingSystem/Map/mapLazyTraverseList.cpp b/src/KingSystem/Map/mapLazyTraverseList.cpp
new file mode 100644
index 00000000..a87d2b94
--- /dev/null
+++ b/src/KingSystem/Map/mapLazyTraverseList.cpp
@@ -0,0 +1,112 @@
+#include "KingSystem/Map/mapLazyTraverseList.h"
+
+#include "Game/DLC/aocManager.h"
+#include "KingSystem/GameData/gdtManager.h"
+
+namespace ksys::map {
+
+LazyTraverseList::LazyTraverseList(sead::Heap* heap) {
+    ksys::res::Handle handle;
+    sead::SafeString path = "Map/MainField/LazyTraverseList.mubin";
+    ksys::res::LoadRequest request;
+
+    if (uking::aoc::Manager::instance())
+        uking::aoc::Manager::instance()->getFileDeviceForMap(&request.mAocFileDevice,
+                                                             &request.mPackHandle, path);
+
+    handle.load(path, &request);
+
+    if (handle.checkLoadStatus()) {
+        mHasEntries = false;
+    } else {
+        auto* direct_res = sead::DynamicCast<sead::DirectResource>(handle.getResource());
+        if (!direct_res) {
+            mHasEntries = false;
+        } else {
+            auto* entryIter = new (heap) al::ByamlIter(direct_res->getRawData());
+            if (entryIter && entryIter->getSize() >= 1) {
+                mHasEntries = true;
+
+                mEntries.allocBufferAssert(entryIter->getSize(), heap);
+
+                int objectCount = 0;
+                for (int entryIdx = 0; entryIdx < entryIter->getSize(); ++entryIdx) {
+                    const char* key;
+                    entryIter->getKeyName(&key, entryIdx);
+
+                    mEntries[entryIdx].flag_name = key;
+                    mEntries[entryIdx].flag_value = 0;
+
+                    al::ByamlIter objectIter;
+                    if (entryIter->tryGetIterByIndex(&objectIter, entryIdx)) {
+                        objectCount += objectIter.getSize();
+                    }
+                }
+
+                mObjects.allocBufferAssert(objectCount, heap);
+
+                for (int object = 0, entryIdx = 0; entryIdx < entryIter->getSize(); ++entryIdx) {
+                    al::ByamlIter objectIter;
+                    const char* entryName;
+                    entryIter->getKeyName(&entryName, entryIdx);  // debug log?
+
+                    if (!entryIter->tryGetIterByIndex(&objectIter, entryIdx))
+                        continue;
+
+                    for (int objectIdx = 0; objectIdx < objectIter.getSize(); ++objectIdx) {
+                        al::ByamlIter kvIter;
+                        if (!objectIter.tryGetIterByIndex(&kvIter, objectIdx))
+                            continue;
+
+                        const char* configName;
+                        kvIter.tryGetStringByKey(&configName, "UnitConfigName");  // debug log?
+
+                        kvIter.tryGetUIntByKey(&mObjects[object].hash_id, "HashId");
+                        mObjects[object].entry_idx = entryIdx;
+                        ++object;
+                    }
+                }
+            } else {
+                mHasEntries = false;
+            }
+
+            if (entryIter) {
+                heap->free(entryIter);
+            }
+        }
+    }
+
+    handle.requestUnload();
+}
+
+LazyTraverseList::~LazyTraverseList() {
+    mEntries.freeBuffer();
+    mObjects.freeBuffer();
+    mHasEntries = false;
+}
+
+void LazyTraverseList::updateFlags() {
+    for (int i = 0; i < u8(mEntries.size()); ++i) {
+        ksys::gdt::Manager::instance()->getParamBypassPerm().get().getBool(&mEntries[i].flag_value,
+                                                                           mEntries[i].flag_name);
+    }
+}
+
+bool LazyTraverseList::wereFlagsUpdated() {
+    auto* mgr = ksys::gdt::Manager::instance();
+
+    bool updated = false;
+    for (int i = 0; i < mEntries.size(); ++i) {
+        if (mgr->wasFlagNotCopied(mEntries[i].flag_name)) {
+            updated = true;
+            mEntries[i].flag_value = false;
+        } else if (mgr->wasFlagCopied(mEntries[i].flag_name)) {
+            updated = true;
+            mEntries[i].flag_value = true;
+        }
+    }
+
+    return updated;
+}
+
+}  // namespace ksys::map