Merge pull request #65 from robojumper/flag_mgrs

flag_managers OK

src/REL/d/a/obj/d_a_obj_bamboo_island.cpp

@@ -1,7 +1,7 @@
 #include "d/a/obj/d_a_obj_bamboo_island.h"
 
 #include "d/col/bg/d_bg_s.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/room_manager.h"
 
 const f32 dAcObambooIsland_c::unusedFloat1 = 100000.0f;

src/REL/d/a/obj/d_a_obj_island_nusi.cpp

@@ -8,7 +8,7 @@
 #include "nw4r/g3d/g3d_resnode.h"
 #include "nw4r/g3d/g3d_scnmdl.h"
 #include "nw4r/g3d/g3d_scnobj.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/room_manager.h"
 
 const f32 dAcOislandNusi_c::someFloat = 100000.0f;

src/REL/d/a/obj/d_a_obj_junk_repairing.cpp

@@ -1,6 +1,6 @@
 #include "d/a/obj/d_a_obj_junk_repairing.h"
 
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/storyflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(OBJ_JUNK_REPAIR, dAcOJunkRep_c, fProfile::OBJ_JUNK_REPAIR, 0x027B, 0, 3);

src/REL/d/a/obj/d_a_obj_pool_cock.cpp

@@ -3,7 +3,7 @@
 #include "d/a/obj/d_a_obj_vortex.h"
 #include "s/s_Math.h"
 #include "toBeSorted/room_manager.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_POOL_COCK, dAcOPoolCock_c, fProfile::OBJ_POOL_COCK, 0x024D, 0, 7);
 

src/REL/d/a/obj/d_a_obj_toD3_stone_figure.cpp

@@ -4,7 +4,7 @@
 #include "toBeSorted/attention.h"
 #include "toBeSorted/event.h"
 #include "toBeSorted/event_manager.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/scgame.h"
 
 

src/REL/d/a/obj/d_a_obj_utajima.cpp

@@ -4,7 +4,7 @@
 #include "d/a/obj/d_a_obj_base.h"
 #include "d/col/bg/d_bg_s.h"
 #include "d/col/c/c_m3d_g_aab.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/room_manager.h"
 
 static const char *const mMdlNames[] = {

src/REL/d/t/d_t_dowsing.cpp

@@ -1,8 +1,8 @@
 #include "d/t/d_t_dowsing.h"
 
-#include "toBeSorted/item_story_flag_manager.h"
-#include "toBeSorted/room_manager.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/itemflag_manager.h"
+#include "d/flag/storyflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(T_DOWSING, dTgDowsing_c, fProfile::T_DOWSING, 0x0293, 0, 0);
@@ -56,13 +56,13 @@ bool dTgDowsing_c::checkDowsing() const {
 
     switch (mDowsingOption) {
         case TRIAL_0:
-            return ItemflagManager::sInstance->getFlag(187) && !StoryflagManager::sInstance->getCounterOrFlag(93);
+            return ItemflagManager::sInstance->getFlagDirect(187) && !StoryflagManager::sInstance->getCounterOrFlag(93);
         case TRIAL_1:
-            return ItemflagManager::sInstance->getFlag(188) && !StoryflagManager::sInstance->getCounterOrFlag(97);
+            return ItemflagManager::sInstance->getFlagDirect(188) && !StoryflagManager::sInstance->getCounterOrFlag(97);
         case TRIAL_2:
-            return ItemflagManager::sInstance->getFlag(189) && !StoryflagManager::sInstance->getCounterOrFlag(98);
+            return ItemflagManager::sInstance->getFlagDirect(189) && !StoryflagManager::sInstance->getCounterOrFlag(98);
         case TRIAL_3:
-            return ItemflagManager::sInstance->getFlag(193) && !StoryflagManager::sInstance->getCounterOrFlag(99);
+            return ItemflagManager::sInstance->getFlagDirect(193) && !StoryflagManager::sInstance->getCounterOrFlag(99);
         case PROPELLER:         return DowsingTarget::hasPropellerDowsing();
         case WATER_BASIN:       return DowsingTarget::hasWaterBasinDowsing();
         case CRYSTAL_BALL:      return DowsingTarget::hasCrystalBallDowsing();

src/REL/d/t/d_t_genki_dws_tgt.cpp

@@ -1,8 +1,8 @@
 #include "d/t/d_t_genki_dws_tgt.h"
 
-#include "toBeSorted/item_story_flag_manager.h"
 #include "toBeSorted/room_manager.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/scgame.h"
 
 

src/REL/d/t/d_t_reaction.cpp

@@ -5,7 +5,7 @@
 #include "d/a/d_a_player.h"
 #include "d/a/obj/d_a_obj_item.h"
 #include "d/col/cc/d_cc_mgr.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(TAG_REACTION, dTgReaction_c, fProfile::TAG_REACTION, 0x0151, 0, 0);

src/REL/d/t/d_t_ship_window.cpp

@@ -1,7 +1,7 @@
 #include "d/t/d_t_ship_window.h"
 
 #include "toBeSorted/event_manager.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(TAG_SHIP_WINDOW, dTgShipWindow_c, fProfile::TAG_SHIP_WINDOW, 0x0228, 0, 0);

src/REL/d/t/d_t_sw_area.cpp

@@ -1,8 +1,8 @@
 #include "d/t/d_t_sw_area.h"
 #include "d/a/d_a_player.h"
 #include "toBeSorted/area_math.h"
-#include "toBeSorted/sceneflag_manager.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/sceneflag_manager.h"
+#include "d/flag/storyflag_manager.h"
 
 SPECIAL_ACTOR_PROFILE(SW_AREA_TAG, dTgSwArea_c, fProfile::SW_AREA_TAG, 0x292, 0, 0);
 

src/REL/d/t/d_t_time_area_check.cpp

@@ -1,6 +1,6 @@
 #include "d/t/d_t_time_area_check.h"
 
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 #include "toBeSorted/time_area_mgr.h"
 
 

src/REL/d/t/d_t_timer.cpp

@@ -1,6 +1,6 @@
 #include "d/t/d_t_timer.h"
 
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(TAG_TIMER, dTgTimer_c, fProfile::TAG_TIMER, 0x029F, 0, 0);

src/REL/d/t/d_t_touch.cpp

@@ -2,7 +2,7 @@
 
 #include "c/c_math.h"
 #include "toBeSorted/area_math.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 
 SPECIAL_ACTOR_PROFILE(TOUCH_TAG, dTgTouchTag, fProfile::TOUCH_TAG, 0x028E, 0, 0);

src/d/a/d_a_base.cpp

@@ -8,7 +8,7 @@
 #include "toBeSorted/event.h"
 #include "toBeSorted/event_manager.h"
 #include "toBeSorted/file_manager.h"
-#include "toBeSorted/misc_flag_managers.h"
+#include "d/flag/enemyflag_manager.h"
 #include "toBeSorted/room_manager.h"
 #include "toBeSorted/scgame.h"
 #include "toBeSorted/special_item_drop_mgr.h"
@@ -476,7 +476,7 @@ void dAcBase_c::setActorRef(dAcBase_c *ref) {
 
 // May not be only purpose
 void dAcBase_c::setEnemyDefeatFlag() {
-    EnemyDefeatManager::sInstance->setFlag(obj_id);
+    EnemyflagManager::sInstance->setFlag(obj_id);
 }
 
 // 8002d940

src/d/a/obj/d_a_obj_switch.cpp

@@ -6,7 +6,7 @@
 #include "d/col/bg/d_bg_w.h"
 #include "nw4r/g3d/g3d_resfile.h"
 #include "s/s_Math.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 
 SPECIAL_ACTOR_PROFILE(OBJ_SW, dAcOsw_c, fProfile::OBJ_SW, 0x12B, 0, 0x1002);
 

src/d/flag/baseflag_manager.inc

@@ -0,0 +1,117 @@
+#include "d/flag/baseflag_manager.h"
+
+ItemStoryManagerBase::ItemStoryManagerBase(): mFlagCount(0), mFlagSizeBytes(0), mpFlagSpace(nullptr), mpFlagIndex(nullptr), mDirty(false) {}
+ItemStoryManagerBase::~ItemStoryManagerBase() {
+    if (mpFlagIndex != nullptr) {
+        delete mpFlagIndex;
+    }
+}
+
+void ItemStoryManagerBase::setFlagSizes(u16 flagCount, u16 flagSizeBytes) {
+    mFlagCount = flagCount;
+    mFlagSizeBytes = flagSizeBytes;
+}
+
+/** 800bf320 */
+void ItemStoryManagerBase::createFlagIndex(FlagDefinition *def, u16 count) {
+    mpFlagIndex = new FlagIndex(count, def);
+}
+
+/** 800bf380 */
+void ItemStoryManagerBase::copyFromSave() {
+    FlagSpace *current = mpFlagSpace;
+    const u16 *saved = getSaveFlagSpace();
+    current->copyFromSaveFile(saved, 0, mFlagCount);
+}
+
+/** 800bf3e0 */
+void ItemStoryManagerBase::init() {
+    const u16 *space = getSaveFlagSpace();
+    if (space == nullptr || mpFlagIndex == nullptr) {
+        initFlagSpace();
+        copyFlagsFromSaveFirstTime();
+        setupFlagIndex();
+    }
+}
+
+/** 800bf470 */
+void ItemStoryManagerBase::initFlagSpace() {
+
+}
+
+/** 800bf480 */
+u16 ItemStoryManagerBase::getFlag(u16 flag) const {
+    const u16 *data = getSaveFlagSpace();
+    return mpFlagIndex->getCounterOrFlag(flag, data, mFlagCount);
+}
+
+/** 800bf4e0 */
+u16 ItemStoryManagerBase::getUncommittedValue_Priv(u16 flag) {
+    u16 *data = mpFlagSpace->getFlagPtrUnchecked();
+    return mpFlagIndex->getCounterOrFlag(flag, data, mFlagCount);
+}
+
+/** 800bf530 */
+void ItemStoryManagerBase::setOrClearFlag(u16 flag, u16 value) {
+    FlagSpace *storyFlagsPtr = mpFlagSpace;
+    u16 *pData = storyFlagsPtr->getFlagPtrChecked();
+    mpFlagIndex->setCounterOrFlag(flag, pData, storyFlagsPtr->mCount, value);
+    onFlagChange(flag);
+}
+
+/** 800bf5b0 */
+void ItemStoryManagerBase::setFlag(u16 flag) {
+    setOrClearFlag(flag, true);
+}
+
+/** 800bf5c0 */
+void ItemStoryManagerBase::unsetFlag(u16 flag) {
+    setOrClearFlag(flag, false);
+}
+
+/** 800bf5d0 */
+void ItemStoryManagerBase::setFlagOrCounterToValue(u16 flag, u16 value) {
+    setOrClearFlag(flag, value);
+}
+
+/** 800bf5e0 */
+u16 ItemStoryManagerBase::getCounterOrFlag(u16 flag) const {
+    return ItemStoryManagerBase::getFlag(flag);
+}
+
+/** 800bf5f0 */
+u16 ItemStoryManagerBase::getUncommittedValue(u16 flag) {
+    return getUncommittedValue_Priv(flag);
+}
+
+/** 800bf600 */
+u16 ItemStoryManagerBase::unk3(u16 flag) {
+    return getMaskForFlag(flag);
+}
+
+/** 800bf610 */
+void ItemStoryManagerBase::onFlagChange(u16 flag) {
+    mDirty = true;
+    onDirty();
+}
+
+/** 800bf630 */
+void ItemStoryManagerBase::onDirty() {
+
+}
+
+/** 800bf640 */
+u16 ItemStoryManagerBase::getMaskForFlag(u16 flag) {
+    return mpFlagIndex->maskForIdx(flag, mFlagCount);
+}
+
+/** 800bf650 */
+void ItemStoryManagerBase::doCommit_Priv() {
+    doCommit();
+    mDirty = false;
+}
+
+/* 800bf690 */
+void ItemStoryManagerBase::postCommit() {
+
+}

src/d/flag/bitwise_flag_helper.inc

@@ -1,4 +1,4 @@
-#include "toBeSorted/bitwise_flag_helper.h"
+#include "d/flag/bitwise_flag_helper.h"
 
 #include "common.h"
 

src/d/flag/committable_flag_manager.inc

@@ -0,0 +1,12 @@
+#include "d/flag/committable_flag_manager.h"
+
+/* 0x800BE7B0 */
+bool CommittableFlagManager::commit() {
+    if (mNeedsCommit) {
+        doCommit();
+        mNeedsCommit = false;
+        return true;
+    } else {
+        return false;
+    }
+}

src/d/flag/dungeonflag_manager.inc

@@ -0,0 +1,75 @@
+#include "d/flag/dungeonflag_manager.h"
+#include "d/flag/flag_index.h"
+
+
+// TODO move
+extern "C" FlagDefinition DungeonflagManager__FLAG_DEFINITIONS[];
+
+/** 80575404 */
+DungeonflagManager *DungeonflagManager::sInstance = nullptr;
+
+/** 805a9c58 */
+u16 DungeonflagManager::sDungeonFlags[8] = {};
+
+/** 800bf8d0 */
+void DungeonflagManager::copyFromSave_Internal(u16 flagIndex) {
+    mFlagSpace.copyFromSaveFile(saveFilePtr(flagIndex), 0, 0x8);
+}
+
+/** 800bf930 */
+void DungeonflagManager::setCommitFlag(u16 flag) {
+    mShouldCommit = true;
+}
+
+/** 0x800bf940 */
+DungeonflagManager::DungeonflagManager()
+    : mShouldCommit(false), mStageIndex(-1), mpFlagIndex(nullptr),
+      mFlagSpace(sDungeonFlags, ARRAY_LENGTH(sDungeonFlags)) {}
+
+/** 800bf980 */
+void DungeonflagManager::init() {
+    mpFlagIndex = new FlagIndex(0x11, DungeonflagManager__FLAG_DEFINITIONS);
+    mShouldCommit = false;
+}
+
+/** 800bf9e0 */
+void DungeonflagManager::copyFromSave(u32 flag) {
+    mStageIndex = flag;
+    copyFromSave_Internal(flag);
+}
+
+/** 800bf9f0 */
+void DungeonflagManager::setToValue(u16 flag, u32 value) {
+    u16 *data = mFlagSpace.getFlagPtrChecked();
+    mpFlagIndex->setCounterOrFlag(flag, data, 8, value);
+    setCommitFlag(flag);
+}
+
+/** 800bfa60 */
+void DungeonflagManager::setFlag(u16 flag) {
+    u16 *data = mFlagSpace.getFlagPtrChecked();
+    mpFlagIndex->setCounterOrFlag(flag, data, 8, 1);
+    setCommitFlag(flag);
+}
+
+/** 800fbac0 */
+u16 DungeonflagManager::getDungeonFlag(u16 flag) {
+    u16 *data = mFlagSpace.getFlagPtrUnchecked();
+    return mpFlagIndex->getCounterOrFlag(flag, data, 8);
+}
+
+/** 800fbb10 */
+bool DungeonflagManager::commit() {
+    FileManager *instance;
+    u16 idx = mStageIndex;
+    if (idx == 0xFFFF) {
+        return false;
+    } else if (mShouldCommit) {
+        instance = FileManager::sInstance;
+        u16 *ptr = mFlagSpace.getFlagPtrUnchecked();
+        instance->setDungeonFlags(ptr, (idx & 0x1fff) * 8, 0x08);
+        mShouldCommit = false;
+        return true;
+    }
+    return false;
+}

src/d/flag/enemyflag_manager.inc

@@ -0,0 +1,81 @@
+#include "d/flag/enemyflag_manager.h"
+
+EnemyflagManager *EnemyflagManager::sInstance = nullptr;
+u16 EnemyflagManager::sEnemyDefeatFlags[4096] = {};
+
+/* 0x800BEAC0 */
+void EnemyflagManager::clearSavedFlags() {
+    u16 empty[0x1000];
+    memset(empty, 0, 0x2000);
+    FileManager::getInstance()->setEnemyDefeatFlags(empty, 0, 0x1000);
+}
+
+/* 0x800BEB00 */
+bool EnemyflagManager::checkUncommittedFlag(u16 flag) {
+    if (checkIsValidFlag(flag)) {
+        return mFlagHelper.checkFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrUnchecked(), mFlagSpace.mCount);
+    } else {
+        return false;
+    }
+}
+
+/* 0x800BEB80 */
+EnemyflagManager::EnemyflagManager()
+    : CommittableFlagManager(false), mFlagSpace(sEnemyDefeatFlags, ARRAY_LENGTH(sEnemyDefeatFlags)) {}
+
+/* 0x800BEBC0 */
+void EnemyflagManager::init() {
+    mSceneIndex = 0;
+    clearAll();
+}
+
+/* 0x800BEBD0 */
+void EnemyflagManager::copyFromSave(u16 sceneIndex) {
+    mSceneIndex = sceneIndex;
+    u16 count = mFlagSpace.mCount;
+    u16 *flags = FileManager::getInstance()->getEnemyDefeatFlagsConst();
+    mFlagSpace.copyFromSaveFile(flags, 0, count);
+}
+
+/* 0x800BEC30 */
+void EnemyflagManager::updateFlagIndex(u16 sceneIndex) {
+    if (mSceneIndex == sceneIndex) {
+        return;
+    }
+    mSceneIndex = sceneIndex;
+    clearAll();
+}
+
+/* 0x800BEC50 */
+void EnemyflagManager::clearAll() {
+    clearSavedFlags();
+    mFlagSpace.unsetAll();
+}
+
+/* 0x800BEC90 */
+bool EnemyflagManager::checkIsValidFlag(u16 flag) {
+    return flag < 0xFFFF;
+}
+
+/* 0x800BECB0 */
+bool EnemyflagManager::checkFlag(u16 flag) {
+    if (!checkIsValidFlag(flag)) {
+        return false;
+    } else {
+        u16 *pData = FileManager::getInstance()->getEnemyDefeatFlagsConst();
+        return mFlagHelper.checkFlag(flag / 16, flag % 16, pData, getFlagCount());
+    }
+}
+
+/* 0x800BED50 */
+u16 EnemyflagManager::getFlagCount() const {
+    return 0x1000;
+}
+
+/* 0x800BED60 */
+void EnemyflagManager::setFlag(u16 flag) {
+    if (checkUncommittedFlag2(flag) != 1 && checkIsValidFlag(flag)) {
+        mFlagHelper.setFlag(flag / 16, flag % 16, mFlagSpace.getFlagPtrChecked(), mFlagSpace.mCount);
+        setNeedsCommit(true);
+    }
+}

src/d/flag/flag_index.inc

@@ -1,30 +1,30 @@
-#include "toBeSorted/unk_flag_stuff.h"
+#include "d/flag/flag_index.h"
 
-u16 UnkFlagStuff::calculateMask(s32 shift) {
+u16 FlagIndex::calculateMask(s32 shift) {
     return (2 << (shift & 0xF)) - 1;
 }
 
-void UnkFlagStuff::doNothing(u32 unused) {}
+void FlagIndex::doNothing(u32 unused) {}
 
-UnkFlagStuff::UnkFlagStuff(u16 count, UnkFlagDefinition *definitions) {
+FlagIndex::FlagIndex(u16 count, FlagDefinition *definitions) {
     this->mDefinitionsCount = count;
     this->mpDefinitions = definitions;
 }
 
-void UnkFlagStuff::prepareIndexShiftMask(u16 counterIdx, u32 unused, u16 *indexPtr, u8 *shiftPtr, u16 *maskPtr) {
+void FlagIndex::prepareIndexShiftMask(u16 counterIdx, u32 unused, u16 *indexPtr, u8 *shiftPtr, u16 *maskPtr) {
     doNothing(counterIdx);
     *indexPtr = mpDefinitions[counterIdx].mIndex;
     *shiftPtr = mpDefinitions[counterIdx].mShiftMask >> 4;
     *maskPtr = calculateMask(mpDefinitions[counterIdx].mShiftMask);
 }
 
-u16 UnkFlagStuff::maskForIdx(u16 index) {
+u16 FlagIndex::maskForIdx(u16 index, u16 flagCount) {
     doNothing(index);
 
     return calculateMask(mpDefinitions[index].mShiftMask);
 }
 
-u32 UnkFlagStuff::getCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 param4) {
+u16 FlagIndex::getCounterOrFlag(u16 counterIdx, const u16 *dataPtr, u32 param4) {
     u16 index = 0;
     u8 shift = 0;
     u16 mask = 0;
@@ -32,7 +32,7 @@ u32 UnkFlagStuff::getCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 param4) {
     return mask & (dataPtr[index] >> shift);
 }
 
-void UnkFlagStuff::setCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 flagCount, u32 value) {
+void FlagIndex::setCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 flagCount, u32 value) {
     u16 index = 0;
     u8 shift = 0;
     u16 mask = 0;
@@ -41,21 +41,13 @@ void UnkFlagStuff::setCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 flagCount,
     dataPtr[index] = (u16)(value << shift) | dataPtr[index];
 }
 
-inline bool isLessThan(int a, int b) {
-    return a <= b;
-}
-
-u32 UnkFlagStuff::checkFlagValid(u16 counterIdx, u32 flagCount) {
+u32 FlagIndex::checkFlagValid(u16 counterIdx, u32 flagCount) {
     if (mpDefinitions == nullptr) {
         return 0;
     }
     if (mDefinitionsCount <= counterIdx || mpDefinitions[counterIdx].mIndex == 0xFF) {
         return 0;
     } else {
-        if (isLessThan(flagCount, mpDefinitions[counterIdx].mIndex)) {
-            return 0;
-        } else {
-            return 1;
-        }
+        return (int)mpDefinitions[counterIdx].mIndex < (int)flagCount;
     }
 }

src/d/flag/flag_managers.cpp

@@ -0,0 +1,125 @@
+
+#include "d/flag/flag_managers.h"
+
+// clang-format off
+#include "common.h"
+#include "egg/core/eggHeap.h"
+#include "m/m_heap.h"
+// vtable order
+#include "d/flag/flag_space.h"
+#include "d/flag/tboxflag_manager.h"
+#include "d/flag/enemyflag_manager.h"
+#include "d/flag/storyflag_manager.h"
+#include "d/flag/itemflag_manager.h"
+
+// actual managers
+#include "d/flag/sceneflag_manager.inc"
+#include "d/flag/committable_flag_manager.inc"
+#include "d/flag/tboxflag_manager.inc"
+#include "d/flag/enemyflag_manager.inc"
+#include "d/flag/flag_space.inc"
+#include "d/flag/flag_index.inc"
+#include "d/flag/bitwise_flag_helper.inc"
+#include "d/flag/baseflag_manager.inc"
+#include "d/flag/storyflag_manager.inc"
+#include "d/flag/itemflag_manager.inc"
+#include "d/flag/dungeonflag_manager.inc"
+#include "d/flag/skipflag_manager.inc"
+// clang-format on
+
+
+static void postSetup();
+
+template <typename T>
+class MyFlagManager : public T {
+public:
+    MyFlagManager<T>() {}
+    ~MyFlagManager<T>() {}
+};
+
+void setupFlagManagers(EGG::Heap *heap) {
+    if (SceneflagManager::sInstance == nullptr) {
+        SceneflagManager::sInstance = new (heap) MyFlagManager<SceneflagManager>();
+        mHeap m(heap);
+        SceneflagManager::sInstance->init();
+    }
+
+    if (TBoxflagManager::sInstance == nullptr) {
+        TBoxflagManager::sInstance = new (heap) MyFlagManager<TBoxflagManager>();
+        mHeap m(heap);
+        TBoxflagManager::sInstance->init();
+    }
+
+    if (EnemyflagManager::sInstance == nullptr) {
+        EnemyflagManager::sInstance = new (heap) MyFlagManager<EnemyflagManager>();
+        mHeap m(heap);
+        EnemyflagManager::sInstance->init();
+    }
+
+    if (StoryflagManager::sInstance == nullptr) {
+        StoryflagManager::sInstance = new (heap) MyFlagManager<StoryflagManager>();
+        mHeap m(heap);
+        StoryflagManager::sInstance->init();
+    }
+
+    if (ItemflagManager::sInstance == nullptr) {
+        ItemflagManager::sInstance = new (heap) MyFlagManager<ItemflagManager>();
+        mHeap m(heap);
+        ItemflagManager::sInstance->init();
+    }
+
+    if (DungeonflagManager::sInstance == nullptr) {
+        DungeonflagManager::sInstance = new (heap) MyFlagManager<DungeonflagManager>();
+        mHeap m(heap);
+        DungeonflagManager::sInstance->init();
+    }
+
+    if (SkipflagManager::sInstance == nullptr) {
+        SkipflagManager::sInstance = new (heap) MyFlagManager<SkipflagManager>();
+        mHeap m(heap);
+        SkipflagManager::sInstance->init();
+    }
+
+    postSetup();
+}
+
+static void postSetup() {
+    updateFlagForFlagIndex(0);
+}
+
+void copyAllFlagManagersFromSave() {
+    u16 flag = FileManager::sInstance->getSceneFlagIndex();
+    SceneflagManager::sInstance->copyFromSave(flag);
+    TBoxflagManager::sInstance->copyFromSave(flag);
+    StoryflagManager::sInstance->copyFromSave();
+    ItemflagManager::sInstance->copyFromSave();
+    DungeonflagManager::sInstance->copyFromSave(flag);
+    SkipflagManager::sInstance->copyFromSave();
+    EnemyflagManager::sInstance->copyFromSave(flag);
+}
+
+void updateFlagForFlagIndex(u16 stage) {
+    SceneflagManager::sInstance->updateFlagindex(stage);
+    TBoxflagManager::sInstance->copyFromSave(stage);
+    EnemyflagManager::sInstance->updateFlagIndex(stage);
+    DungeonflagManager::sInstance->copyFromSave(stage);
+}
+
+void commitAllFlagManagers() {
+    StoryflagManager::sInstance->commit();
+    ItemflagManager::sInstance->commit();
+    DungeonflagManager::sInstance->commit();
+    SkipflagManager::sInstance->commit();
+    SceneflagManager::sInstance->commit();
+    TBoxflagManager::sInstance->commit();
+    EnemyflagManager::sInstance->commit();
+}
+
+bool checkedMemcpy(void *dest, u32 destLen, const void *src, u32 count) {
+    if (dest == nullptr || src == nullptr || destLen < count || destLen > 0xFFFF) {
+        return true;
+    } else {
+        memcpy(dest, src, count);
+        return false;
+    }
+}

src/d/flag/flag_space.inc

@@ -0,0 +1,33 @@
+#include "common.h"
+#include "d/flag/flag_managers.h"
+#include "d/flag/flag_space.h"
+#include "toBeSorted/file_manager.h"
+
+u16 *FlagSpace::getFlagPtrChecked() const {
+    filemanagerCheck();
+    return mpFlags;
+}
+u16 *FlagSpace::getFlagPtrUnchecked() const {
+    return mpFlags;
+}
+void FlagSpace::unsetAll() {
+    setAllToZero(0, mCount);
+}
+void FlagSpace::setAllToZero(u16 offset, u16 flagCount) {
+    filemanagerCheck();
+    memset(mpFlags + offset, 0, (u16)(flagCount * 2));
+}
+void FlagSpace::copyFromSaveFile2(const u16 *pSaved, u16 offset, u16 flagCount) {
+    filemanagerCheck();
+    checkedMemcpy(mpFlags + offset, (u16)(mCount * 2), pSaved, (u16)(flagCount * 2));
+}
+
+void FlagSpace::copyFromSaveFile(const u16 *pSaved, u16 offset, u16 flagCount) {
+    checkedMemcpy(mpFlags + offset, (u16)(mCount * 2), pSaved, (u16)(flagCount * 2));
+}
+void FlagSpace::filemanagerCheck() const {
+    if (FileManager::sInstance->mIsFileUnk1[0]) {
+        return;
+    }
+    while (true) {}
+}

src/d/flag/itemflag_manager.inc

@@ -0,0 +1,29 @@
+#include "d/flag/itemflag_manager.h"
+
+u16 ItemflagManager::sFlags[0x40];
+
+ItemflagManager *ItemflagManager::sInstance = nullptr;
+
+ItemflagManager::ItemflagManager() : mItemFlags(sFlags, 0x40) {}
+
+void ItemflagManager::copyFlagsFromSaveFirstTime() {
+    setFlagSizes(0x40, 0x80);
+    ItemStoryManagerBase::copyFromSave();
+}
+
+extern "C" FlagDefinition ItemflagManager__ITEMFLAG_DEFINITIONS[];
+
+void ItemflagManager::setupFlagIndex() {
+    createFlagIndex(ItemflagManager__ITEMFLAG_DEFINITIONS, 0x1FE);
+}
+
+void ItemflagManager::onDirty() {}
+
+bool ItemflagManager::commit() {
+    if (mDirty) {
+        doCommit_Priv();
+        postCommit();
+        return true;
+    }
+    return false;
+}

src/d/flag/sceneflag_manager.inc

@@ -1,16 +1,13 @@
-#include "toBeSorted/sceneflag_manager.h"
-
 #include "common.h"
-#include "libc.h"
+#include "d/flag/sceneflag_manager.h"
 #include "toBeSorted/file_manager.h"
 
-
 SceneflagManager *SceneflagManager::sInstance = nullptr;
 u16 SceneflagManager::sTempFlags[] = {};
 u16 SceneflagManager::sSceneFlags[8] = {};
 u16 SceneflagManager::sZoneFlags[0xFC] = {};
 
-void SceneflagManager::doNothing() {}
+void SceneflagManager::init() {}
 void SceneflagManager::setShouldCommit(u16 flag) {
     mShouldCommit = 1;
 }
@@ -20,14 +17,7 @@ SceneflagManager::SceneflagManager()
     mSceneIdx = 0xFFFF;
     mShouldCommit = 0;
 }
-// SceneflagManager::SceneflagManager()
-//     {
-//         mSceneflags.init(sSceneFlags, ARRAY_LENGTH(sSceneFlags));
-//         mTempflags.init(sTempFlags, ARRAY_LENGTH(sTempFlags));
-//         mZoneflags.init(sZoneFlags, ARRAY_LENGTH(sZoneFlags));
-//         mSceneIdx = 0xFFFF;
-//         mShouldCommit = 0;
-//     }
+
 s32 SceneflagManager::isNotTempOrZoneFlag(u16 flag) {
     // return ((s32)flag - 0x80) < 0;
     return flag < 0x80;
@@ -259,7 +249,7 @@ void SceneflagManager::unsetTempOrSceneflag(u16 flag) {
         setShouldCommit(flag);
     }
 }
-s32 SceneflagManager::doCommit() {
+s32 SceneflagManager::commit() {
     if (mSceneIdx == 0xFFFF) {
         return 0;
     } else if (mShouldCommit) {

src/d/flag/skipflag_manager.inc

@@ -1,26 +1,9 @@
-#include "libc.h"
-#include "toBeSorted/bitwise_flag_helper.h"
+#include "common.h"
+#include "d/flag/bitwise_flag_helper.h"
+#include "d/flag/flag_managers.h"
+#include "d/flag/flag_space.h"
+#include "d/flag/skipflag_manager.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;
@@ -28,7 +11,7 @@ SkipflagManager *SkipflagManager::sInstance = nullptr;
 u16 SkipflagManager::sSkipFlags[16] = {};
 
 // 800bfba0
-void SkipflagManager::copyFromSave() {
+void SkipflagManager::doCopyFromSave() {
     u16 *savedSkipflags = FileManager::sInstance->getSkipFlags();
     mFlagSpace.copyFromSaveFile(savedSkipflags, 0, 0x10);
 }
@@ -42,13 +25,13 @@ void SkipflagManager::setCommitFlag(u16 flag) {
 SkipflagManager::SkipflagManager() : mFlagSpace(sSkipFlags, ARRAY_LENGTH(sSkipFlags)), mShouldCommit(false) {}
 
 // 800bfc30
-void SkipflagManager::unsetCommitFlag() {
+void SkipflagManager::init() {
     mShouldCommit = false;
 }
 
 // 800bfc40
-void SkipflagManager::thunk_copyFromSave() {
-    SkipflagManager::copyFromSave();
+void SkipflagManager::copyFromSave() {
+    doCopyFromSave();
 }
 
 // 800bfc50
@@ -70,7 +53,7 @@ bool SkipflagManager::checkFlag(u16 flag) {
 }
 
 // 800bfd90
-bool SkipflagManager::commitFlags() {
+bool SkipflagManager::commit() {
     if (mShouldCommit) {
         FileManager *instance = FileManager::sInstance;
         instance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);

src/d/flag/storyflag_manager.inc

@@ -0,0 +1,32 @@
+#include "d/flag/storyflag_manager.h"
+
+u16 StoryflagManager::sFlags[0x80];
+StoryflagManager *StoryflagManager::sInstance = nullptr;
+
+StoryflagManager::StoryflagManager() : mStoryFlags(sFlags, 0x80) {}
+
+void StoryflagManager::copyFlagsFromSaveFirstTime() {
+    setFlagSizes(0x80, 0x100);
+    ItemStoryManagerBase::copyFromSave();
+}
+
+extern "C" FlagDefinition StoryflagManager__STORYFLAG_DEFINITIONS[];
+
+void StoryflagManager::setupFlagIndex() {
+    createFlagIndex(StoryflagManager__STORYFLAG_DEFINITIONS, 0x4B1);
+}
+
+void StoryflagManager::onDirty() {}
+
+bool StoryflagManager::commit() {
+    if (mDirty) {
+        doCommit_Priv();
+        postCommit();
+        return true;
+    }
+    return false;
+}
+
+void StoryflagManager::unsetFlag(u16 flag) {
+    ItemStoryManagerBase::unsetFlag(flag);
+}

src/d/flag/tboxflag_manager.inc

@@ -0,0 +1,54 @@
+#include "d/flag/tboxflag_manager.h"
+#include "toBeSorted/file_manager.h"
+
+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);
+}
+
+/* 0x800BE8E0 */
+TBoxflagManager::TBoxflagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
+    mSceneIndex = 0xFFFF;
+}
+
+/* 0x800BE920 */
+void TBoxflagManager::init() {}
+
+/* 0x800BE930 */
+void TBoxflagManager::copyFromSave(u32 sceneIndex) {
+    u16 idx = sceneIndex;
+    mSceneIndex = idx;
+    u16 *flags = FileManager::getInstance()->getTBoxFlagsConst();
+    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);
+        setNeedsCommit(true);
+    }
+}

src/d/tg/d_t_switch.cpp

@@ -2,7 +2,7 @@
 
 #include "c/c_math.h"
 #include "toBeSorted/event.h"
-#include "toBeSorted/sceneflag_manager.h"
+#include "d/flag/sceneflag_manager.h"
 #include "toBeSorted/scgame.h"
 
 

src/toBeSorted/counters/counter.cpp

@@ -1,6 +1,6 @@
 #include "toBeSorted/counters/counter.h"
 
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/itemflag_manager.h"
 
 /* 8016cc40 */ s32 Counter::checkedAdd(s32 num) {
     s32 uncommitted = getUncommittedValue();

src/toBeSorted/counters/rupee_counter.cpp

@@ -1,5 +1,5 @@
 #include "toBeSorted/counters/counter.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/itemflag_manager.h"
 
 static u16 getBaseCapacity();
 static u16 getExtraWalletCapacity();
@@ -28,7 +28,7 @@ struct WalletStruct {
     };
     const WalletStruct *wallet = &wallet_definitions[3];
     for (; i < 4; i++, wallet--) {
-        if (ItemflagManager::sInstance->getFlag(wallet->flag)) {
+        if (ItemflagManager::sInstance->getFlagDirect(wallet->flag)) {
             return wallet->capacity;
         }
     }

src/toBeSorted/dowsing_target.cpp

@@ -2,8 +2,8 @@
 
 #include "c/c_math.h"
 #include "m/m_mtx.h"
-#include "nw4r/ut/ut_LinkList.h"
-#include "toBeSorted/item_story_flag_manager.h"
+#include "d/flag/itemflag_manager.h"
+#include "d/flag/storyflag_manager.h"
 #include "toBeSorted/tlist.h"
 
 

src/toBeSorted/dungeonflag_manager.cpp

@@ -1,105 +0,0 @@
-#include "libc.h"
-#include "toBeSorted/bitwise_flag_helper.h"
-#include "toBeSorted/file_manager.h"
-#include "toBeSorted/flag_space.h"
-#include "toBeSorted/unk_flag_stuff.h"
-
-
-// TODO move
-extern "C" UnkFlagDefinition DungeonflagManager__FLAG_DEFINITIONS[];
-
-class DungeonflagManager {
-public:
-    bool mShouldCommit;
-    u16 mStageIndex;
-    UnkFlagStuff *mFlagStuff;
-    FlagSpace mFlagSpace;
-
-    static u16 sDungeonFlags[8];
-    // static DungeonflagManager *sInstance;
-
-    void copyFromSave(s16 flag);
-    void copyFromSave(u16 flagIndex);
-    void setCommitFlag(u16 flag);
-    DungeonflagManager();
-    void setupFlagStuff();
-    void setToValue(u16 flag, u32 value);
-    void setFlag(u16 flag);
-    u32 getDungeonFlag(u16 flag);
-    bool doCommit();
-
-    /** inline shenanigans to get copyFromSave to match */
-    static inline u16 *saveFilePtr(u16 flagIndex) {
-        u32 offset = (flagIndex & 0x1fff) * 8;
-        return FileManager::sInstance->getDungeonFlagsConst() + offset;
-    }
-};
-
-/** 80575404 */
-// DungeonflagManager *DungeonflagManager::sInstance = nullptr;
-
-/** 805a9c58 */
-u16 DungeonflagManager::sDungeonFlags[8] = {};
-
-/** 800bf8d0 */
-void DungeonflagManager::copyFromSave(u16 flagIndex) {
-    mFlagSpace.copyFromSaveFile(saveFilePtr(flagIndex), 0, 0x8);
-}
-
-/** 800bf930 */
-void DungeonflagManager::setCommitFlag(u16 flag) {
-    mShouldCommit = true;
-}
-
-/** 0x800bf940 */
-DungeonflagManager::DungeonflagManager()
-    : mShouldCommit(false), mStageIndex(-1), mFlagStuff(nullptr),
-      mFlagSpace(sDungeonFlags, ARRAY_LENGTH(sDungeonFlags)) {}
-
-/** 800bf980 */
-void DungeonflagManager::setupFlagStuff() {
-    mFlagStuff = new UnkFlagStuff(0x11, DungeonflagManager__FLAG_DEFINITIONS);
-    mShouldCommit = false;
-}
-
-/** 800bf9e0 */
-void DungeonflagManager::copyFromSave(s16 flag) {
-    mStageIndex = flag;
-    copyFromSave((u16)flag);
-}
-
-/** 800bf9f0 */
-void DungeonflagManager::setToValue(u16 flag, u32 value) {
-    u16 *data = mFlagSpace.getFlagPtrChecked();
-    mFlagStuff->setCounterOrFlag(flag, data, 8, value);
-    setCommitFlag(flag);
-}
-
-/** 800bfa60 */
-void DungeonflagManager::setFlag(u16 flag) {
-    u16 *data = mFlagSpace.getFlagPtrChecked();
-    mFlagStuff->setCounterOrFlag(flag, data, 8, 1);
-    setCommitFlag(flag);
-}
-
-/** 800fbac0 */
-u32 DungeonflagManager::getDungeonFlag(u16 flag) {
-    u16 *data = mFlagSpace.getFlagPtrUnchecked();
-    return mFlagStuff->getCounterOrFlag(flag, data, 8);
-}
-
-/** 800fbb10 */
-bool DungeonflagManager::doCommit() {
-    FileManager *instance;
-    u16 idx = mStageIndex;
-    if (idx == 0xFFFF) {
-        return false;
-    } else if (mShouldCommit) {
-        instance = FileManager::sInstance;
-        u16 *ptr = mFlagSpace.getFlagPtrUnchecked();
-        instance->setDungeonFlags(ptr, (idx & 0x1fff) * 8, 0x08);
-        mShouldCommit = false;
-        return true;
-    }
-    return false;
-}

src/toBeSorted/file_manager.cpp

@@ -80,7 +80,7 @@ u16 *FileManager::getStoryFlagsMut() {
     return getCurrentFile()->getStoryFlags1();
 }
 /* 8000A3B0 */ u16 *FileManager::getItemFlagsMut() {}
-/* 8000A3E0 */ u16 *FileManager::getItemFlagsConst() {}
+/* 8000A3E0 */ const u16 *FileManager::getItemFlagsConst() {}
 /* 8000A430 */ u16 *FileManager::getDungeonFlagsMut() {}
 /* 8000A460 */ u16 *FileManager::getDungeonFlagsConst() {}
 /* 8000A4B0 */ u16 *FileManager::getSceneFlagsMut() {}
@@ -234,7 +234,7 @@ u16 *FileManager::getStoryFlagsMut() {
 /* 8000CAD0 */ bool FileManager::isNew_FileA() {}
 
 /* 8000CB00 */ void FileManager::setSceneFlagIndex(u16 idx) {}
-/* 8000CB30 */ u16 FileManager::getSceneFlagIndex() {}
+/* 8000CB30 */ u32 FileManager::getSceneFlagIndex() {}
 /* 8000CB80 */ s32 FileManager::getFileAreaIndex() {}
 
 /* 8000CBD0 */ void FileManager::fn_8000CBD0(u8) {}

src/toBeSorted/flag_space.cpp

@@ -1,34 +0,0 @@
-#include "toBeSorted/flag_space.h"
-
-#include "common.h"
-#include "libc.h"
-#include "toBeSorted/file_manager.h"
-
-u16 *FlagSpace::getFlagPtrChecked() {
-    filemanagerCheck();
-    return mpFlags;
-}
-u16 *FlagSpace::getFlagPtrUnchecked() {
-    return mpFlags;
-}
-void FlagSpace::unsetAll() {
-    setAllToZero(0, mCount);
-}
-void FlagSpace::setAllToZero(u16 offset, u16 flagCount) {
-    filemanagerCheck();
-    memset(mpFlags + offset, 0, (u16)(flagCount * 2));
-}
-void FlagSpace::copyFromSaveFile2(u16 *pSaved, u16 offset, u16 flagCount) {
-    filemanagerCheck();
-    checkedMemcpy(mpFlags + offset, mCount * 2, pSaved, flagCount * 2);
-}
-
-void FlagSpace::copyFromSaveFile(u16 *pSaved, u16 offset, u16 flagCount) {
-    checkedMemcpy(mpFlags + offset, mCount * 2, pSaved, flagCount * 2);
-}
-void FlagSpace::filemanagerCheck() {
-    if (FileManager::sInstance->mIsFileUnk1[0]) {
-        return;
-    }
-    while (true) {}
-}

src/toBeSorted/misc_flag_managers.cpp

@@ -1,151 +0,0 @@
-#include "toBeSorted/misc_flag_managers.h"
-
-#include "common.h"
-#include "libc.h"
-#include "toBeSorted/bitwise_flag_helper.h"
-#include "toBeSorted/file_manager.h"
-#include "toBeSorted/flag_space.h"
-
-
-/* 0x800BE7B0 */
-bool CommittableFlagManager::commitIfNecessary() {
-    if (mNeedsCommit) {
-        doCommit();
-        mNeedsCommit = false;
-        return true;
-    } else {
-        return false;
-    }
-}
-
-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);
-}
-
-/* 0x800BE8E0 */
-TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(sTBoxFlags, ARRAY_LENGTH(sTBoxFlags)) {
-    mSceneIndex = 0xFFFF;
-}
-
-/* 0x800BE920 */
-void TBoxFlagManager::init() {}
-
-/* 0x800BE930 */
-void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
-    u16 idx = sceneIndex;
-    mSceneIndex = idx;
-    u16 *flags = FileManager::getInstance()->getTBoxFlagsConst();
-    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);
-        setNeedsCommit(true);
-    }
-}
-
-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);
-    } else {
-        return false;
-    }
-}
-
-/* 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;
-    u16 *flags = FileManager::getInstance()->getEnemyDefeatFlagsConst();
-    mFlagSpace.copyFromSaveFile(flags, 0, count);
-}
-
-/* 0x800BEC30 */
-void EnemyDefeatManager::updateFlagIndex(u16 sceneIndex) {
-    if (mSceneIndex == sceneIndex) {
-        return;
-    }
-    mSceneIndex = 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;
-    } else {
-        u16 *pData = FileManager::getInstance()->getEnemyDefeatFlagsConst();
-        return mFlagHelper.checkFlag(flag / 16, flag % 16, pData, getFlagCount());
-    }
-}
-
-/* 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);
-        setNeedsCommit(true);
-    }
-}