Merge branch 'main' into pr/7

src/c/c_list.cpp

@@ -1,7 +1,7 @@
 #include <c/c_list.h>
 
-
-bool cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
+/* 0x802E08C0 */
+void cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     if (prevNode == nullptr) {
         return this->prepend(node);
     }
@@ -18,7 +18,8 @@ bool cListMg_c::insertAfter(cListNd_c *node, cListNd_c *prevNode) {
     }
 }
 
-bool cListMg_c::remove(cListNd_c *node) {
+/* 0x802E0900 */
+void cListMg_c::remove(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -46,7 +47,8 @@ bool cListMg_c::remove(cListNd_c *node) {
     }
 }
 
-bool cListMg_c::append(cListNd_c *node) {
+/* 0x802E09B0 */
+void cListMg_c::append(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }
@@ -59,7 +61,8 @@ bool cListMg_c::append(cListNd_c *node) {
     this->mpLast = node;
 }
 
-bool cListMg_c::prepend(cListNd_c *node) {
+/* 0x802E09E0 */
+void cListMg_c::prepend(cListNd_c *node) {
     if (node == nullptr) {
         return;
     }

src/c/c_tree.cpp

@@ -0,0 +1,121 @@
+#include <c/c_tree.h>
+
+/* 0x802E0E70 */
+cTreeNd_c::cTreeNd_c() {
+    this->forcedClear();
+}
+
+/* 0x802E0EA0 */
+void cTreeNd_c::forcedClear() {
+    this->mpParent = nullptr;
+    this->mpChild = nullptr;
+    this->mpPrev = nullptr;
+    this->mpNext = nullptr;
+}
+
+/* 0x802E0EC0 */
+bool cTreeMg_c::addTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
+    if (node != nullptr) {
+        if (parent != nullptr) {
+            node->mpParent = parent;
+            if (parent->mpChild == nullptr) {
+                parent->mpChild = node;
+            } else {
+                cTreeNd_c *cursor;
+                for (cursor = parent->mpChild; cursor->mpNext != nullptr; cursor = cursor->mpNext) {}
+                cursor->mpNext = node;
+                node->mpPrev = cursor;
+            }
+        } else {
+            cTreeNd_c *cursor = this->mpRootNode;
+            if (cursor != nullptr) {
+                for (; cursor->mpNext != nullptr; cursor = cursor->mpNext) {}
+                cursor->mpNext = node;
+                node->mpPrev = cursor;
+            } else {
+                this->mpRootNode = node;
+            }
+        }
+    } else {
+        return false;
+    }
+    return true;
+}
+
+/* 0x802E0F60*/
+bool cTreeMg_c::removeTreeNode(cTreeNd_c *node) {
+    if (node != nullptr) {
+        if (node->mpChild != nullptr) {
+            return false;
+        }
+        if (node->mpPrev != nullptr) {
+            node->mpPrev->mpNext = node->mpNext;
+        } else if (node->mpParent != nullptr) {
+            node->mpParent->mpChild = node->mpNext;
+        } else if (node == this->mpRootNode) {
+            this->mpRootNode = node->mpNext;
+        }
+
+        if (node->mpNext != nullptr) {
+            node->mpNext->mpPrev = node->mpPrev;
+        }
+
+        node->mpPrev = nullptr;
+        node->mpNext = nullptr;
+        node->mpParent = nullptr;
+    } else {
+        return false;
+    }
+    return true;
+}
+
+/* 0x802E1000 */
+bool cTreeMg_c::insertTreeNode(cTreeNd_c *node, cTreeNd_c *parent) {
+    cTreeNd_c *cursor;
+
+    for (cursor = parent; cursor != nullptr; cursor = cursor->mpParent) {
+        if (cursor == node) {
+            return false;
+        }
+    }
+
+    if (node != nullptr) {
+        cTreeNd_c *child = node->mpChild;
+        node->mpChild = nullptr;
+        if (!this->removeTreeNode(node)) {
+            node->mpChild = child;
+            return false;
+        } else {
+            node->mpChild = child;
+            return this->addTreeNode(node, parent);
+        }
+    }
+
+    return false;
+}
+
+/* 0x802E10C0 */
+cTreeNd_c *cTreeNd_c::getTreeNext() const {
+    cTreeNd_c *child = this->mpChild;
+    if (child != nullptr) {
+        return child;
+    } else {
+        return this->getTreeNextNotChild();
+    }
+}
+
+/* 0x802E1100 */
+cTreeNd_c *cTreeNd_c::getTreeNextNotChild() const {
+    if (this->mpNext != nullptr) {
+        return this->mpNext;
+    }
+
+    cTreeNd_c *parent;
+
+    for (parent = this->mpParent; parent != nullptr; parent = parent->mpParent) {
+        if (parent->mpNext != nullptr) {
+            return parent->mpNext;
+        }
+    }
+    return nullptr;
+}

src/egg/core/eggColorFader.cpp

@@ -0,0 +1,143 @@
+#include <egg/core/eggColorFader.h>
+#include <rvl/GX/GXHardware.h>
+#include <rvl/GX/GXTexture.h>
+
+
+/* 80497930 */
+EGG::ColorFader::ColorFader(float startX, float startY, float lengthX, float lengthY, nw4r::ut::Color color,
+        Fader::EStatus initialStatus)
+    : mStartX(startX), mStartY(startY), mEndX(startX + lengthX), mEndY(startY + lengthY), mFrame(0x14), mFadeTimer(0) {
+    setColor(color);
+    setStatus(initialStatus);
+    mFlags.setBit(1);
+}
+
+void EGG::ColorFader::setFrame(u16 frames) {
+    mFrame = frames;
+}
+
+void EGG::ColorFader::setColor(nw4r::ut::Color color) {
+    mColor.r = color.r;
+    mColor.g = color.g;
+    mColor.b = color.b;
+    // Don't set alpha
+}
+
+void EGG::ColorFader::setStatus(Fader::EStatus status) {
+    if (status == STATUS_PREPARE_IN) {
+        mStatus = STATUS_PREPARE_IN;
+        mColor.a = 255;
+    } else if (status == STATUS_PREPARE_OUT) {
+        mStatus = STATUS_PREPARE_OUT;
+        mColor.a = 0;
+    }
+}
+
+bool EGG::ColorFader::fadeIn() {
+    bool doFadeIn = mStatus == STATUS_PREPARE_IN;
+    if (doFadeIn) {
+        mStatus = STATUS_FADE_IN;
+        mFadeTimer = 0;
+    }
+
+    return doFadeIn;
+}
+
+bool EGG::ColorFader::fadeOut() {
+    bool doFadeOut = mStatus == STATUS_PREPARE_OUT;
+    if (doFadeOut) {
+        mStatus = STATUS_FADE_OUT;
+        mFadeTimer = 0;
+    }
+
+    return doFadeOut;
+}
+
+bool EGG::ColorFader::calc() {
+    bool result = false;
+
+    if (mStatus == STATUS_PREPARE_OUT) {
+        mColor.a = 0;
+    } else if (mStatus == STATUS_PREPARE_IN) {
+        mColor.a = 255;
+    } else if (mStatus == STATUS_FADE_IN) {
+        u16 endFrame = mFrame;
+        u16 currFrame = mFadeTimer++;
+        if (currFrame > endFrame) {
+            mStatus = STATUS_PREPARE_OUT;
+            result = mFlags.onBit(0);
+            currFrame = mFrame;
+        }
+        mColor.a = 255 - (currFrame * 255 / mFrame);
+    } else if (mStatus == STATUS_FADE_OUT) {
+        u16 endFrame = mFrame;
+        u16 currFrame = mFadeTimer++;
+        if (currFrame > endFrame) {
+            if (currFrame > endFrame + 1) {
+                mStatus = STATUS_PREPARE_IN;
+                result = mFlags.onBit(1);
+            }
+            endFrame = mFrame;
+            currFrame = endFrame;
+        }
+        mColor.a = currFrame * 255 / endFrame;
+    }
+
+    return result;
+}
+
+void EGG::ColorFader::draw() {
+    if (mColor.a == 0) {
+        return;
+    }
+
+    Mtx44 projMtx;
+    C_MTXOrtho(projMtx, mStartY, mEndY, mStartX, mEndX, 0.0f, 1.0f);
+    GXSetProjection(projMtx, GX_ORTHOGRAPHIC);
+
+    GXSetViewport(mStartX, mStartY, getWidth(), getHeight(), 0.0f, 1.0f);
+    GXSetScissor(mStartX, mStartY, getWidth(), getHeight());
+
+    Mtx posMtx;
+    PSMTXIdentity(posMtx);
+    GXLoadPosMtxImm(posMtx, 0);
+    GXSetCurrentMtx(0);
+
+    GXClearVtxDesc();
+    GXInvalidateVtxCache();
+
+    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
+    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
+
+    GXSetNumChans(1);
+    GXSetChanMatColor(GX_COLOR0A0, mColor);
+    GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
+
+    GXSetNumTexGens(0);
+    GXSetNumIndStages(0);
+    __GXSetIndirectMask(0);
+
+    GXSetNumTevStages(1);
+    GXSetTevOp(GX_TEVSTAGE0, 4);
+    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
+
+    if (mColor.a == 255) {
+        GXSetBlendMode(GX_BM_NONE, GX_BL_ONE, GX_BL_ZERO, GX_LO_SET);
+    } else {
+        GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
+    }
+
+    GXSetColorUpdate(1);
+    GXSetAlphaUpdate(1);
+    GXSetZMode(0, GX_NEVER, 0);
+    GXSetCullMode(GX_CULL_BACK);
+
+    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
+
+    GXPosition3f32(mStartX, mStartY, 0.0f);
+    GXPosition3f32(mEndX, mStartY, 0.0f);
+    GXPosition3f32(mEndX, mEndY, 0.0f);
+    GXPosition3f32(mStartX, mEndY, 0.0f);
+
+    // GXEnd();
+}

src/m/m_heap.cpp

@@ -1,16 +1,13 @@
 #include <egg/core/eggAssertHeap.h>
 #include <egg/core/eggExpHeap.h>
 #include <egg/core/eggFrmHeap.h>
+#include <m/m_heap.h>
 
 namespace mHeap {
 
 u8 g_DefaultGameHeapId = 1;
-static const char *s_GameHeapNames[4] = {
-        0,
-        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
-        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
-        0,
-};
+
+#define MIN_ALIGN 0x20
 
 EGG::ExpHeap *g_gameHeaps[4];
 EGG::ExpHeap *s_SavedCurrentHeap;
@@ -19,23 +16,166 @@ EGG::ExpHeap *g_commandHeap;
 EGG::ExpHeap *g_dylinkHeap;
 EGG::AssertHeap *g_assertHeap;
 
-u32 getHeapAttribute(u32) {}
+u16 copyAttribute(u32 arg) {
+    u16 result = 0;
+
+    if ((arg & 1) != 0) {
+        result = 1;
+    }
+    if ((arg & 2) != 0) {
+        result |= 2;
+    }
+    if ((arg & 4) != 0) {
+        result |= 4;
+    }
+    return result;
+}
 
 EGG::Heap *setCurrentHeap(EGG::Heap *heap) {
     return heap->becomeCurrentHeap();
 }
-EGG::ExpHeap *createExpHeap(size_t, EGG::Heap *parent, const char *name, unsigned long, unsigned long) {}
-void adjustExpHeap(EGG::ExpHeap *) {}
-size_t expHeapCost(unsigned long, unsigned long) {}
+EGG::ExpHeap *createExpHeap(size_t size, EGG::Heap *parent, const char *name, unsigned long align,
+        unsigned long attrs) {
+    if (parent == nullptr) {
+        parent = EGG::Heap::sCurrentHeap;
+    }
 
-EGG::FrmHeap *createFrmHeap(unsigned long, EGG::Heap *, const char *, unsigned long, unsigned long) {}
-void destroyFrmHeap(EGG::FrmHeap *) {}
-size_t adjustFrmHeap(EGG::FrmHeap *) {}
-size_t frmHeapCost(unsigned long, unsigned long) {}
+    if (align < MIN_ALIGN) {
+        align = MIN_ALIGN;
+    }
 
-EGG::ExpHeap *createHeap(unsigned long, EGG::Heap *, const char *) {}
-void saveCurrentHeap() {}
-void restoreCurrentHeap() {}
+    if (size != 0xFFFFFFFF) {
+        size = expHeapCost(size, align);
+    } else {
+        size = parent->getAllocatableSize(align);
+    }
+
+    void *mem = parent->alloc(size, align);
+    EGG::ExpHeap *heap = nullptr;
+    if (mem != nullptr) {
+        heap = EGG::ExpHeap::create(mem, size, copyAttribute(attrs));
+        if (heap == nullptr) {
+            parent->free(mem);
+        } else if (name != nullptr) {
+            heap->mName = name;
+        }
+    }
+    return heap;
+}
+
+size_t adjustExpHeap(EGG::ExpHeap *heap) {
+    int ret = 0;
+    if (heap != nullptr) {
+        size_t ad = heap->adjust();
+        size_t cost = mHeap::expHeapCost(0, 4);
+        if (ad >= cost) {
+            ret = ad - cost;
+        }
+    }
+    return ret;
+}
+size_t expHeapCost(size_t size, s32 align) {
+    int a = align - 1;
+    long b = (0x84 + a);
+    
+    return size + (~(a) & b);
+}
+
+EGG::FrmHeap *createFrmHeap(size_t size, EGG::Heap *parent, const char *name, size_t align, size_t attrs) {
+    if (parent == nullptr) {
+        parent = EGG::Heap::sCurrentHeap;
+    }
+
+    if (align < MIN_ALIGN) {
+        align = MIN_ALIGN;
+    }
+
+    if (size != 0xFFFFFFFF) {
+        size = frmHeapCost(size, align);
+    } else {
+        size = parent->getAllocatableSize(align);
+    }
+
+    void *mem = parent->alloc(size, align);
+    EGG::FrmHeap *heap = nullptr;
+    if (mem != nullptr) {
+        heap = EGG::FrmHeap::create(mem, size, copyAttribute(attrs));
+        if (heap == nullptr) {
+            parent->free(mem);
+        } else if (name != nullptr) {
+            heap->mName = name;
+        }
+    }
+    return heap;
+}
+void destroyFrmHeap(EGG::FrmHeap *heap) {
+    if (heap != nullptr) {
+        heap->destroy();
+    }
+}
+
+size_t adjustFrmHeap(EGG::FrmHeap *heap) {
+    int ret = 0;
+    if (heap != nullptr) {
+        size_t ad = heap->adjust();
+        size_t cost = mHeap::frmHeapCost(0, 4);
+        if (ad >= cost) {
+            ret = ad - cost;
+        }
+    }
+    return ret;
+}
+
+size_t frmHeapCost(size_t size, s32 align) {
+    int a = align - 1;
+    long b = (0x7C + a);
+    
+    return size + (~(a) & b);
+}
+
+EGG::Heap **setTempHeap(EGG::Heap **prevHeap, EGG::Heap *tempNewHeap) {
+    *prevHeap = tempNewHeap->becomeCurrentHeap();
+    return prevHeap;
+}
+EGG::Heap **restoreTempHeap(EGG::Heap **prevHeap, s32 size) {
+    if (prevHeap != nullptr) {
+        (*prevHeap)->becomeCurrentHeap();
+        if (size > 0) {
+            delete prevHeap;
+        }
+    }
+    return prevHeap;
+}
+
+EGG::ExpHeap *createHeap(size_t size, EGG::Heap *block, const char *name) {
+    EGG::ExpHeap *heap = EGG::ExpHeap::create(size, block, 4);
+    if (heap != nullptr) {
+        heap->setGroupID(0);
+        if (name != nullptr) {
+            heap->mName = name;
+        }
+    } else {
+        block->dump();
+    }
+
+    return heap;
+}
+void saveCurrentHeap() {
+    s_SavedCurrentHeap = (EGG::ExpHeap *)EGG::Heap::sCurrentHeap;
+}
+void restoreCurrentHeap() {
+    s_SavedCurrentHeap->becomeCurrentHeap();
+    s_SavedCurrentHeap = nullptr;
+}
+
+EGG::FrmHeap *makeFrmHeapAndUpdate(size_t size, EGG::Heap *parentHeap, const char *name, s32 align, u32 unk) {
+    EGG::FrmHeap *heap = createFrmHeap(size, parentHeap, name, align, unk);
+    if (heap != nullptr) {
+        EGG::Heap *heap2 = setCurrentHeap(heap);
+        s_SavedCurrentHeap = (EGG::ExpHeap *)heap2;
+    }
+    return heap;
+}
 
 int getDefaultGameHeapId() {
     return g_DefaultGameHeapId;
@@ -45,6 +185,13 @@ inline bool isValidHeapId(u32 id) {
     return id >= 1 && id <= 2;
 }
 
+const char *const s_GameHeapNames[4] = {
+        0,
+        "ゲーム用汎用ヒープ1(mHeap::gameHeaps[1])",
+        "ゲーム用汎用ヒープ2(mHeap::gameHeaps[2])",
+        0,
+};
+
 EGG::ExpHeap *createGameHeap(int heapId, size_t size, EGG::Heap *parent) {
     if (!isValidHeapId(heapId)) {
         return nullptr;
@@ -60,16 +207,26 @@ EGG::ExpHeap *createGameHeap1(size_t size, EGG::Heap *parent) {
     return createGameHeap(getDefaultGameHeapId(), size, parent);
 }
 EGG::ExpHeap *createArchiveHeap(size_t size, EGG::Heap *parent) {
-    g_archiveHeap = createHeap(size, parent, "");
+    g_archiveHeap = createHeap(size, parent, "汎用ファイル読み込み用ヒープ(mHeap::archiveHeap)");
+    return g_archiveHeap;
 }
 EGG::ExpHeap *createCommandHeap(size_t size, EGG::Heap *parent) {
     g_commandHeap = createHeap(size, parent, "DVD読み込みコマンド用ヒープ(mHeap::commandHeap)");
+    return g_commandHeap;
 }
 EGG::ExpHeap *createDylinkHeap(size_t size, EGG::Heap *parent) {
     g_dylinkHeap = createHeap(size, parent, "ダイナミックリンク用ヒープ(mHeap::dylinkHeap)");
+    return g_dylinkHeap;
 }
-EGG::ExpHeap *createAssertHeap(EGG::Heap *parent) {
+EGG::AssertHeap *createAssertHeap(EGG::Heap *parent) {
+    const char *name = "アサートヒープ(mHeap::assertHeap)";
     g_assertHeap = EGG::AssertHeap::create(EGG::AssertHeap::getSize(), parent);
-    g_assertHeap->mName = "アサートヒープ(mHeap::assertHeap)";
+    g_assertHeap->mName = name;
+    return g_assertHeap;
 }
+
+EGG::Heap *makeHeapOnCurrentGameHeap(size_t size, char *name, s32 align, u32 flags) {
+    return makeFrmHeapAndUpdate(size, g_gameHeaps[0], name, align, flags);
+}
+
 } // namespace mHeap

src/toBeSorted/misc_flag_managers.cpp

@@ -4,7 +4,6 @@
 #include <toBeSorted/file_manager.h>
 #include <toBeSorted/flag_space.h>
 
-
 class CommittableFlagManager {
 public:
     bool mNeedsCommit;
@@ -22,6 +21,7 @@ public:
     }
 };
 
+/* 0x800BE7B0 */
 bool CommittableFlagManager::commitIfNecessary() {
     if (mNeedsCommit) {
         doCommit();
@@ -33,22 +33,21 @@ bool CommittableFlagManager::commitIfNecessary() {
 }
 
 class TBoxFlagManager : public CommittableFlagManager {
-    // class TBoxFlagManager {
-    // bool mNeedsCommit;
-    // u32 pad;
+public:
     FlagSpace mFlagSpace;
     u16 mSceneIndex;
     BitwiseFlagHelper mFlagHelper;
 
-    static u16 *sFlags;
+    static u16 sTBoxFlags[2];
+
+    static TBoxFlagManager *sInstance;
 
-public:
     virtual void doCommit() override;
     bool checkUncommittedFlag(u16 flag);
     TBoxFlagManager();
     virtual ~TBoxFlagManager() {}
     void init();
-    void copyFromSave(u16 sceneIndex);
+    void copyFromSave(s16 sceneIndex);
     bool checkFlag(u16 sceneIndex, u16 flag);
     virtual u16 getFlagCount() const;
     void setFlag(u16 flag);
@@ -58,39 +57,50 @@ public:
     }
 };
 
+TBoxFlagManager *TBoxFlagManager::sInstance = nullptr;
+u16 TBoxFlagManager::sTBoxFlags[2] = {};
+
+/* 0x800BE810 */
 void TBoxFlagManager::doCommit() {
     if (mSceneIndex != 0xFFFF) {
         FileManager::getInstance()->setTBoxFlags(mFlagSpace.getFlagPtrUnchecked(), mSceneIndex * 2, 2);
     }
 }
 
+/* 0x800BE870 */
 bool TBoxFlagManager::checkUncommittedFlag(u16 flag) {
     return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
 }
 
-TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 2) {
+/* 0x800BE8E0 */
+TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
     mSceneIndex = 0xFFFF;
 }
 
+/* 0x800BE920 */
 void TBoxFlagManager::init() {}
 
-void TBoxFlagManager::copyFromSave(u16 sceneIndex) {
-    // mr should be a clrlwi
-    mSceneIndex = sceneIndex;
+/* 0x800BE930 */
+void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
+    u16 idx = sceneIndex;
+    mSceneIndex = idx;
     u16 *flags = FileManager::getInstance()->getTBoxFlagsConst();
-    mFlagSpace.copyFromSaveFile2(flags + (sceneIndex * 2), 0, 2);
+    mFlagSpace.copyFromSaveFile2(flags + (idx * 2), 0, 2);
 }
 
+/* 0x800BE990 */
 bool TBoxFlagManager::checkFlag(u16 sceneIndex, u16 flag) {
     s32 actualFlag = (flag + sceneIndex * 0x20);
     return mFlagHelper.checkFlag(actualFlag / 16, flag % 16, FileManager::getInstance()->getTBoxFlagsConst(),
             getFlagCount());
 }
 
+/* 0x800BEA30 */
 u16 TBoxFlagManager::getFlagCount() const {
     return 0x200;
 }
 
+/* 0x800BEA40 */
 void TBoxFlagManager::setFlag(u16 flag) {
     if (checkUncommittedFlag2(flag) != 1) {
         mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
@@ -98,13 +108,17 @@ void TBoxFlagManager::setFlag(u16 flag) {
     }
 }
 
+// NOTE: Not actually Enemy Defeat.
+// This is a little more than that, it keeps track of live objects based on their id as a whole
 class EnemyDefeatManager : public CommittableFlagManager {
 public:
     FlagSpace mFlagSpace;
     BitwiseFlagHelper mFlagHelper;
     u16 mSceneIndex;
 
-    static u16 *sFlags;
+    static u16 sEnemyDefeatFlags[4096];
+
+    static EnemyDefeatManager *sInstance;
 
     void clearSavedFlags();
     bool checkUncommittedFlag(u16 flag);
@@ -123,12 +137,17 @@ public:
     void setFlag(u16 flag);
 };
 
+EnemyDefeatManager *EnemyDefeatManager::sInstance = nullptr;
+u16 EnemyDefeatManager::sEnemyDefeatFlags[4096] = {};
+
+/* 0x800BEAC0 */
 void EnemyDefeatManager::clearSavedFlags() {
     u16 empty[0x1000];
     memset(empty, 0, 0x2000);
     FileManager::getInstance()->setEnemyDefeatFlags(empty, 0, 0x1000);
 }
 
+/* 0x800BEB00 */
 bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     if (checkIsValidFlag(flag)) {
         return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
@@ -137,13 +156,17 @@ bool EnemyDefeatManager::checkUncommittedFlag(u16 flag) {
     }
 }
 
-EnemyDefeatManager::EnemyDefeatManager() : CommittableFlagManager(false), mFlagSpace(sFlags, 12 /* later */) {}
+/* 0x800BEB80 */
+EnemyDefeatManager::EnemyDefeatManager()
+    : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {}
 
+/* 0x800BEBC0 */
 void EnemyDefeatManager::init() {
     mSceneIndex = 0;
     clearAll();
 }
 
+/* 0x800BEBD0 */
 void EnemyDefeatManager::copyFromSave(u16 sceneIndex) {
     mSceneIndex = sceneIndex;
     u16 count = mFlagSpace.mCount;
@@ -151,6 +174,7 @@ void EnemyDefeatManager::copyFromSave(u16 sceneIndex) {
     mFlagSpace.copyFromSaveFile(flags, 0, count);
 }
 
+/* 0x800BEC30 */
 void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
     if (mSceneIndex == sceneIndex) {
         return;
@@ -159,15 +183,18 @@ void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
     clearAll();
 }
 
+/* 0x800BEC50 */
 void EnemyDefeatManager::clearAll() {
     clearSavedFlags();
     mFlagSpace.unsetAll();
 }
 
+/* 0x800BEC90 */
 bool EnemyDefeatManager::checkIsValidFlag(u16 flag) {
     return flag < 0xFFFF;
 }
 
+/* 0x800BECB0 */
 bool EnemyDefeatManager::checkFlag(u16 flag) {
     if (!checkIsValidFlag(flag)) {
         return false;
@@ -177,10 +204,12 @@ bool EnemyDefeatManager::checkFlag(u16 flag) {
     }
 }
 
+/* 0x800BED50 */
 u16 EnemyDefeatManager::getFlagCount() const {
     return 0x1000;
 }
 
+/* 0x800BED60 */
 void EnemyDefeatManager::setFlag(u16 flag) {
     if (checkUncommittedFlag2(flag) != 1 && checkIsValidFlag(flag)) {
         mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);

src/toBeSorted/sceneflag_manager.cpp

@@ -17,7 +17,7 @@ public:
     static u16 sTempFlags[4];
     static u16 sSceneFlags[8];
     static u16 sZoneFlags[0xFC];
-    // public:
+
     static SceneflagManager *sInstance;
     void doNothing();
     void setShouldCommit(u16 flag);

src/toBeSorted/skipflag_manager.cpp

@@ -0,0 +1,82 @@
+#include <libc.h>
+#include "toBeSorted/bitwise_flag_helper.h"
+#include "toBeSorted/file_manager.h"
+#include "toBeSorted/flag_space.h"
+
+class SkipflagManager {
+public:
+    bool mShouldCommit;
+    BitwiseFlagHelper mFlagHelper;
+    FlagSpace mFlagSpace;
+
+    static u16 sSkipFlags[16];
+    static SkipflagManager *sInstance;
+
+    void copyFromSave();
+    void setCommitFlag(u16 flag);
+    SkipflagManager();
+    void unsetCommitFlag();
+    void thunk_copyFromSave();
+    void setFlag(u16 flag);
+    bool checkFlag(u16 flag);
+    bool commitFlags();
+};
+
+// 0x80575408
+SkipflagManager *SkipflagManager::sInstance = nullptr;
+// 0x805A9C68
+u16 SkipflagManager::sSkipFlags[16] = {};
+
+// 800bfba0
+void SkipflagManager::copyFromSave() {
+    u16* savedSkipflags = FileManager::sInstance->getSkipFlags();
+    mFlagSpace.copyFromSaveFile(savedSkipflags, 0, 0x10);
+}
+
+// 800bfbf0
+void SkipflagManager::setCommitFlag(u16 flag) {
+    mShouldCommit = true;
+}
+
+// 800bfc00
+SkipflagManager::SkipflagManager() : mFlagSpace(sSkipFlags, ARRAY_LENGTH(sSkipFlags)), mShouldCommit(false) {
+}
+
+// 800bfc30
+void SkipflagManager::unsetCommitFlag() {
+    mShouldCommit = false;
+}
+
+// 800bfc40
+void SkipflagManager::thunk_copyFromSave() {
+    SkipflagManager::copyFromSave();
+}
+
+// 800bfc50
+void SkipflagManager::setFlag(u16 flag) {
+    mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
+
+    u16 savedSkipflags[0x10];
+    checkedMemcpy(savedSkipflags, 0x20, FileManager::sInstance->getSkipFlags(), 0x20);
+
+    mFlagHelper.setFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
+    FileManager::sInstance->setSkipFlagsChecked(savedSkipflags, 0, 0x10);
+    setCommitFlag(flag);
+}
+
+// 800bfd20
+bool SkipflagManager::checkFlag(u16 flag) {
+    u16* savedSkipflags = FileManager::sInstance->getSkipFlags();
+    return mFlagHelper.checkFlag(flag / 16, flag % 16, savedSkipflags, 0x10);
+}
+
+// 800bfd90
+bool SkipflagManager::commitFlags() {
+    if (mShouldCommit) {
+        FileManager *instance = FileManager::sInstance;
+        instance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
+        mShouldCommit = false;
+        return true;
+    }
+    return false;
+}