Available Randomizer Checks (#5091)

* Calculate accessible checks and show them in the check tracker.

* Added added DoorUnlocked checks to the Fire Temple doors.

This is needed when calculating Accessible checks while playing and using small keys. Otherwise checks will appear unaccessible because Keys have been used.

* Changed RecalculateAccessibleChecks to use the logic ReachabilitySearch.

* Reverted DoorUnlocked changes.

* Added recalculate_accessible_checks debug console command.

* Skip CanBuy check when calculating accessible checks, it spoils that some items can't be bought with the current wallet.

* Set RAND_INF_ZELDAS_LETTER.

* Don't add locations to the pool when calculating accessible checks.

* Save and Load randomizer trick options.

* Get the number of used small keys.

* Added check if bean was planted.

* Show number of Accessible checks in each Area.

* Accounted for missing RG_POCKET_CUCCO in logic HasItem and ApplyItemEffect.

* Show accessible checks via an icon.

* Check shop price against current wallet.

* Recalculate Accessible Checks in CheckTrackerLoadGame instead of LoadFile.

* RecalculateAccessibleChecks on save.

* Don't unset Zelda's Letter.

* Added Only Show Available Checks checkbox.

* Rename Accessible Checks to Available Checks.

* Added option to Enable Available Checks.

* Remove debug console to recalculate available checks, this can now be done by toggling Enable Available Checks in the settings.

* Remove extra requiredTrial.

* Default "Hide unshuffled shop item checks" unchecked.

* Updated GetSmallKeyCount to return int8_t.

* Default AmmoDrop to true until the setting is implemented.

* Fixed Sleeping Waterfall timesaver.

* Updated Only Show Available Checks to let Show Hidden Items reveal hidden available checks.

* Revert "Don't unset Zelda's Letter."

This reverts commit 4b5903940f.

* Set RAND_INF_ZELDAS_LETTER.

* Revert "Fixed Sleeping Waterfall timesaver."

This reverts commit 9b62fd5297.

* Added isMagicAcquired to Logic::HasItem.

* GetDungeonSmallKeyDoors return static emptyVector.

* Comment out AmmoCanDrop in ResetLogic.

* Added location_access CanBuy todo.

* Reverted Get and Set SmallKeyCount to use uint8_t and handled -1 keys.

* Added todo for MQ Water GetUsedSmallKeyCount.

soh/soh/Enhancements/debugger/debugSaveEditor.h

@@ -1164,6 +1164,9 @@ const std::vector<FlagTable> flagTables = {
         { RAND_INF_COLOSSUS_GREAT_FAIRY_REWARD, "RAND_INF_COLOSSUS_GREAT_FAIRY_REWARD" },
         { RAND_INF_OGC_GREAT_FAIRY_REWARD, "RAND_INF_OGC_GREAT_FAIRY_REWARD" },
 
+        { RAND_INF_ZELDAS_LETTER, "RAND_INF_ZELDAS_LETTER" },
+        { RAND_INF_WEIRD_EGG, "RAND_INF_WEIRD_EGG" },
+
         { RAND_INF_KF_SOUTH_GRASS_WEST_RUPEE, "RAND_INF_KF_SOUTH_GRASS_WEST_RUPEE" },
         { RAND_INF_KF_NORTH_GRASS_WEST_RUPEE, "RAND_INF_KF_NORTH_GRASS_WEST_RUPEE" },
         { RAND_INF_KF_NORTH_GRASS_EAST_RUPEE, "RAND_INF_KF_NORTH_GRASS_EAST_RUPEE" },

soh/soh/Enhancements/debugger/performanceTimer.cpp

@@ -12,6 +12,10 @@ std::chrono::duration<double, std::milli> GetPerformanceTimer(TimerID timer){
     return totalTimes[timer];
 }
 
+void ResetPerformanceTimer(TimerID timer) {
+    totalTimes[timer] = {};
+}
+
 void ResetPerformanceTimers(){
     totalTimes = {};
 }

soh/soh/Enhancements/debugger/performanceTimer.h

@@ -25,12 +25,14 @@ typedef enum {
   PT_TOD_ACCESS,
   PT_ENTRANCE_LOGIC,
   PT_LOCATION_LOGIC,
+  PT_RECALCULATE_AVAILABLE_CHECKS,
   PT_MAX
 } TimerID;
 
 void StartPerformanceTimer(TimerID timer);
 void StopPerformanceTimer(TimerID timer);
 std::chrono::duration<double, std::milli> GetPerformanceTimer(TimerID timer);
+void ResetPerformanceTimer(TimerID timer);
 void ResetPerformanceTimers();
 static std::array<std::chrono::duration<double, std::milli>, PT_MAX> totalTimes = {};
 static std::array<std::chrono::high_resolution_clock::time_point, PT_MAX> timeStarted = {};

soh/soh/Enhancements/randomizer/3drando/fill.cpp

@@ -402,7 +402,13 @@ bool AddCheckToLogic(LocationAccess& locPair, GetAccessibleLocationsStruct& gals
   Rando::ItemLocation* location = ctx->GetItemLocation(loc);
   RandomizerGet locItem = location->GetPlacedRandomizerGet();
 
-  if (!location->IsAddedToPool() && locPair.ConditionsMet(parentRegion)) {
+  if (!location->IsAddedToPool() && locPair.ConditionsMet(parentRegion, gals.calculatingAvailableChecks)) {
+    if (gals.calculatingAvailableChecks) {
+      gals.accessibleLocations.push_back(loc);
+      StopPerformanceTimer(PT_LOCATION_LOGIC);
+      return false;
+    }
+
     location->AddToPool();
 
     if (locItem == RG_NONE) {
@@ -498,19 +504,23 @@ void ProcessRegion(Region* region, GetAccessibleLocationsStruct& gals, Randomize
 }
 
 // Return any of the targetLocations that are accessible in logic
-std::vector<RandomizerCheck> ReachabilitySearch(const std::vector<RandomizerCheck>& targetLocations, RandomizerGet ignore /* = RG_NONE*/) {
+std::vector<RandomizerCheck> ReachabilitySearch(const std::vector<RandomizerCheck>& targetLocations, RandomizerGet ignore /* = RG_NONE*/, bool calculatingAvailableChecks /* = false */) {
   auto ctx = Rando::Context::GetInstance();
   GetAccessibleLocationsStruct gals(0);
-  ResetLogic(ctx, gals, true);
+  gals.calculatingAvailableChecks = calculatingAvailableChecks;
+  ResetLogic(ctx, gals, !calculatingAvailableChecks);
   do {
     gals.InitLoop();
     for (size_t i = 0; i < gals.regionPool.size(); i++) {
       ProcessRegion(RegionTable(gals.regionPool[i]), gals, ignore);
     }
   } while (gals.logicUpdated);
-  erase_if(gals.accessibleLocations, [&targetLocations, ctx](RandomizerCheck loc){
+  erase_if(gals.accessibleLocations, [&targetLocations, ctx, calculatingAvailableChecks](RandomizerCheck loc) {
+    if (ctx->GetItemLocation(loc)->GetPlacedRandomizerGet() != RG_NONE && !calculatingAvailableChecks) {
+      return false;
+    }
     for (RandomizerCheck allowedLocation : targetLocations) {
-      if (loc == allowedLocation || ctx->GetItemLocation(loc)->GetPlacedRandomizerGet() != RG_NONE) {
+      if (loc == allowedLocation) {
         return false;
       }
     }

soh/soh/Enhancements/randomizer/3drando/fill.hpp

@@ -34,6 +34,8 @@ struct GetAccessibleLocationsStruct {
   std::vector<RandomizerCheck> itemSphere;
   std::list<Rando::Entrance*> entranceSphere;
 
+  bool calculatingAvailableChecks = false;
+
   GetAccessibleLocationsStruct(int _maxGsCount){
     regionPool = {RR_ROOT};
     gsCount = 0;
@@ -62,7 +64,7 @@ std::vector<RandomizerCheck> GetEmptyLocations(std::vector<RandomizerCheck> allo
 void ProcessRegion(Region* region, GetAccessibleLocationsStruct& gals, RandomizerGet ignore = RG_NONE, 
                    bool stopOnBeatable = false, bool addToPlaythrough = false);
 
-std::vector<RandomizerCheck> ReachabilitySearch(const std::vector<RandomizerCheck>& allowedLocations, RandomizerGet ignore=RG_NONE);
+std::vector<RandomizerCheck> ReachabilitySearch(const std::vector<RandomizerCheck>& allowedLocations, RandomizerGet ignore=RG_NONE, bool calculatingAvailableChecks=false);
 
 void GeneratePlaythrough();
 

soh/soh/Enhancements/randomizer/hook_handlers.cpp

@@ -236,6 +236,14 @@ void RandomizerOnFlagSetHandler(int16_t flagType, int16_t flag) {
         Flags_UnsetRandomizerInf(RAND_INF_CHILD_TRADES_HAS_CHICKEN);
     }
 
+    if (flagType == FLAG_EVENT_CHECK_INF && flag == EVENTCHKINF_OBTAINED_ZELDAS_LETTER) {
+        Flags_SetRandomizerInf(RAND_INF_ZELDAS_LETTER);
+    }
+
+    if (flagType == FLAG_EVENT_CHECK_INF && flag == EVENTCHKINF_OBTAINED_POCKET_EGG) {
+        Flags_SetRandomizerInf(RAND_INF_WEIRD_EGG);
+    }
+
     RandomizerCheck rc = GetRandomizerCheckFromFlag(flagType, flag);
     if (rc == RC_UNKNOWN_CHECK) return;
 
@@ -351,6 +359,7 @@ void RandomizerOnItemReceiveHandler(GetItemEntry receivedItemEntry) {
         loc->SetCheckStatus(RCSHOW_COLLECTED);
         CheckTracker::SpoilAreaFromCheck(randomizerQueuedCheck);
         CheckTracker::RecalculateAllAreaTotals();
+        CheckTracker::RecalculateAvailableChecks();
         SaveManager::Instance->SaveSection(gSaveContext.fileNum, SECTION_ID_TRACKER_DATA, true);
         randomizerQueuedCheck = RC_UNKNOWN_CHECK;
         randomizerQueuedItemEntry = GET_ITEM_NONE;

soh/soh/Enhancements/randomizer/item_location.cpp

@@ -228,5 +228,14 @@ void ItemLocation::ResetVariables() {
     areas = {};
     status = RCSHOW_UNCHECKED;
     isSkipped = false;
+    isAvailable = false;
+}
+
+bool ItemLocation::IsAvailable() const {
+    return isAvailable;
+}
+
+void ItemLocation::SetAvailable(bool isAvailable_) {
+    isAvailable = isAvailable_;
 }
 }

soh/soh/Enhancements/randomizer/item_location.h

@@ -56,6 +56,8 @@ class ItemLocation {
     bool IsFoolishCandidate() const;
     void SetBarrenCandidate();
     void ResetVariables();
+    bool IsAvailable() const;
+    void SetAvailable(bool isAvailable_);
 
   private:
     RandomizerCheck rc;
@@ -76,5 +78,6 @@ class ItemLocation {
     bool barrenCandidate = false;
     RandomizerCheckStatus status = RCSHOW_UNCHECKED;
     bool isSkipped = false;
+    bool isAvailable = false;
 };
 } // namespace Rando

soh/soh/Enhancements/randomizer/location_access.cpp

@@ -11,6 +11,11 @@
 
 #include <fstream>
 
+extern "C" {
+    extern SaveContext gSaveContext;
+    extern PlayState* gPlayState;
+}
+
 //generic grotto event list
 std::vector<EventAccess> grottoEvents;
 
@@ -27,7 +32,7 @@ bool LocationAccess::CheckConditionAtAgeTime(bool& age, bool& time) const {
     return GetConditionsMet();
 }
 
-bool LocationAccess::ConditionsMet(Region* parentRegion) const {
+bool LocationAccess::ConditionsMet(Region* parentRegion, bool calculatingAvailableChecks) const {
     //WARNING enterance validation can run this after resetting the access for sphere 0 validation
     //When refactoring ToD access, either fix the above or do not assume that we
     //have any access at all just because this is being run
@@ -41,8 +46,8 @@ bool LocationAccess::ConditionsMet(Region* parentRegion) const {
     ) {
         conditionsMet = true;
     }
-
+    
-    return conditionsMet && CanBuy();
+    return conditionsMet && (calculatingAvailableChecks || CanBuy()); // TODO: run CanBuy when price is known due to settings
 }
 
 bool LocationAccess::CanBuy() const {
@@ -224,8 +229,73 @@ bool MQSpiritSharedBrokenWallRoom(const RandomizerRegion region, ConditionFn con
     return areaTable[region].MQSpiritShared(condition, true, anyAge);
 }
 
+bool BeanPlanted(const RandomizerRegion region) {
+    // swchFlag found using the Actor Viewer to get the Obj_Bean parameters & 0x3F
+    // not tested with multiple OTRs, but can be automated similarly to GetDungeonSmallKeyDoors
+    SceneID sceneID;
+    uint8_t swchFlag;
+    switch (region) {
+        case RR_ZORAS_RIVER:
+            sceneID = SceneID::SCENE_ZORAS_RIVER;
+            swchFlag = 3;
+            break;
+        case RR_THE_GRAVEYARD:
+            sceneID = SceneID::SCENE_GRAVEYARD;
+            swchFlag = 3;
+            break;
+        case RR_KOKIRI_FOREST:
+            sceneID = SceneID::SCENE_KOKIRI_FOREST;
+            swchFlag = 9;
+            break;
+        case RR_THE_LOST_WOODS:
+            sceneID = SceneID::SCENE_LOST_WOODS;
+            swchFlag = 4;
+            break;
+        case RR_LW_BEYOND_MIDO:
+            sceneID = SceneID::SCENE_LOST_WOODS;
+            swchFlag = 18;
+            break;
+        case RR_DEATH_MOUNTAIN_TRAIL:
+            sceneID = SceneID::SCENE_DEATH_MOUNTAIN_TRAIL;
+            swchFlag = 6;
+            break;
+        case RR_LAKE_HYLIA:
+            sceneID = SceneID::SCENE_LAKE_HYLIA;
+            swchFlag = 1;
+            break;
+        case RR_GERUDO_VALLEY:
+            sceneID = SceneID::SCENE_GERUDO_VALLEY;
+            swchFlag = 3;
+            break;
+        case RR_DMC_CENTRAL_LOCAL:
+            sceneID = SceneID::SCENE_DEATH_MOUNTAIN_CRATER;
+            swchFlag = 3;
+            break;
+        case RR_DESERT_COLOSSUS:
+            sceneID = SceneID::SCENE_DESERT_COLOSSUS;
+            swchFlag = 24;
+            break;
+        default:
+            sceneID = SCENE_ID_MAX;
+            swchFlag = 0;
+            break;
+    }
+
+    // Get the swch value for the scene
+    uint32_t swch;
+    if (gPlayState != nullptr && gPlayState->sceneNum == sceneID) {
+        swch = gPlayState->actorCtx.flags.swch;
+    } else if (sceneID != SCENE_ID_MAX) {
+        swch = gSaveContext.sceneFlags[sceneID].swch;
+    } else {
+        swch = 0;
+    }
+
+    return swch >> swchFlag & 1;
+}
+
 bool CanPlantBean(const RandomizerRegion region) {
-    return areaTable[region].CanPlantBeanCheck();
+    return areaTable[region].CanPlantBeanCheck() || BeanPlanted(region);
 }
 
 bool BothAges(const RandomizerRegion region) {

soh/soh/Enhancements/randomizer/location_access.h

@@ -75,7 +75,7 @@ class LocationAccess {
 
         bool CheckConditionAtAgeTime(bool& age, bool& time) const;
 
-        bool ConditionsMet(Region* parentRegion) const;
+        bool ConditionsMet(Region* parentRegion, bool calculatingAvailableChecks) const;
 
         RandomizerCheck GetLocation() const {
             return location;

soh/soh/Enhancements/randomizer/logic.cpp

@@ -13,6 +13,11 @@
 #include "macros.h"
 #include "variables.h"
 #include <spdlog/spdlog.h>
+#include "StringHelper.h"
+#include "soh/resource/type/Scene.h"
+#include "soh/resource/type/scenecommand/SetTransitionActorList.h"
+#include "src/overlays/actors/ovl_En_Door/z_en_door.h"
+#include "src/overlays/actors/ovl_Door_Shutter/z_door_shutter.h"
 
 namespace Rando {
 
@@ -87,7 +92,7 @@ namespace Rando {
             case RG_BOMB_BAG:
                 return CurrentUpgrade(UPG_BOMB_BAG);
             case RG_MAGIC_SINGLE:
-                return GetSaveContext()->magicLevel >= 1;
+                return GetSaveContext()->magicLevel >= 1 || GetSaveContext()->isMagicAcquired;
                 // Songs
             case RG_ZELDAS_LULLABY:
             case RG_EPONAS_SONG:
@@ -217,6 +222,7 @@ namespace Rando {
             case RG_GOLDEN_SCALE:
                 return CurrentUpgrade(UPG_SCALE) >= 2;
             case RG_POCKET_EGG:
+                return CheckRandoInf(RAND_INF_ADULT_TRADES_HAS_POCKET_EGG);
             case RG_COJIRO:
             case RG_ODD_MUSHROOM:
             case RG_ODD_POTION:
@@ -226,7 +232,7 @@ namespace Rando {
             case RG_EYEBALL_FROG:
             case RG_EYEDROPS:
             case RG_CLAIM_CHECK:
-                return CheckRandoInf(itemName - RG_POCKET_EGG + RAND_INF_ADULT_TRADES_HAS_POCKET_EGG);
+                return CheckRandoInf(itemName - RG_COJIRO + RAND_INF_ADULT_TRADES_HAS_COJIRO);
             case RG_BOTTLE_WITH_BIG_POE:
             case RG_BOTTLE_WITH_BLUE_FIRE:
             case RG_BOTTLE_WITH_BLUE_POTION:
@@ -1509,6 +1515,8 @@ namespace Rando {
                 mSaveContext->isDoubleDefenseAcquired = state;
                 break;
             case RG_POCKET_EGG:
+                SetRandoInf(RAND_INF_ADULT_TRADES_HAS_POCKET_EGG, state);
+                break;
             case RG_COJIRO:
             case RG_ODD_MUSHROOM:
             case RG_ODD_POTION:
@@ -1518,7 +1526,7 @@ namespace Rando {
             case RG_EYEBALL_FROG:
             case RG_EYEDROPS:
             case RG_CLAIM_CHECK:
-                SetRandoInf(randoGet - RG_POCKET_EGG + RAND_INF_ADULT_TRADES_HAS_POCKET_EGG, state);
+                SetRandoInf(randoGet - RG_COJIRO + RAND_INF_ADULT_TRADES_HAS_COJIRO, state);
                 break;
             case RG_PROGRESSIVE_HOOKSHOT:
             {
@@ -2096,8 +2104,111 @@ namespace Rando {
         }
     }
 
+    std::unordered_map<SceneID, DungeonKey> SceneToDungeon = {
+        { SceneID::SCENE_DEKU_TREE, DungeonKey::DEKU_TREE },
+        { SceneID::SCENE_DODONGOS_CAVERN, DungeonKey::DODONGOS_CAVERN },
+        { SceneID::SCENE_JABU_JABU, DungeonKey::JABU_JABUS_BELLY },
+        { SceneID::SCENE_FOREST_TEMPLE, DungeonKey::FOREST_TEMPLE },
+        { SceneID::SCENE_FIRE_TEMPLE, DungeonKey::FIRE_TEMPLE },
+        { SceneID::SCENE_WATER_TEMPLE, DungeonKey::WATER_TEMPLE },
+        { SceneID::SCENE_SPIRIT_TEMPLE, DungeonKey::SPIRIT_TEMPLE },
+        { SceneID::SCENE_SHADOW_TEMPLE, DungeonKey::SHADOW_TEMPLE },
+        { SceneID::SCENE_BOTTOM_OF_THE_WELL, DungeonKey::BOTTOM_OF_THE_WELL },
+        { SceneID::SCENE_ICE_CAVERN, DungeonKey::ICE_CAVERN },
+        { SceneID::SCENE_GERUDO_TRAINING_GROUND, DungeonKey::GERUDO_TRAINING_GROUND },
+        { SceneID::SCENE_INSIDE_GANONS_CASTLE, DungeonKey::GANONS_CASTLE },
+    };
+
+    // Get the swch bit positions for the dungeon
+    const std::vector<uint8_t>& GetDungeonSmallKeyDoors(SceneID sceneId) {
+        static const std::vector<uint8_t> emptyVector;
+        auto foundDungeon = SceneToDungeon.find(static_cast<SceneID>(sceneId));
+        if (foundDungeon == SceneToDungeon.end()) {
+            return emptyVector;
+        }
+
+        bool masterQuest = Rando::Context::GetInstance()->GetDungeon(foundDungeon->second)->IsMQ();
+
+        // Create a unique key for the dungeon and master quest 
+        uint8_t key = sceneId | (masterQuest << 7);
+
+        static std::unordered_map<uint8_t, std::vector<uint8_t>> dungeonSmallKeyDoors;
+        auto foundEntry = dungeonSmallKeyDoors.find(key);
+        if (foundEntry != dungeonSmallKeyDoors.end()) {
+            return foundEntry->second;
+        }
+        dungeonSmallKeyDoors[key] = {};
+
+        // Get the scene path
+        SceneTableEntry* sceneTableEntry = &gSceneTable[sceneId];
+        std::string scenePath = StringHelper::Sprintf("scenes/%s/%s/%s", masterQuest ? "mq" : "nonmq",
+            sceneTableEntry->sceneFile.fileName, sceneTableEntry->sceneFile.fileName);
+
+        // Load the scene
+        std::shared_ptr<SOH::Scene> scene = std::dynamic_pointer_cast<SOH::Scene>(
+            Ship::Context::GetInstance()->GetResourceManager()->LoadResource(scenePath));
+        if (scene == nullptr) {
+            return emptyVector;
+        }
+
+        // Find the SetTransitionActorList command
+        std::shared_ptr<SOH::SetTransitionActorList> transitionActorListCommand = nullptr;
+        for (auto& command : scene->commands) {
+            if (command->cmdId == SOH::SceneCommandID::SetTransitionActorList) {
+                transitionActorListCommand = std::dynamic_pointer_cast<SOH::SetTransitionActorList>(command);
+                break;
+            }
+        }
+        if (transitionActorListCommand == nullptr) {
+            return emptyVector;
+        }
+
+        // Find the bit position for the small key doors
+        for (auto& transitionActor : transitionActorListCommand->transitionActorList) {
+            if (transitionActor.id == ACTOR_EN_DOOR) {
+                uint8_t doorType = (transitionActor.params >> 7) & 7;
+                if (doorType == DOOR_LOCKED) {
+                    dungeonSmallKeyDoors[key].emplace_back(transitionActor.params & 0x3F);
+                }
+            } else if (transitionActor.id == ACTOR_DOOR_SHUTTER) {
+                uint8_t doorType = (transitionActor.params >> 7) & 15;
+                if (doorType == SHUTTER_BACK_LOCKED || doorType == SHUTTER_BOSS || doorType == SHUTTER_KEY_LOCKED) {
+                    dungeonSmallKeyDoors[key].emplace_back(transitionActor.params & 0x3F);
+                }
+            }
+        }
+
+        return dungeonSmallKeyDoors[key];
+    }
+
+    int8_t GetUsedSmallKeyCount(SceneID sceneId) {
+        const auto& smallKeyDoors = GetDungeonSmallKeyDoors(sceneId);
+        
+        // Get the swch value for the scene
+        uint32_t swch;
+        if (gPlayState != nullptr && gPlayState->sceneNum == sceneId) {
+            swch = gPlayState->actorCtx.flags.swch;
+        } else {
+            swch = gSaveContext.sceneFlags[sceneId].swch;
+        }
+        
+        // Count the number of small keys doors unlocked
+        int8_t unlockedSmallKeyDoors = 0;
+        for (auto& smallKeyDoor : smallKeyDoors) {
+            unlockedSmallKeyDoors += swch >> smallKeyDoor & 1;
+        }
+
+        // RANDOTODO: Account for MQ Water trick that causes the basement lock to unlock when the player clears the stalfos pit.
+        return unlockedSmallKeyDoors;
+    }
+
     uint8_t Logic::GetSmallKeyCount(uint32_t dungeonIndex) {
-        return mSaveContext->inventory.dungeonKeys[dungeonIndex];
+        int8_t dungeonKeys = mSaveContext->inventory.dungeonKeys[dungeonIndex];
+        if (dungeonKeys == -1) {
+            // never got keys, so can't have used keys
+            return 0;
+        }
+        return dungeonKeys + GetUsedSmallKeyCount(SceneID(dungeonIndex));
     }
 
     void Logic::SetSmallKeyCount(uint32_t dungeonIndex, uint8_t count) {
@@ -2172,7 +2283,8 @@ namespace Rando {
         IsKeysanity = ctx->GetOption(RSK_KEYSANITY).Is(RO_DUNGEON_ITEM_LOC_ANYWHERE) || 
                     ctx->GetOption(RSK_KEYSANITY).Is(RO_DUNGEON_ITEM_LOC_ANYWHERE) || 
                     ctx->GetOption(RSK_KEYSANITY).Is(RO_DUNGEON_ITEM_LOC_ANYWHERE);
-        AmmoCanDrop = /*AmmoDrops.IsNot(AMMODROPS_NONE) TODO: AmmoDrop setting*/ true;
+
+        //AmmoCanDrop = /*AmmoDrops.IsNot(AMMODROPS_NONE)*/ false; TODO: AmmoDrop setting
 
         //Child item logic
         SkullMask     = false;

soh/soh/Enhancements/randomizer/logic.h

@@ -90,7 +90,7 @@ class Logic {
     bool FairyPot = false;
     bool FreeFairies = false;
     bool FairyPond = false;
-    bool AmmoCanDrop = false;
+    bool AmmoCanDrop = true;
 
     uint8_t PieceOfHeart = 0;
     uint8_t HeartContainer = 0;

soh/soh/Enhancements/randomizer/randomizer_check_tracker.cpp

@@ -9,7 +9,10 @@
 #include "soh/SohGui/UIWidgets.hpp"
 #include "soh/SohGui/SohGui.hpp"
 #include "dungeon.h"
+#include "entrance.h"
 #include "location_access.h"
+#include "3drando/fill.hpp"
+#include "soh/Enhancements/debugger/performanceTimer.h"
 
 #include <string>
 #include <vector>
@@ -84,7 +87,7 @@ bool fishsanityAgeSplit;
 bool initialized;
 bool doAreaScroll;
 bool previousShowHidden = false;
-bool hideShopUnshuffledChecks = true;
+bool hideShopUnshuffledChecks = false;
 bool alwaysShowGS = false;
 
 std::map<uint32_t, RandomizerCheck> startingShopItem = { { SCENE_KOKIRI_SHOP, RC_KF_SHOP_ITEM_1 },
@@ -132,8 +135,10 @@ bool areasFullyChecked[RCAREA_INVALID];
 u32 areasSpoiled = 0;
 bool showVOrMQ;
 s8 areaChecksGotten[RCAREA_INVALID]; //|     "Kokiri Forest (4/9)"
+s8 areaChecksAvailable[RCAREA_INVALID];
 s8 areaCheckTotals[RCAREA_INVALID];
 uint16_t totalChecks = 0;
+uint16_t totalChecksAvailable = 0;
 uint16_t totalChecksGotten = 0;
 bool optCollapseAll; // A bool that will collapse all checks once
 bool optExpandAll;       // A bool that will expand all checks once
@@ -166,6 +171,8 @@ bool hideCollected = false;
 bool showHidden = true;
 bool mystery = false;
 bool showLogicTooltip = false;
+bool enableAvailableChecks = false;
+bool onlyShowAvailable = false;
 
 SceneID DungeonSceneLookupByArea(RandomizerCheckArea area) {
     switch (area) {
@@ -235,10 +242,12 @@ void TrySetAreas() {
 
 void CalculateTotals() {
     totalChecks = 0;
+    totalChecksAvailable = 0;
     totalChecksGotten = 0;
 
     for (uint8_t i = 0; i < RCAREA_INVALID; i++) {
         totalChecks += areaCheckTotals[i];
+        totalChecksAvailable += areaChecksAvailable[i];
         totalChecksGotten += areaChecksGotten[i];
     }
 }
@@ -251,17 +260,43 @@ uint16_t GetTotalChecksGotten() {
     return totalChecksGotten;
 }
 
+bool IsCheckHidden(RandomizerCheck rc) {
+    Rando::ItemLocation* itemLocation = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
+    RandomizerCheckStatus status = itemLocation->GetCheckStatus();
+    bool available = itemLocation->IsAvailable();
+    bool skipped = itemLocation->GetIsSkipped();
+    bool obtained = itemLocation->HasObtained();
+    bool seen = status == RCSHOW_SEEN || status == RCSHOW_IDENTIFIED;
+    bool scummed = status == RCSHOW_SCUMMED;
+    bool unchecked = status == RCSHOW_UNCHECKED;
+
+    return !showHidden && (
+        (skipped && hideSkipped) ||
+        (seen && hideSeen) ||
+        (scummed && hideScummed) ||
+        (unchecked && hideUnchecked)
+    );
+}
+
 void RecalculateAreaTotals(RandomizerCheckArea rcArea) {
     areaChecksGotten[rcArea] = 0;
+    areaChecksAvailable[rcArea] = 0;
     areaCheckTotals[rcArea] = 0;
     for (auto rc : checksByArea.at(rcArea)) {
         if (!IsVisibleInCheckTracker(rc)) {
             continue;
         }
         areaCheckTotals[rcArea]++;
-        if (OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->GetIsSkipped() || OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->HasObtained()) {
+
+        Rando::ItemLocation* itemLoc = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
+
+        if (itemLoc->GetIsSkipped() || itemLoc->HasObtained()) {
             areaChecksGotten[rcArea]++;
         }
+
+        if (itemLoc->IsAvailable() && !IsCheckHidden(rc)) {
+            areaChecksAvailable[rcArea]++;
+        }
     }
     CalculateTotals();
 }
@@ -308,6 +343,7 @@ void SetCheckCollected(RandomizerCheck rc) {
     if (IsVisibleInCheckTracker(rc)) {
         if (!OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->GetIsSkipped()) {
             areaChecksGotten[loc->GetArea()]++;
+            areaChecksAvailable[loc->GetArea()]--;
         } else {
             OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->SetIsSkipped(false);
         }
@@ -424,10 +460,12 @@ void ClearAreaChecksAndTotals() {
     for (auto& [rcArea, vec] : checksByArea) {
         vec.clear();
         areaChecksGotten[rcArea] = 0;
+        areaChecksAvailable[rcArea] = 0;
         areaCheckTotals[rcArea] = 0;
     }
     totalChecks = 0;
     totalChecksGotten = 0;
+    totalChecksAvailable = 0;
 }
 
 void SetShopSeen(uint32_t sceneNum, bool prices) {
@@ -469,6 +507,9 @@ void CheckTrackerLoadGame(int32_t fileNum) {
             if (loc->GetCheckStatus() == RCSHOW_SAVED || loc->GetIsSkipped()) {
                 areaChecksGotten[entry2->GetArea()]++;
             }
+            if (loc->IsAvailable()) {
+                areaChecksAvailable[entry2->GetArea()]++;
+            }
         }
 
         if (areaChecksGotten[entry2->GetArea()] != 0 || RandomizerCheckObjects::AreaIsOverworld(entry2->GetArea()) ||
@@ -524,6 +565,7 @@ void CheckTrackerLoadGame(int32_t fileNum) {
     UpdateAllOrdering();
     UpdateInventoryChecks();
     UpdateFilters();
+    RecalculateAvailableChecks();
 }
 
 void CheckTrackerShopSlotChange(uint8_t cursorSlot, int16_t basePrice) {
@@ -539,6 +581,7 @@ void CheckTrackerShopSlotChange(uint8_t cursorSlot, int16_t basePrice) {
     if (status == RCSHOW_SEEN) {
         OTRGlobals::Instance->gRandoContext->GetItemLocation(slot)->SetCheckStatus(RCSHOW_IDENTIFIED);
         SaveManager::Instance->SaveSection(gSaveContext.fileNum, sectionId, true);
+        RecalculateAvailableChecks();
     }
 }
 
@@ -812,6 +855,9 @@ void SaveTrackerData(SaveContext* saveContext, int sectionID, bool fullSave) {
 
 void SaveFile(SaveContext* saveContext, int sectionID, bool fullSave) {
     SaveTrackerData(saveContext, sectionID, fullSave);
+    if (fullSave) {
+        RecalculateAvailableChecks();
+    }
 }
 
 void LoadFile() {
@@ -882,6 +928,8 @@ void CheckTrackerWindow::DrawElement() {
     showHidden                  = CVarGetInteger(CVAR_TRACKER_CHECK("ShowHidden"), 0);
     mystery                     = CVarGetInteger(CVAR_RANDOMIZER_ENHANCEMENT("MysteriousShuffle"), 0);
     showLogicTooltip            = CVarGetInteger(CVAR_TRACKER_CHECK("ShowLogic"), 0);
+    enableAvailableChecks       = CVarGetInteger(CVAR_TRACKER_CHECK("EnableAvailableChecks"), 0);
+    onlyShowAvailable           = CVarGetInteger(CVAR_TRACKER_CHECK("OnlyShowAvailable"), 0);
 
     hideShopUnshuffledChecks = CVarGetInteger(CVAR_TRACKER_CHECK("HideUnshuffledShopChecks"), 0);
     alwaysShowGS = CVarGetInteger(CVAR_TRACKER_CHECK("AlwaysShowGSLocs"), 0);
@@ -932,9 +980,21 @@ void CheckTrackerWindow::DrawElement() {
 
     ImGui::TableNextRow(0, headerHeight);
     ImGui::TableNextColumn();
-    UIWidgets::CVarCheckbox(
+    if (UIWidgets::CVarCheckbox(
-        "Show Hidden Items", CVAR_TRACKER_CHECK("ShowHidden"), UIWidgets::CheckboxOptions({{ .tooltip = "When active, items will show hidden checks by default when updated to this state." }})
+        "Show Hidden Items", CVAR_TRACKER_CHECK("ShowHidden"), UIWidgets::CheckboxOptions({{.tooltip = "When active, items will show hidden checks by default when updated to this state." }})
-        .Color(THEME_COLOR));
+        .Color(THEME_COLOR))) {
+        doAreaScroll = true;
+        showHidden = CVarGetInteger(CVAR_TRACKER_CHECK("ShowHidden"), 0);
+        RecalculateAllAreaTotals();
+    }
+    if (enableAvailableChecks) {
+        if (UIWidgets::CVarCheckbox(
+            "Only Show Available Checks", CVAR_TRACKER_CHECK("OnlyShowAvailable"), UIWidgets::CheckboxOptions({{ .tooltip = "When active, unavailable checks will be hidden." }})
+            .Color(THEME_COLOR))) {
+            doAreaScroll = true;
+            RecalculateAllAreaTotals();
+        }
+    }
     UIWidgets::PaddedSeparator();
     if (UIWidgets::Button("Expand All", UIWidgets::ButtonOptions().Color(THEME_COLOR).Size(UIWidgets::Sizes::Inline))) {
         optCollapseAll = false;
@@ -960,7 +1020,13 @@ void CheckTrackerWindow::DrawElement() {
 
     ImGui::Separator();
 
-    ImGui::Text("Total Checks: %d / %d", totalChecksGotten, totalChecks);
+    std::ostringstream totalChecksSS;
+    totalChecksSS << "Total Checks: ";
+    if (enableAvailableChecks) {
+        totalChecksSS << totalChecksAvailable << " Available / ";
+    }
+    totalChecksSS << totalChecksGotten << " Checked / " << totalChecks << " Total";
+    ImGui::Text(totalChecksSS.str().c_str());
 
     UIWidgets::PaddedSeparator();
 
@@ -1012,7 +1078,8 @@ void CheckTrackerWindow::DrawElement() {
             doAreaScroll = true;
         }
         if ((shouldHideFilteredAreas && filterAreasHidden[rcArea]) ||
-            (!showHidden && ((hideComplete && thisAreaFullyChecked) || (hideIncomplete && !thisAreaFullyChecked)))
+            (!showHidden && ((hideComplete && thisAreaFullyChecked) || (hideIncomplete && !thisAreaFullyChecked))) ||
+            (enableAvailableChecks && onlyShowAvailable && areaChecksAvailable[rcArea] == 0)
         ) {
             doDraw = false;
         } else {
@@ -1051,14 +1118,27 @@ void CheckTrackerWindow::DrawElement() {
             isThisAreaSpoiled = IsAreaSpoiled(rcArea) || mqSpoilers;
 
             if (isThisAreaSpoiled) {
-                if (showVOrMQ && RandomizerCheckObjects::AreaIsDungeon(rcArea)) {
+                std::ostringstream areaTotalsSS;
-                    if (OTRGlobals::Instance->gRandoContext->GetDungeons()->GetDungeonFromScene(DungeonSceneLookupByArea(rcArea))->IsMQ())
+                std::ostringstream areaTotalsTooltipSS;
-                        ImGui::Text("(%d/%d) - MQ", areaChecksGotten[rcArea], areaCheckTotals[rcArea]);
+
-                    else
+                areaTotalsSS << "(";
-                        ImGui::Text("(%d/%d) - Vanilla", areaChecksGotten[rcArea], areaCheckTotals[rcArea]);
+                if (enableAvailableChecks) {
-                } else {
+                    areaTotalsSS << static_cast<uint16_t>(areaChecksAvailable[rcArea]) << " / ";
-                    ImGui::Text("(%d/%d)", areaChecksGotten[rcArea], areaCheckTotals[rcArea]);
+                    areaTotalsTooltipSS << "Available / ";
                 }
+                areaTotalsSS << static_cast<uint16_t>(areaChecksGotten[rcArea]) << " / " << static_cast<uint16_t>(areaCheckTotals[rcArea]) << ")";
+                areaTotalsTooltipSS << "Checked / Total";
+
+                if (showVOrMQ && RandomizerCheckObjects::AreaIsDungeon(rcArea)) {
+                    if (OTRGlobals::Instance->gRandoContext->GetDungeons()->GetDungeonFromScene(DungeonSceneLookupByArea(rcArea))->IsMQ()) {
+                        areaTotalsSS << " - MQ";
+                    } else {
+                        areaTotalsSS << " - Vanilla";
+                    }
+                }
+
+                ImGui::Text(areaTotalsSS.str().c_str());
+                UIWidgets::Tooltip(areaTotalsTooltipSS.str().c_str());
             } else {
                 ImGui::Text("???");
             }
@@ -1561,6 +1641,12 @@ void DrawLocation(RandomizerCheck rc) {
     Rando::ItemLocation* itemLoc = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
     RandomizerCheckStatus status = itemLoc->GetCheckStatus();
     bool skipped = itemLoc->GetIsSkipped();
+    bool available = itemLoc->IsAvailable();
+
+    if (enableAvailableChecks && onlyShowAvailable && !available) {
+        return;
+    }
+
     if (status == RCSHOW_COLLECTED) {
         if (!showHidden && hideCollected) {
             return;
@@ -1637,10 +1723,18 @@ void DrawLocation(RandomizerCheck rc) {
                 OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->SetIsSkipped(false);
                 areaChecksGotten[loc->GetArea()]--;
                 totalChecksGotten--;
+                if (available) {
+                    areaChecksAvailable[loc->GetArea()]++;
+                    totalChecksAvailable++;
+                }
             } else {
                 OTRGlobals::Instance->gRandoContext->GetItemLocation(rc)->SetIsSkipped(true);
                 areaChecksGotten[loc->GetArea()]++;
                 totalChecksGotten++;
+                if (available) {
+                    areaChecksAvailable[loc->GetArea()]--;
+                    totalChecksAvailable--;
+                }
             }
             UpdateOrdering(loc->GetArea());
             UpdateInventoryChecks();
@@ -1654,7 +1748,19 @@ void DrawLocation(RandomizerCheck rc) {
     ImGui::SameLine();
 
     //Draw
-    ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(mainColor.r / 255.0f, mainColor.g / 255.0f, mainColor.b / 255.0f, mainColor.a / 255.0f));
+    ImVec4 styleColor(mainColor.r / 255.0f, mainColor.g / 255.0f, mainColor.b / 255.0f, mainColor.a / 255.0f);
+    if (enableAvailableChecks) {
+        if (itemLoc->HasObtained()) {
+            ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0, 0, 0, 0));
+        } else {
+            ImGui::PushStyleColor(ImGuiCol_Text, styleColor);
+        }
+        ImGui::Text("%s", available ? ICON_FA_UNLOCK : ICON_FA_LOCK);
+        ImGui::PopStyleColor();
+        ImGui::SameLine();
+    }
+
+    ImGui::PushStyleColor(ImGuiCol_Text, styleColor);
     ImGui::Text("%s", txt.c_str());
     ImGui::PopStyleColor();
 
@@ -1726,7 +1832,7 @@ void DrawLocation(RandomizerCheck rc) {
                 if (conditionStr != "true") {
                     UIWidgets::Tooltip(conditionStr.c_str());
                 }
-                return;
+                break;
             }
         }
     }
@@ -1804,6 +1910,55 @@ void ImGuiDrawTwoColorPickerSection(const char* text, const char* cvarMainName,
     UIWidgets::PopStyleCombobox();
 }
 
+void RecalculateAvailableChecks() {
+    if (!enableAvailableChecks) {
+        return;
+    }
+
+    ResetPerformanceTimer(PT_RECALCULATE_AVAILABLE_CHECKS);
+    StartPerformanceTimer(PT_RECALCULATE_AVAILABLE_CHECKS);
+
+    std::vector<RandomizerCheck> targetLocations;
+    targetLocations.reserve(RR_MAX);
+    for (auto& location : Rando::StaticData::GetLocationTable()) {
+        RandomizerCheck rc = location.GetRandomizerCheck();
+        Rando::ItemLocation* itemLocation = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
+        itemLocation->SetAvailable(false);
+        if (!itemLocation->HasObtained()) {
+            targetLocations.emplace_back(rc);
+        }
+    }
+
+    std::vector<RandomizerCheck> availableChecks = ReachabilitySearch(targetLocations, RG_NONE, true);
+    for (auto& rc : availableChecks) {
+        const auto& location = Rando::StaticData::GetLocation(rc);
+        const auto& itemLocation = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
+        if (location->GetRCType() == RCTYPE_SHOP && itemLocation->GetCheckStatus() == RCSHOW_IDENTIFIED) {
+            if (CanBuyAnother(rc)) {
+                itemLocation->SetAvailable(true);
+            }
+        } else {
+            itemLocation->SetAvailable(true);
+        }
+    }
+
+    totalChecksAvailable = 0;
+    for (auto& [rcArea, vec] : checksByArea) {
+        areaChecksAvailable[rcArea] = 0;
+        for (auto& rc : vec) {
+            Rando::ItemLocation* itemLocation = OTRGlobals::Instance->gRandoContext->GetItemLocation(rc);
+            if (itemLocation->IsAvailable() && IsVisibleInCheckTracker(rc) && !IsCheckHidden(rc)) {
+                areaChecksAvailable[rcArea]++;
+            }
+        }
+        totalChecksAvailable += areaChecksAvailable[rcArea];
+    }
+
+    StopPerformanceTimer(PT_RECALCULATE_AVAILABLE_CHECKS);
+    SPDLOG_INFO("Recalculate Available Checks Time: {}ms", GetPerformanceTimer(PT_RECALCULATE_AVAILABLE_CHECKS).count());
+}
+
+
 void CheckTrackerWindow::Draw() {
     if (!IsVisible()) {
         return;
@@ -1858,7 +2013,7 @@ void CheckTrackerSettingsWindow::DrawElement() {
                 .Tooltip("If enabled, Vanilla/MQ dungeons will show on the tracker immediately. Otherwise, Vanilla/MQ dungeon locations must be unlocked.").Color(THEME_COLOR));
         if (UIWidgets::CVarCheckbox("Hide unshuffled shop item checks", CVAR_TRACKER_CHECK("HideUnshuffledShopChecks"),
                 UIWidgets::CheckboxOptions().Tooltip("If enabled, will prevent the tracker from displaying slots with non-shop-item shuffles.").Color(THEME_COLOR))) {
-            hideShopUnshuffledChecks = !hideShopUnshuffledChecks;
+            hideShopUnshuffledChecks = CVarGetInteger(CVAR_TRACKER_CHECK("HideUnshuffledShopChecks"), 0);
             UpdateFilters();
         }
         if (UIWidgets::CVarCheckbox("Always show gold skulltulas", CVAR_TRACKER_CHECK("AlwaysShowGSLocs"),
@@ -1868,6 +2023,11 @@ void CheckTrackerSettingsWindow::DrawElement() {
         }
         UIWidgets::CVarCheckbox("Show Logic", CVAR_TRACKER_CHECK("ShowLogic"),
             UIWidgets::CheckboxOptions().Tooltip("If enabled, will show a check's logic when hovering over it.").Color(THEME_COLOR));
+        if (UIWidgets::CVarCheckbox("Enable Available Checks", CVAR_TRACKER_CHECK("EnableAvailableChecks"),
+            UIWidgets::CheckboxOptions().Tooltip("If enabled, will show the checks that are available to be collected with your current progress.").Color(THEME_COLOR))) {
+            enableAvailableChecks = CVarGetInteger(CVAR_TRACKER_CHECK("EnableAvailableChecks"), 0);
+            RecalculateAvailableChecks();
+        }
 
         // Filtering settings
         UIWidgets::PaddedSeparator();

soh/soh/Enhancements/randomizer/randomizer_check_tracker.h

@@ -61,4 +61,5 @@ void UpdateAllOrdering();
 void UpdateAllAreas();
 void RecalculateAllAreaTotals();
 void SpoilAreaFromCheck(RandomizerCheck rc);
+void RecalculateAvailableChecks();
 } // namespace CheckTracker

soh/soh/Enhancements/randomizer/savefile.cpp

@@ -306,11 +306,13 @@ extern "C" void Randomizer_InitSaveFile() {
 
         // Malon/Talon back at ranch.
         Flags_SetEventChkInf(EVENTCHKINF_OBTAINED_POCKET_EGG);
+        Flags_SetRandomizerInf(RAND_INF_WEIRD_EGG);
         Flags_SetEventChkInf(EVENTCHKINF_TALON_WOKEN_IN_CASTLE);
         Flags_SetEventChkInf(EVENTCHKINF_TALON_RETURNED_FROM_CASTLE);
 
         // Set "Got Zelda's Letter" flag. Also ensures Saria is back at SFM.
         Flags_SetEventChkInf(EVENTCHKINF_OBTAINED_ZELDAS_LETTER);
+        Flags_SetRandomizerInf(RAND_INF_ZELDAS_LETTER);
         Flags_SetRandomizerInf(RAND_INF_CHILD_TRADES_HAS_LETTER_ZELDA);
 
         // Got item from Impa.
@@ -321,7 +323,6 @@ extern "C" void Randomizer_InitSaveFile() {
         // Set this at the end to ensure we always start with the letter.
         // This is for the off chance, we got the Weird Egg from Impa (which should never happen).
         INV_CONTENT(ITEM_LETTER_ZELDA) = ITEM_LETTER_ZELDA;
-        Flags_SetRandomizerInf(RAND_INF_CHILD_TRADES_HAS_LETTER_ZELDA);
     }
 
     if (Randomizer_GetSettingValue(RSK_SHUFFLE_MASTER_SWORD) && startingAge == RO_AGE_ADULT) {

soh/soh/SaveManager.cpp

@@ -459,10 +459,16 @@ void SaveManager::LoadRandomizerVersion3() {
     });
 
     randoContext->GetTrials()->SkipAll();
-    SaveManager::Instance->LoadArray("requiredTrials", randoContext->GetOption(RSK_TRIAL_COUNT).Get() + 1, [&](size_t i) {
+    SaveManager::Instance->LoadArray("requiredTrials", randoContext->GetOption(RSK_TRIAL_COUNT).Get(), [&](size_t i) {
         size_t trialId;
         SaveManager::Instance->LoadData("", trialId);
         randoContext->GetTrial(trialId)->SetAsRequired();
+                                     });
+
+    SaveManager::Instance->LoadArray("trickOptions", RT_MAX, [&](size_t i) {
+        uint8_t value = 0;
+        SaveManager::Instance->LoadData("", value);
+        randoContext->GetTrickOption(RandomizerTrick(i)).Set(value);
     });
 }
 
@@ -596,6 +602,10 @@ void SaveManager::SaveRandomizer(SaveContext* saveContext, int sectionID, bool f
             SaveManager::Instance->SaveData("", i);
         }
     });
+
+    SaveManager::Instance->SaveArray("trickOptions", RT_MAX, [&](size_t i) {
+        SaveManager::Instance->SaveData("", randoContext->GetTrickOption(RandomizerTrick(i)).Get());
+    });
 }
 
 // Init() here is an extension of InitSram, and thus not truly an initializer for SaveManager itself. don't put any class initialization stuff here