Flag managers WIP, broken after rebase

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_managers/dungeonflag_manager.inc

@@ -25,7 +25,7 @@ public:
     void setupFlagStuff();
     void setToValue(u16 flag, u32 value);
     void setFlag(u16 flag);
-    u32 getDungeonFlag(u16 flag);
+    u16 getDungeonFlag(u16 flag);
     bool doCommit();
 
     /** inline shenanigans to get copyFromSave to match */
@@ -33,6 +33,8 @@ public:
         u32 offset = (flagIndex & 0x1fff) * 8;
         return FileManager::sInstance->getDungeonFlagsConst() + offset;
     }
+
+    static DungeonflagManager *sInstance;
 };
 
 /** 80575404 */
@@ -83,7 +85,7 @@ void DungeonflagManager::setFlag(u16 flag) {
 }
 
 /** 800fbac0 */
-u32 DungeonflagManager::getDungeonFlag(u16 flag) {
+u16 DungeonflagManager::getDungeonFlag(u16 flag) {
     u16 *data = mFlagSpace.getFlagPtrUnchecked();
     return mFlagStuff->getCounterOrFlag(flag, data, 8);
 }

src/toBeSorted/flag_managers/flag_managers.cpp

@@ -0,0 +1,289 @@
+// clang-format off
+
+#include <toBeSorted/flag_space.h>
+#include <toBeSorted/misc_flag_managers.h>
+#include <toBeSorted/item_story_flag_manager.h>
+
+#include <toBeSorted/flag_managers/sceneflag_manager.inc>
+#include <toBeSorted/item_story_flag_manager.h>
+#include <toBeSorted/flag_managers/misc_flag_managers.inc>
+#include <toBeSorted/flag_managers/flag_space.inc>
+#include <toBeSorted/flag_managers/unk_flag_stuff.inc>
+#include <toBeSorted/flag_managers/bitwise_flag_helper.inc>
+
+
+ItemStoryManagerBase::ItemStoryManagerBase(): flagSizeMaybe(0), anotherSizeMaybe(0), storyFlagsPtr(nullptr), unkFlagsPtr(nullptr), dirty(false) {}
+ItemStoryManagerBase::~ItemStoryManagerBase() {
+    if (unkFlagsPtr != nullptr) {
+        delete unkFlagsPtr;
+    }
+}
+
+void ItemStoryManagerBase::setFlagSizes(u16 flagSizeMaybe, u16 anotherFlagSizeMaybe) {
+    this->flagSizeMaybe = flagSizeMaybe;
+    this->anotherSizeMaybe = anotherFlagSizeMaybe;
+}
+
+/** 800bf320 */
+void ItemStoryManagerBase::setupUnkFlagStuff(UnkFlagDefinition *def, u16 count) {
+    UnkFlagStuff *stuff = new UnkFlagStuff(count, def);
+    this->unkFlagsPtr = stuff;
+}
+
+/** 800bf380 */
+void ItemStoryManagerBase::copyFlagsFromSave_Priv() {
+    FlagSpace *current = this->storyFlagsPtr;
+    const u16 *saved = this->getSaveFlagSpace();
+    current->copyFromSaveFile(saved, 0, this->flagSizeMaybe);
+}
+
+/** 800bf3e0 */
+void ItemStoryManagerBase::init() {
+    const u16 *space = this->getSaveFlagSpace();
+    if (space == nullptr || this->unkFlagsPtr == nullptr) {
+        this->setFlagszptr();
+        this->copyFlagsFromSave();
+        this->setupUnkFlagsStuff();
+    }
+}
+
+/** 800bf470 */
+void ItemStoryManagerBase::setFlagszptr() {
+
+}
+
+/** 800bf480 */
+u16 ItemStoryManagerBase::getCounterOrFlag(u16 flag) const {
+    const u16 *data = this->getSaveFlagSpace();
+    return this->unkFlagsPtr->getCounterOrFlag(flag, data, this->flagSizeMaybe);
+}
+
+/** 800bf4e0 */
+u16 ItemStoryManagerBase::getUncommittedValue_Priv(u16 flag) {
+    u16 *data = this->storyFlagsPtr->getFlagPtrUnchecked();
+    return this->unkFlagsPtr->getCounterOrFlag(flag, data, this->flagSizeMaybe);
+}
+
+/** 800bf530 */
+void ItemStoryManagerBase::setOrClearFlag(u16 flag, u16 value) {
+    FlagSpace *storyFlagsPtr = this->storyFlagsPtr;
+    u16 *pData = storyFlagsPtr->getFlagPtrChecked();
+    this->unkFlagsPtr->setCounterOrFlag(flag, pData, storyFlagsPtr->mCount, value);
+    this->FUN_800bf610(flag);
+}
+
+/** 800bf5b0 */
+void ItemStoryManagerBase::setFlag(u16 flag) {
+    this->setOrClearFlag(flag, true);
+}
+
+/** 800bf5c0 */
+void ItemStoryManagerBase::unsetFlag(u16 flag) {
+    this->setOrClearFlag(flag, false);
+}
+
+/** 800bf5d0 */
+void ItemStoryManagerBase::thunk_setOrClearFlag(u16 flag, u16 value) {
+    this->setOrClearFlag(flag, value);
+}
+
+/** 800bf5e0 */
+u16 ItemStoryManagerBase::getFlag(u16 flag) const {
+    return ItemStoryManagerBase::getCounterOrFlag(flag);
+}
+
+/** 800bf5f0 */
+u16 ItemStoryManagerBase::getUncommittedValue(u16 flag) {
+    return this->getUncommittedValue_Priv(flag);
+}
+
+/** 800bf600 */
+u16 ItemStoryManagerBase::FUN_800bf600(u16 flag) {
+    return this->FUN_800bf640(flag);
+}
+
+/** 800bf610 */
+void ItemStoryManagerBase::FUN_800bf610(u16 flag) {
+    this->dirty = true;
+    this->onDirty();
+}
+
+/** 800bf630 */
+void ItemStoryManagerBase::onDirty() {
+
+}
+
+/** 800bf640 */
+u16 ItemStoryManagerBase::FUN_800bf640(u16 flag) {
+    return this->unkFlagsPtr->maskForIdx(flag, this->flagSizeMaybe);
+}
+
+/** 800bf650 */
+void ItemStoryManagerBase::doCommit_Priv() {
+    this->doCommit();
+    this->dirty = false;
+}
+
+/* 800bf690 */
+void ItemStoryManagerBase::FUN_800bf690() {
+
+}
+
+StoryflagManager::StoryflagManager() : storyFlags(sFlags, 0x80) {
+
+}
+
+void StoryflagManager::copyFlagsFromSave() {
+    setFlagSizes(0x80, 0x100);
+    copyFlagsFromSave_Priv();
+}
+
+extern "C" UnkFlagDefinition StoryflagManager__STORYFLAG_DEFINITIONS[];
+
+void StoryflagManager::setupUnkFlagsStuff() {
+    setupUnkFlagStuff(StoryflagManager__STORYFLAG_DEFINITIONS, 0x4B1);
+}
+
+void StoryflagManager::onDirty() {
+
+}
+
+bool StoryflagManager::commit() {
+    if (dirty) {
+        doCommit_Priv();
+        FUN_800bf690();
+        return true;
+    }
+    return false;
+}
+
+void StoryflagManager::unsetFlag(u16 flag) {
+    ItemStoryManagerBase::unsetFlag(flag);
+}
+
+ItemflagManager::ItemflagManager() : itemFlags(sFlags, 0x40) {}
+
+void ItemflagManager::copyFlagsFromSave() {
+    setFlagSizes(0x40, 0x80);
+    copyFlagsFromSave_Priv();
+}
+
+extern "C" UnkFlagDefinition ItemflagManager__ITEMFLAG_DEFINITIONS[];
+
+void ItemflagManager::setupUnkFlagsStuff() {
+    setupUnkFlagStuff(ItemflagManager__ITEMFLAG_DEFINITIONS, 0x1FE);
+}
+
+void ItemflagManager::onDirty() {
+
+}
+
+bool ItemflagManager::commit() {
+    if (dirty) {
+        doCommit_Priv();
+        FUN_800bf690();
+        return true;
+    }
+    return false;
+}
+
+#include <toBeSorted/flag_managers/dungeonflag_manager.inc>
+#include <toBeSorted/flag_managers/skipflag_manager.inc>
+// clang-format on
+
+#include <egg/core/eggHeap.h>
+#include <m/m_heap.h>
+
+static void postSetup();
+static void updateFlagForFlagIndex(u16 stage);
+class TBoxFlagManagerSub : public TBoxFlagManager {
+    // virtual ~TBoxFlagManagerSub() {}
+};
+
+class EnemyDefeatManagerSub : public EnemyDefeatManager {
+    // virtual ~EnemyDefeatManagerSub() {}
+};
+
+
+class StoryflagManagerSub : public StoryflagManager {
+    // virtual ~StoryflagManagerSub() {}
+};
+
+class ItemflagManagerSub : public ItemflagManager {
+    // virtual ~ItemflagManagerSub() {}
+};
+
+
+
+
+void setupFlagManagers(EGG::Heap *heap) {
+    if (SceneflagManager::sInstance == nullptr) {
+        SceneflagManager::sInstance = new (heap) SceneflagManager();
+        mHeap m(heap);
+        SceneflagManager::sInstance->doNothing();
+    }
+
+    if (TBoxFlagManager::sInstance == nullptr) {
+        TBoxFlagManager::sInstance = new (heap) TBoxFlagManagerSub();
+        mHeap m(heap);
+        TBoxFlagManager::sInstance->init();
+    }
+
+    if (EnemyDefeatManager::sInstance == nullptr) {
+        EnemyDefeatManager::sInstance = new (heap) EnemyDefeatManagerSub();
+        mHeap m(heap);
+        EnemyDefeatManager::sInstance->init();
+    }
+
+    if (StoryflagManager::sInstance == nullptr) {
+        StoryflagManager::sInstance = new (heap) StoryflagManagerSub();
+        mHeap m(heap);
+        StoryflagManager::sInstance->init();
+    }
+
+    if (ItemflagManager::sInstance == nullptr) {
+        ItemflagManager::sInstance = new (heap) ItemflagManagerSub();
+        mHeap m(heap);
+        ItemflagManager::sInstance->init();
+    }
+
+    if (DungeonflagManager::sInstance == nullptr) {
+        DungeonflagManager::sInstance = new (heap) DungeonflagManager();
+        mHeap m(heap);
+        DungeonflagManager::sInstance->setupFlagStuff();
+    }
+
+    if (SkipflagManager::sInstance == nullptr) {
+        SkipflagManager::sInstance = new (heap) SkipflagManager();
+        mHeap m(heap);
+        SkipflagManager::sInstance->unsetCommitFlag();
+    }
+
+    postSetup();
+}
+
+static void postSetup() {
+    updateFlagForFlagIndex(0);
+}
+
+void copyAllFlagManagersFromSave() {
+    u16 flag = FileManager::sInstance->getSceneFlagIndex();
+    SceneflagManager::sInstance->copyFromSave(flag);
+    TBoxFlagManager::sInstance->copyFromSave(flag);
+    StoryflagManager::sInstance->copyFlagsFromSave_Priv();
+    ItemflagManager::sInstance->copyFlagsFromSave_Priv();
+    DungeonflagManager::sInstance->copyFromSave(flag);
+    SkipflagManager::sInstance->copyFromSave();
+    EnemyDefeatManager::sInstance->copyFromSave(flag);
+}
+
+static void updateFlagForFlagIndex(u16 stage) {}
+
+extern "C" 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/toBeSorted/flag_managers/flag_space.inc

@@ -0,0 +1,34 @@
+#include "toBeSorted/flag_space.h"
+#include "toBeSorted/file_manager.h"
+#include <common.h>
+
+extern "C" bool checkedMemcpy(void *dest, u32 destLen, const void *src, u32 count);
+
+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/toBeSorted/flag_managers/misc_flag_managers.inc

@@ -42,7 +42,7 @@ TBoxFlagManager::TBoxFlagManager() : CommittableFlagManager(false), mFlagSpace(s
 void TBoxFlagManager::init() {}
 
 /* 0x800BE930 */
-void TBoxFlagManager::copyFromSave(s16 sceneIndex) {
+void TBoxFlagManager::copyFromSave(u32 sceneIndex) {
     u16 idx = sceneIndex;
     mSceneIndex = idx;
     u16 *flags = FileManager::getInstance()->getTBoxFlagsConst();

src/toBeSorted/flag_managers/skipflag_manager.inc

@@ -1,8 +1,10 @@
-#include "libc.h"
+#include "common.h"
 #include "toBeSorted/bitwise_flag_helper.h"
 #include "toBeSorted/file_manager.h"
 #include "toBeSorted/flag_space.h"
 
+extern "C" bool checkedMemcpy(void *dest, u32 destLen, const void *src, u32 count);
+
 class SkipflagManager {
 public:
     bool mShouldCommit;

src/toBeSorted/flag_managers/unk_flag_stuff.inc

@@ -18,13 +18,13 @@ void UnkFlagStuff::prepareIndexShiftMask(u16 counterIdx, u32 unused, u16 *indexP
     *maskPtr = calculateMask(mpDefinitions[counterIdx].mShiftMask);
 }
 
-u16 UnkFlagStuff::maskForIdx(u16 index) {
+u16 UnkFlagStuff::maskForIdx(u16 index, u16 flagSizeMaybe) {
     doNothing(index);
 
     return calculateMask(mpDefinitions[index].mShiftMask);
 }
 
-u32 UnkFlagStuff::getCounterOrFlag(u16 counterIdx, u16 *dataPtr, u32 param4) {
+u16 UnkFlagStuff::getCounterOrFlag(u16 counterIdx, const u16 *dataPtr, u32 param4) {
     u16 index = 0;
     u8 shift = 0;
     u16 mask = 0;

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) {}
-}