Merge pull request #65 from robojumper/flag_mgrs

flag_managers OK

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

@@ -0,0 +1,13 @@
+#include "d/flag/bitwise_flag_helper.h"
+
+#include "common.h"
+
+bool BitwiseFlagHelper::checkFlag(u16 slot, u16 shift, const u16 *pData, u16 flagCount) {
+    return (pData[slot] >> shift) & 1;
+}
+void BitwiseFlagHelper::setFlag(u16 slot, u16 shift, u16 *pData, u16 flagCount) {
+    pData[slot] |= (1 << shift);
+}
+void BitwiseFlagHelper::unsetFlag(u16 slot, u16 shift, u16 *pData, u16 flagCount) {
+    pData[slot] &= ~(1 << shift);
+}

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

@@ -0,0 +1,53 @@
+#include "d/flag/flag_index.h"
+
+u16 FlagIndex::calculateMask(s32 shift) {
+    return (2 << (shift & 0xF)) - 1;
+}
+
+void FlagIndex::doNothing(u32 unused) {}
+
+FlagIndex::FlagIndex(u16 count, FlagDefinition *definitions) {
+    this->mDefinitionsCount = count;
+    this->mpDefinitions = definitions;
+}
+
+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 FlagIndex::maskForIdx(u16 index, u16 flagCount) {
+    doNothing(index);
+
+    return calculateMask(mpDefinitions[index].mShiftMask);
+}
+
+u16 FlagIndex::getCounterOrFlag(u16 counterIdx, const u16 *dataPtr, u32 param4) {
+    u16 index = 0;
+    u8 shift = 0;
+    u16 mask = 0;
+    prepareIndexShiftMask(counterIdx, param4, &index, &shift, &mask);
+    return mask & (dataPtr[index] >> shift);
+}
+
+void FlagIndex::setCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 flagCount, u32 value) {
+    u16 index = 0;
+    u8 shift = 0;
+    u16 mask = 0;
+    prepareIndexShiftMask(counterIdx, flagCount, &index, &shift, &mask);
+    dataPtr[index] &= ~(mask << shift);
+    dataPtr[index] = (u16)(value << shift) | dataPtr[index];
+}
+
+u32 FlagIndex::checkFlagValid(u16 counterIdx, u32 flagCount) {
+    if (mpDefinitions == nullptr) {
+        return 0;
+    }
+    if (mDefinitionsCount <= counterIdx || mpDefinitions[counterIdx].mIndex == 0xFF) {
+        return 0;
+    } else {
+        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

@@ -0,0 +1,263 @@
+#include "common.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::init() {}
+void SceneflagManager::setShouldCommit(u16 flag) {
+    mShouldCommit = 1;
+}
+SceneflagManager::SceneflagManager()
+    : mSceneflags(sSceneFlags, ARRAY_LENGTH(sSceneFlags)), mTempflags(sTempFlags, ARRAY_LENGTH(sTempFlags)),
+      mZoneflags(sZoneFlags, ARRAY_LENGTH(sZoneFlags)) {
+    mSceneIdx = 0xFFFF;
+    mShouldCommit = 0;
+}
+
+s32 SceneflagManager::isNotTempOrZoneFlag(u16 flag) {
+    // return ((s32)flag - 0x80) < 0;
+    return flag < 0x80;
+}
+
+inline s32 possiblyZoneFlag(u32 flag) {
+    return flag >= 0xC0;
+}
+
+s32 SceneflagManager::isZoneFlag(u32 flag) {
+    if (possiblyZoneFlag(flag) && flag < 0x100) {
+        return 1;
+    } else {
+        return 0;
+    }
+    // return flag >= 0xC0 && flag < 0x100;
+}
+void SceneflagManager::updateFlagindex(u16 sceneIdx) {
+    if (sceneIdx != mSceneIdx) {
+        mSceneIdx = sceneIdx;
+        mSceneflags.copyFromSaveFile2(FileManager::sInstance->getSceneFlagsConst() + sceneIdx * 8, 0, 8);
+        unsetZoneAndTempflags();
+    }
+}
+void SceneflagManager::copyFromSave(u32 sceneIdx) {
+    // sceneIdx &= 0xFFFF;
+    u16 sceneIdx2 = sceneIdx;
+    // missing clrlwi, more inlines?
+    mSceneIdx = sceneIdx2;
+    mSceneflags.copyFromSaveFile2(FileManager::getInstance()->getSceneFlagsConst() + sceneIdx2 * 8, 0, 8);
+    mTempflags.copyFromSaveFile(FileManager::getInstance()->getTempFlagsConst(), 0, mTempflags.mCount);
+    mZoneflags.copyFromSaveFile(FileManager::getInstance()->getZoneFlagsConst(), 0, mZoneflags.mCount);
+}
+void SceneflagManager::unsetAllTempflags() {
+    u16 flags[4];
+    memset(flags, 0, sizeof(flags));
+    FileManager::sInstance->setTempFlags(flags, 0, 4);
+}
+void SceneflagManager::zoneflagsResetAll() {
+    u16 flags[0xFC];
+    memset(flags, 0, sizeof(flags));
+    FileManager::sInstance->setZoneFlags(flags, 0, 0xFC);
+}
+void SceneflagManager::zoneflagsResetForRoom(u16 roomId) {
+    u16 flags[4];
+    memset(flags, 0, sizeof(flags));
+    // ? weird mask
+    FileManager::sInstance->setZoneFlags(flags, (roomId & 0x3FF) * 4, 4);
+}
+void SceneflagManager::unsetZoneAndTempflags() {
+    unsetAllTempflags();
+    mTempflags.unsetAll();
+    unsetAllZoneflags();
+}
+void SceneflagManager::unsetAllZoneflags() {
+    zoneflagsResetAll();
+    mZoneflags.unsetAll();
+}
+void SceneflagManager::unsetZoneflagsForRoom(u16 roomId) {
+    zoneflagsResetForRoom(roomId);
+    // ? weird mask
+    mZoneflags.setAllToZero((roomId & 0x3FF) * 4, 4);
+}
+u16 SceneflagManager::getZoneflagSlot(u16 roomId, u16 flag) {
+    return (flag + roomId * 0x40) >> 4 & 0xFFF;
+}
+u16 SceneflagManager::getSceneflagSlotGlobal(u16 sceneIdx, u16 flag) {
+    return (flag + sceneIdx * 0x80) >> 4 & 0xFFF;
+}
+u16 SceneflagManager::getSceneflagSlot(u16 flag) {
+    return flag >> 4 & 0xFFF;
+}
+u16 SceneflagManager::getTempflagSlot(u16 flag) {
+    return flag >> 4 & 0xFFF;
+}
+bool SceneflagManager::checkZoneFlag(u16 roomId, u16 flag) {
+    if (flag == 0xFF) {
+        return false;
+    } else {
+        u16 zoneflag = flag - 0xC0;
+        u16 *pData = FileManager::sInstance->getZoneFlagsConst();
+        u16 slot = getZoneflagSlot(roomId, zoneflag);
+        return mFlagHelper.checkFlag(slot, zoneflag % 16, pData, 0xFC);
+    }
+}
+bool SceneflagManager::checkUncommittedZoneflag(u16 roomId, u16 flag) {
+    if (flag == 0xFF) {
+        return false;
+    } else {
+        u16 *pData;
+        u16 zoneflag = flag - 0xC0;
+        pData = mZoneflags.getFlagPtrUnchecked();
+        u16 slot = getZoneflagSlot(roomId, zoneflag);
+        return mFlagHelper.checkFlag(slot, zoneflag % 16, pData, mZoneflags.mCount);
+    }
+}
+inline bool checkSceneflag(SceneflagManager *mgr, u16 flag) {
+    u16 *pData;
+    pData = mgr->mSceneflags.getFlagPtrUnchecked();
+    // u16 slot = getSceneflagSlot2(flag);
+    return mgr->mFlagHelper.checkFlag(mgr->getSceneflagSlot(flag), flag % 16, pData, mgr->mSceneflags.mCount);
+}
+bool SceneflagManager::checkUncommittedTempOrSceneflag(u16 flag) {
+    if (flag >= 0x80) {
+        u16 *pData;
+        u16 tempflag = flag - 0x80;
+        pData = mTempflags.getFlagPtrUnchecked();
+        u16 slot = getTempflagSlot(tempflag);
+        return mFlagHelper.checkFlag(slot, tempflag % 16, pData, mTempflags.mCount);
+    } else {
+        return ::checkSceneflag(this, flag);
+        // u16* pData;
+        // pData = mSceneflags.getFlagPtr();
+        // // u16 slot = getSceneflagSlot2(flag);
+        // mFlagHelper.checkFlag(getSceneflagSlot2(flag), flag % 16, pData, mSceneflags.mCount);
+    }
+}
+u16 SceneflagManager::checkFlag(u16 roomId, u16 flag) {
+    if (isZoneFlag(flag)) {
+        return checkZoneFlag(roomId, flag);
+    } else {
+        return checkTempOrSceneflag(flag);
+    }
+}
+bool SceneflagManager::checkSceneflagGlobal(u16 sceneIdx, u16 flag) {
+    u16 *pData = FileManager::sInstance->getSceneFlagsConst();
+    return mFlagHelper.checkFlag(getSceneflagSlotGlobal(sceneIdx, flag), flag % 16, pData, 0x800);
+}
+bool SceneflagManager::checkTempOrSceneflag(u16 flag) {
+    if (flag >= 0x80) {
+        u16 tempflag = flag - 0x80;
+        const u16 *pData = FileManager::sInstance->getTempFlagsConst();
+        u16 slot = getTempflagSlot(tempflag);
+        return mFlagHelper.checkFlag(slot, tempflag % 16, pData, 4);
+    } else {
+        return checkSceneflagGlobal(mSceneIdx, flag);
+    }
+}
+u16 SceneflagManager::checkUncommittedFlag(u16 roomId, u16 flag) {
+    if (isZoneFlag(flag)) {
+        return checkUncommittedZoneflag(roomId, flag);
+    } else {
+        return checkUncommittedTempOrSceneflag(flag);
+    }
+}
+void SceneflagManager::setZoneflag(u16 roomId, u16 flag) {
+    if (checkUncommittedZoneflag2(roomId, flag) != 1 && flag != 0xFF) {
+        u16 *pData;
+        u16 zoneflag = flag - 0xC0;
+        pData = mZoneflags.getFlagPtrChecked();
+        u16 slot = getZoneflagSlot(roomId, zoneflag);
+        mFlagHelper.setFlag(slot, zoneflag % 16, pData, mZoneflags.mCount);
+        setShouldCommit(flag);
+    }
+}
+void SceneflagManager::setFlag(u16 roomId, u16 flag) {
+    if (isZoneFlag(flag)) {
+        setZoneflag(roomId, flag);
+    } else {
+        setTempOrSceneflag(flag);
+    }
+}
+void SceneflagManager::setSceneflagGlobal(u16 sceneIdx, u16 flag) {
+    u16 slot = getSceneflagSlotGlobal(sceneIdx, flag);
+    u16 *pData = FileManager::sInstance->getSceneFlagsConst();
+    u16 pCurData = pData[slot];
+    mFlagHelper.setFlag(0, flag % 16, &pCurData, 2);
+    FileManager::sInstance->setSceneFlags(&pCurData, slot, 1);
+    if (sceneIdx == mSceneIdx) {
+        u16 *pData2 = mSceneflags.getFlagPtrChecked();
+        mFlagHelper.setFlag(getSceneflagSlot(flag), flag % 16, pData2, mSceneflags.mCount);
+    }
+    setShouldCommit(flag);
+}
+void SceneflagManager::setTempOrSceneflag(u16 flag) {
+    if (checkUncommittedTempOrSceneflag2(flag) != 1) {
+        u16 *pData;
+        if (flag >= 0x80) {
+            u16 tempflag = flag - 0x80;
+            pData = mTempflags.getFlagPtrChecked();
+            mFlagHelper.setFlag(getTempflagSlot(tempflag), tempflag % 16, pData, mTempflags.mCount);
+        } else {
+            pData = mSceneflags.getFlagPtrChecked();
+            mFlagHelper.setFlag(getSceneflagSlot(flag), flag % 16, pData, mSceneflags.mCount);
+        }
+        setShouldCommit(flag);
+    }
+}
+void SceneflagManager::unsetZoneflag(u16 roomId, u16 flag) {
+    if (checkUncommittedZoneflag2(roomId, flag) != 0 && flag != 0xFF) {
+        u16 *pData;
+        u16 zoneflag = flag - 0xC0;
+        pData = mZoneflags.getFlagPtrChecked();
+        u16 slot = getZoneflagSlot(roomId, zoneflag);
+        mFlagHelper.unsetFlag(slot, zoneflag % 16, pData, mZoneflags.mCount);
+        setShouldCommit(flag);
+    }
+}
+void SceneflagManager::unsetFlag(u16 roomId, u16 flag) {
+    if (isZoneFlag(flag)) {
+        unsetZoneflag(roomId, flag);
+    } else {
+        unsetTempOrSceneflag(flag);
+    }
+}
+void SceneflagManager::unsetSceneflagGlobal(u16 sceneIdx, u16 flag) {
+    u16 slot = getSceneflagSlotGlobal(sceneIdx, flag);
+    u16 *pData = FileManager::sInstance->getSceneFlagsConst();
+    u16 pCurData = pData[slot];
+    mFlagHelper.unsetFlag(0, flag % 16, &pCurData, 2);
+    FileManager::sInstance->setSceneFlags(&pCurData, slot, 1);
+    if (sceneIdx == mSceneIdx) {
+        u16 *pData2 = mSceneflags.getFlagPtrChecked();
+        mFlagHelper.unsetFlag(getSceneflagSlot(flag), flag % 16, pData2, mSceneflags.mCount);
+    }
+    setShouldCommit(flag);
+}
+void SceneflagManager::unsetTempOrSceneflag(u16 flag) {
+    if (checkUncommittedTempOrSceneflag2(flag) != 0) {
+        u16 *pData;
+        if (flag >= 0x80) {
+            u16 tempflag = flag - 0x80;
+            pData = mTempflags.getFlagPtrChecked();
+            mFlagHelper.unsetFlag(getTempflagSlot(tempflag), tempflag % 16, pData, mTempflags.mCount);
+        } else {
+            pData = mSceneflags.getFlagPtrChecked();
+            mFlagHelper.unsetFlag(getSceneflagSlot(flag), flag % 16, pData, mSceneflags.mCount);
+        }
+        setShouldCommit(flag);
+    }
+}
+s32 SceneflagManager::commit() {
+    if (mSceneIdx == 0xFFFF) {
+        return 0;
+    } else if (mShouldCommit) {
+        FileManager::getInstance()->setSceneFlags(mSceneflags.getFlagPtrUnchecked(), mSceneIdx * 8, 8);
+        FileManager::getInstance()->setTempFlags(mTempflags.getFlagPtrUnchecked(), 0, mTempflags.mCount);
+        FileManager::getInstance()->setZoneFlags(mZoneflags.getFlagPtrUnchecked(), 0, mZoneflags.mCount);
+        mShouldCommit = false;
+        return 1;
+    }
+    return 0;
+}

src/d/flag/skipflag_manager.inc

@@ -0,0 +1,64 @@
+#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"
+
+// 0x80575408
+SkipflagManager *SkipflagManager::sInstance = nullptr;
+// 0x805A9C68
+u16 SkipflagManager::sSkipFlags[16] = {};
+
+// 800bfba0
+void SkipflagManager::doCopyFromSave() {
+    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::init() {
+    mShouldCommit = false;
+}
+
+// 800bfc40
+void SkipflagManager::copyFromSave() {
+    doCopyFromSave();
+}
+
+// 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::commit() {
+    if (mShouldCommit) {
+        FileManager *instance = FileManager::sInstance;
+        instance->setSkipFlagsChecked(mFlagSpace.getFlagPtrUnchecked(), 0, 0x10);
+        mShouldCommit = false;
+        return true;
+    }
+    return false;
+}

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"