Counters except sinit won't match

src/toBeSorted/counters/arrow_counter.cpp

@@ -4,7 +4,7 @@ class ArrowCounter : public Counter {
 public:
     ArrowCounter();
     /* 8016DFA0 */ ~ArrowCounter() {}
-    /* 8016E000 */ virtual u16 getMax() override {
+    /* 8016E000 */ virtual u16 getMax() const override {
         return 20;
     };
 };

src/toBeSorted/counters/bomb_counter.cpp

@@ -4,7 +4,7 @@ class BombCounter : public Counter {
 public:
     BombCounter();
     /* 8016E020 */ ~BombCounter() {}
-    /* 8016E080 */ virtual u16 getMax() override {
+    /* 8016E080 */ virtual u16 getMax() const override {
         return 10;
     }
 };

src/toBeSorted/counters/counter.cpp

@@ -21,11 +21,11 @@
     return result <= max ? 0 : (result - max);
 }
 
-/* 8016cd30 */ u16 Counter::getCommittedValue() {
+/* 8016cd30 */ u16 Counter::getCommittedValue() const {
     return ItemflagManager::sInstance->getCounterOrFlag(counterId | 0x4000);
 }
 
-/* 8016cd50 */ u16 Counter::getUncommittedValue() {
+/* 8016cd50 */ u16 Counter::getUncommittedValue() const {
     return ItemflagManager::sInstance->getUncommittedValue(counterId | 0x4000);
 }
 

src/toBeSorted/counters/counters.cpp

@@ -0,0 +1,169 @@
+#include "d/flag/dungeonflag_manager.h"
+#include "toBeSorted/counters/counter.h"
+
+class SmallKeyCounter : public Counter {
+public:
+    SmallKeyCounter() : Counter(0xF) {}
+    virtual u16 getMax() const override {
+        return 15;
+    }
+    virtual u16 getCommittedValue() const override;
+    virtual u16 getUncommittedValue() const override;
+    virtual void setValue(u16 num) override;
+};
+
+u16 SmallKeyCounter::getCommittedValue() const {
+    u16 counter = counterId;
+    return DungeonflagManager::sInstance->getCounterOrFlag(counter, 8);
+}
+
+u16 SmallKeyCounter::getUncommittedValue() const {
+    return DungeonflagManager::sInstance->getDungeonFlag(counterId);
+}
+
+void SmallKeyCounter::setValue(u16 num) {
+    return DungeonflagManager::sInstance->setToValue(counterId, num);
+}
+
+static SmallKeyCounter sSmallKeyCounter;
+
+#define MAKE_COMMON_COUNTER(name, id, max)                                                                             \
+    class name##Counter : public Counter {                                                                             \
+    public:                                                                                                            \
+        name##Counter() : Counter(id) {}                                                                               \
+        virtual u16 getMax() const override {                                                                          \
+            return max;                                                                                                \
+        }                                                                                                              \
+    };                                                                                                                 \
+    static name##Counter s##name##Counter;
+
+MAKE_COMMON_COUNTER(PouchExpansion, 0x1EA, 7);
+
+class HeartPieceCounter : public Counter {
+public:
+    HeartPieceCounter() : Counter(0x1E9) {}
+    virtual s32 checkedAdd(s32 num) override;
+    virtual u16 getMax() const override {
+        return 3;
+    }
+};
+
+static HeartPieceCounter sHeartPieceCounter;
+
+s32 HeartPieceCounter::checkedAdd(s32 num) {
+    if (num > 0) {
+        s32 uncommitted = getUncommittedValue();
+        s32 newCount = uncommitted + num;
+        setValue(newCount % 4);
+    }
+
+    return 0;
+}
+
+MAKE_COMMON_COUNTER(HeartContainer, 0x1Fd, 24);
+
+MAKE_COMMON_COUNTER(FaronGrasshopper, 0x1B9, 99);
+MAKE_COMMON_COUNTER(WoodlandRhinoBeetle, 0x1BA, 99);
+MAKE_COMMON_COUNTER(DekuHornet, 0x1BB, 99);
+MAKE_COMMON_COUNTER(SkyloftMantis, 0x1BC, 99);
+MAKE_COMMON_COUNTER(VolcanicLadybug, 0x1BD, 99);
+MAKE_COMMON_COUNTER(BlessedButterfly, 0x1BE, 99);
+MAKE_COMMON_COUNTER(LanayruAnt, 0x1BF, 99);
+MAKE_COMMON_COUNTER(SandCicada, 0x1C0, 99);
+MAKE_COMMON_COUNTER(GerudoDragonfly, 0x1C1, 99);
+MAKE_COMMON_COUNTER(EldinRoller, 0x1C2, 99);
+MAKE_COMMON_COUNTER(SkyStagBeetle, 0x1C3, 99);
+MAKE_COMMON_COUNTER(StarryFirefly, 0x1C4, 99);
+
+MAKE_COMMON_COUNTER(HornetLarvae, 0x1A5, 99);
+MAKE_COMMON_COUNTER(BirdFeather, 0x1A6, 99);
+MAKE_COMMON_COUNTER(Tumbleweed, 0x1A7, 99); // TIM!!
+MAKE_COMMON_COUNTER(LizardTail, 0x1A8, 99);
+MAKE_COMMON_COUNTER(EldinOre, 0x1A9, 99);
+MAKE_COMMON_COUNTER(AncientFlower, 0x1AA, 99);
+MAKE_COMMON_COUNTER(AmberRelic, 0x1AB, 99);
+MAKE_COMMON_COUNTER(DuskRelic, 0x1AC, 99);
+MAKE_COMMON_COUNTER(JellyBlob, 0x1AD, 99);
+MAKE_COMMON_COUNTER(MonsterClaw, 0x1AE, 99);
+MAKE_COMMON_COUNTER(MonsterHorn, 0x1AF, 99);
+MAKE_COMMON_COUNTER(OrnamentalSkull, 0x1B0, 99);
+MAKE_COMMON_COUNTER(EvilCrystal, 0x1B1, 99);
+MAKE_COMMON_COUNTER(BlueBirdFeather, 0x1B2, 99);
+MAKE_COMMON_COUNTER(GoldenSkull, 0x1B3, 99);
+MAKE_COMMON_COUNTER(GoddessPlume, 0x1B4, 99);
+MAKE_COMMON_COUNTER(GratitudeCrystal, 0x1B5, 127);
+
+// I don't want to move all of these to headers yet
+extern TumbleweedCounter ARROW_COUNTER;
+extern TumbleweedCounter BOMB_COUNTER;
+extern TumbleweedCounter EXTRA_WALLET_COUNTER;
+extern TumbleweedCounter KEY_PIECE_COUNTER;
+extern TumbleweedCounter RUPEE_COUNTER;
+extern TumbleweedCounter SLINGSHOT_SEED_COUNTER;
+extern TumbleweedCounter TEAR_COUNTER;
+
+class Counters {
+public:
+    Counters() {
+        // mCounters\[([0-9]+)\] = &([A-Za-z_]+);
+        mCounters[0] = &RUPEE_COUNTER;
+        mCounters[1] = &ARROW_COUNTER;
+        mCounters[2] = &BOMB_COUNTER;
+        mCounters[3] = &TEAR_COUNTER;
+        mCounters[4] = &SLINGSHOT_SEED_COUNTER;
+        mCounters[5] = &KEY_PIECE_COUNTER;
+
+        mCounters[6] = &sSmallKeyCounter;
+        mCounters[7] = &sPouchExpansionCounter;
+        mCounters[8] = &sHeartPieceCounter;
+        mCounters[9] = &sHeartContainerCounter;
+
+        mCounters[10] = &sFaronGrasshopperCounter;
+        mCounters[11] = &sWoodlandRhinoBeetleCounter;
+        mCounters[12] = &sDekuHornetCounter;
+        mCounters[13] = &sSkyloftMantisCounter;
+        mCounters[14] = &sVolcanicLadybugCounter;
+        mCounters[15] = &sBlessedButterflyCounter;
+        mCounters[16] = &sLanayruAntCounter;
+        mCounters[17] = &sSandCicadaCounter;
+        mCounters[18] = &sGerudoDragonflyCounter;
+        mCounters[19] = &sEldinRollerCounter;
+        mCounters[20] = &sSkyStagBeetleCounter;
+        mCounters[21] = &sStarryFireflyCounter;
+
+        mCounters[22] = &sHornetLarvaeCounter;
+        mCounters[23] = &sBirdFeatherCounter;
+        mCounters[24] = &sTumbleweedCounter;
+        mCounters[25] = &sLizardTailCounter;
+        mCounters[26] = &sEldinOreCounter;
+        mCounters[27] = &sAncientFlowerCounter;
+        mCounters[28] = &sAmberRelicCounter;
+        mCounters[29] = &sDuskRelicCounter;
+        mCounters[30] = &sJellyBlobCounter;
+        mCounters[31] = &sMonsterClawCounter;
+        mCounters[32] = &sMonsterHornCounter;
+        mCounters[33] = &sOrnamentalSkullCounter;
+        mCounters[34] = &sEvilCrystalCounter;
+        mCounters[35] = &sBlueBirdFeatherCounter;
+        mCounters[36] = &sGoldenSkullCounter;
+        mCounters[37] = &sGoddessPlumeCounter;
+        mCounters[38] = &sGratitudeCrystalCounter;
+        mCounters[39] = &EXTRA_WALLET_COUNTER;
+    }
+
+    Counter *mCounters[40];
+};
+
+Counters sCounters;
+
+s32 increaseCounter(u16 counterIdx, s32 value) {
+    return sCounters.mCounters[counterIdx]->checkedAdd(value);
+}
+
+s32 getCounterByIndex(u16 counterIdx) {
+    return sCounters.mCounters[counterIdx]->getCommittedValue();
+}
+
+s32 getMaxItemCount(u16 counterIdx) {
+    return sCounters.mCounters[counterIdx]->getMax();
+}

src/toBeSorted/counters/extra_wallet_counter.cpp

@@ -4,7 +4,7 @@ class ExtraWalletCounter : public Counter {
 public:
     ExtraWalletCounter();
     /* 8016E220 */ ~ExtraWalletCounter() {}
-    /* 8016E280 */ virtual u16 getMax() override {
+    /* 8016E280 */ virtual u16 getMax() const override {
         return 3;
     }
 };

src/toBeSorted/counters/key_piece_counter.cpp

@@ -4,7 +4,7 @@ class KeyPieceCounter : public Counter {
 public:
     KeyPieceCounter();
     /* 8016E1A0 */ ~KeyPieceCounter() {}
-    /* 8016E200 */ virtual u16 getMax() override {
+    /* 8016E200 */ virtual u16 getMax() const override {
         return 5;
     }
 };

src/toBeSorted/counters/rupee_counter.cpp

@@ -9,7 +9,7 @@ class RupeeCounter : public Counter {
 public:
     RupeeCounter();
     /* 8016DEF0 */ ~RupeeCounter() {}
-    /* 8016DF50 */ virtual u16 getMax() override {
+    /* 8016DF50 */ virtual u16 getMax() const override {
         return (getBaseCapacity() + getExtraWalletCapacity());
     }
 };
@@ -36,9 +36,6 @@ struct WalletStruct {
     return 300;
 }
 
-// TODO main counters class
-extern "C" u16 getCounterByIndex(u16);
-
 /* 8016DEC0 */ static u16 getExtraWalletCapacity() {
     return 300 * getCounterByIndex(0x27); // Maybe 0x27 corresponds to item 27 -> small wallet?
 }

src/toBeSorted/counters/slingshot_seed_counter.cpp

@@ -4,7 +4,7 @@ class SlingshotSeedCounter : public Counter {
 public:
     SlingshotSeedCounter();
     /* 8016E120 */ ~SlingshotSeedCounter() {}
-    /* 8016E180 */ virtual u16 getMax() override {
+    /* 8016E180 */ virtual u16 getMax() const override {
         return 20;
     };
 };

src/toBeSorted/counters/tear_counter.cpp

@@ -4,7 +4,7 @@ class TearCounter : public Counter {
 public:
     TearCounter();
     /* 8016E0A0 */ ~TearCounter() {}
-    /* 8016E100 */ virtual u16 getMax() override {
+    /* 8016E100 */ virtual u16 getMax() const override {
         return 15;
     };
 };