Merge pull request #10 from CovenEsme/flag-mgr-experimenting

misc_flag_managers and skipflag_manager

config/SOUE01/splits.txt

@@ -108,6 +108,9 @@ toBeSorted/sceneflag_manager.cpp:
 
 toBeSorted/misc_flag_managers.cpp:
 	.text       start:0x800BE7B0 end:0x800BEE00
+	.data       start:0x80510CDC end:0x80510D04
+	.sbss       start:0x805753F0 end:0x805753FC
+	.bss        start:0x805A7AD8 end:0x805A9AD8
 
 toBeSorted/flag_space.cpp:
 	.text       start:0x800BEE00 end:0x800BEF90
@@ -119,6 +122,11 @@ toBeSorted/unk_flag_stuff.cpp:
 toBeSorted/bitwise_flag_helper.cpp:
 	.text       start:0x800BF200 end:0x800BF264
 
+toBeSorted/skipflag_manager.cpp:
+	.text       start:0x800BFBA0 end:0x800BFE00
+	.sbss       start:0x80575408 end:0x8057540C
+	.bss        start:0x805A9C68 end:0x805A9C88
+
 c/c_list.cpp:
 	.text       start:0x802E08C0 end:0x802E0A10
 

config/SOUE01/symbols.txt

@@ -4106,7 +4106,7 @@ doCommit__15TBoxFlagManagerFv = .text:0x800BE810; // type:function size:0x58
 checkUncommittedFlag__15TBoxFlagManagerFUs = .text:0x800BE870; // type:function size:0x68
 __ct__15TBoxFlagManagerFv = .text:0x800BE8E0; // type:function size:0x40
 init__15TBoxFlagManagerFv = .text:0x800BE920; // type:function size:0x4
-copyFromSave__15TBoxFlagManagerFUs = .text:0x800BE930; // type:function size:0x5C
+copyFromSave__15TBoxFlagManagerFs = .text:0x800BE930; // type:function size:0x5C
 checkFlag__15TBoxFlagManagerFUsUs = .text:0x800BE990; // type:function size:0x94
 getFlagCount__15TBoxFlagManagerCFv = .text:0x800BEA30; // type:function size:0x8
 setFlag__15TBoxFlagManagerFUs = .text:0x800BEA40; // type:function size:0x80
@@ -4180,17 +4180,17 @@ fn_800BF9F0 = .text:0x800BF9F0; // type:function size:0x6C
 fn_800BFA60 = .text:0x800BFA60; // type:function size:0x60
 fn_800BFAC0 = .text:0x800BFAC0; // type:function size:0x50
 fn_800BFB10 = .text:0x800BFB10; // type:function size:0x8C
-fn_800BFBA0 = .text:0x800BFBA0; // type:function size:0x44
-fn_800BFBF0 = .text:0x800BFBF0; // type:function size:0xC
-fn_800BFC00 = .text:0x800BFC00; // type:function size:0x2C
-fn_800BFC30 = .text:0x800BFC30; // type:function size:0xC
-fn_800BFC40 = .text:0x800BFC40; // type:function size:0x4
-fn_800BFC50 = .text:0x800BFC50; // type:function size:0xD0
-fn_800BFD20 = .text:0x800BFD20; // type:function size:0x68
-fn_800BFD90 = .text:0x800BFD90; // type:function size:0x70
+copyFromSave__15SkipflagManagerFv = .text:0x800BFBA0; // type:function size:0x44
+setCommitFlag__15SkipflagManagerFUs = .text:0x800BFBF0; // type:function size:0xC
+__ct__15SkipflagManagerFv = .text:0x800BFC00; // type:function size:0x2C
+unsetCommitFlag__15SkipflagManagerFv = .text:0x800BFC30; // type:function size:0xC
+thunk_copyFromSave__15SkipflagManagerFv = .text:0x800BFC40; // type:function size:0x4
+setFlag__15SkipflagManagerFUs = .text:0x800BFC50; // type:function size:0xD0
+checkFlag__15SkipflagManagerFUs = .text:0x800BFD20; // type:function size:0x68
+commitFlags__15SkipflagManagerFv = .text:0x800BFD90; // type:function size:0x70
 fn_800BFE00 = .text:0x800BFE00; // type:function size:0x294
-fn_800C00A0 = .text:0x800C00A0; // type:function size:0x40
-fn_800C00E0 = .text:0x800C00E0; // type:function size:0x40
+__dt__15TBoxFlagManagerFv = .text:0x800C00A0; // type:function size:0x40
+__dt__18EnemyDefeatManagerFv = .text:0x800C00E0; // type:function size:0x40
 fn_800C0120 = .text:0x800C0120; // type:function size:0x58
 fn_800C0180 = .text:0x800C0180; // type:function size:0x58
 fn_800C01E0 = .text:0x800C01E0; // type:function size:0x8
@@ -31012,8 +31012,8 @@ lbl_80510C14 = .data:0x80510C14; // type:object size:0x14
 lbl_80510C28 = .data:0x80510C28; // type:object size:0x3C
 lbl_80510C64 = .data:0x80510C64; // type:object size:0x3C
 lbl_80510CA0 = .data:0x80510CA0; // type:object size:0x3C
-lbl_80510CDC = .data:0x80510CDC; // type:object size:0x14
-lbl_80510CF0 = .data:0x80510CF0; // type:object size:0x14
+__vt__18EnemyDefeatManager = .data:0x80510CDC; // type:object size:0x14
+__vt__15TBoxFlagManager = .data:0x80510CF0; // type:object size:0x14
 __vt__9FlagSpace = .data:0x80510D04; // type:object size:0xC
 lbl_80510D10 = .data:0x80510D10; // type:object size:0x38 data:4byte
 lbl_80510D48 = .data:0x80510D48; // type:object size:0x18
@@ -39843,13 +39843,13 @@ lbl_805753D0 = .sbss:0x805753D0; // type:object size:0x8 data:4byte
 lbl_805753D8 = .sbss:0x805753D8; // type:object size:0x8 data:4byte
 sInstance__16SceneflagManager = .sbss:0x805753E0; // type:object size:0x4 data:4byte
 sTempFlags__16SceneflagManager = .sbss:0x805753E8; // type:object size:0x8
-lbl_805753F0 = .sbss:0x805753F0; // type:object size:0x4 data:4byte
-lbl_805753F4 = .sbss:0x805753F4; // type:object size:0x4
-lbl_805753F8 = .sbss:0x805753F8; // type:object size:0x4 data:4byte
+sInstance__15TBoxFlagManager = .sbss:0x805753F0; // type:object size:0x4 data:4byte
+sTBoxFlags__15TBoxFlagManager = .sbss:0x805753F4; // type:object size:0x4
+sInstance__18EnemyDefeatManager = .sbss:0x805753F8; // type:object size:0x4 data:4byte
 lbl_805753FC = .sbss:0x805753FC; // type:object size:0x4 data:4byte
 lbl_80575400 = .sbss:0x80575400; // type:object size:0x4 data:4byte
 lbl_80575404 = .sbss:0x80575404; // type:object size:0x4 data:4byte
-lbl_80575408 = .sbss:0x80575408; // type:object size:0x8 data:4byte
+sInstance__15SkipflagManager = .sbss:0x80575408; // type:object size:0x4 data:4byte
 lbl_80575410 = .sbss:0x80575410; // type:object size:0x8 data:4byte
 lbl_80575418 = .sbss:0x80575418; // type:object size:0x8
 lbl_80575420 = .sbss:0x80575420; // type:object size:0x8 data:byte
@@ -48233,11 +48233,11 @@ lbl_805A78B8 = .bss:0x805A78B8; // type:object size:0xC
 lbl_805A78C4 = .bss:0x805A78C4; // type:object size:0xC data:4byte
 lbl_805A78D0 = .bss:0x805A78D0; // type:object size:0x10
 lbl_805A78E0 = .bss:0x805A78E0; // type:object size:0x1F8
-lbl_805A7AD8 = .bss:0x805A7AD8; // type:object size:0x2000
+sEnemyDefeatFlags__18EnemyDefeatManager = .bss:0x805A7AD8; // type:object size:0x2000
 lbl_805A9AD8 = .bss:0x805A9AD8; // type:object size:0x100
 lbl_805A9BD8 = .bss:0x805A9BD8; // type:object size:0x80
 lbl_805A9C58 = .bss:0x805A9C58; // type:object size:0x10
-lbl_805A9C68 = .bss:0x805A9C68; // type:object size:0x20
+sSkipFlags__15SkipflagManager = .bss:0x805A9C68; // type:object size:0x20
 lbl_805A9C88 = .bss:0x805A9C88; // type:object size:0x10 data:4byte
 lbl_805A9C98 = .bss:0x805A9C98; // type:object size:0x208
 lbl_805A9EA0 = .bss:0x805A9EA0; // type:object size:0x40 data:4byte

configure.py

@@ -274,6 +274,7 @@ config.libs = [
             Object(Matching, "toBeSorted/sceneflag_manager.cpp"),
             Object(NonMatching, "toBeSorted/flag_space.cpp"),
             Object(NonMatching, "toBeSorted/misc_flag_managers.cpp"),
+            Object(Matching, "toBeSorted/skipflag_manager.cpp"),
             Object(Matching, "c/c_list.cpp"),
             Object(Matching, "c/c_tree.cpp"),
             Object(Matching, "d/d_base.cpp"),

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;
+}