Merge pull request #164 from SuperDude88/legacy-race-mode

SuperDude88 · web-flow · commit b0060479a0fd · 2026-03-17T20:15:39.000-04:00
Generalize Race Mode Terms
diff --git a/gui/desktop/mainwindow.cpp b/gui/desktop/mainwindow.cpp
@@ -545,7 +545,7 @@ void MainWindow::apply_config_settings()
     APPLY_SPINBOX_SETTING(config, ui, damage_multiplier, float(2.0f), float(MAXIMUM_DAMAGE_MULTIPLIER));
 
     auto& num_required_dungeons = config.settings.num_required_dungeons;
-    // Race mode dungeons must be between 1 and 6 if race mode is enabled
+    // Required dungeons must be between 1 and 6 if race mode is enabled
     if (config.settings.progression_dungeons == ProgressionDungeons::RaceMode)
     {
         num_required_dungeons = std::clamp(num_required_dungeons, uint8_t(1), uint8_t(MAXIMUM_NUM_DUNGEONS));
@@ -771,7 +771,7 @@ DEFINE_STATE_CHANGE_FUNCTION(progression_combat_secret_caves)
 void MainWindow::on_progression_dungeons_currentTextChanged(const QString &arg1)
 {
     config.settings.progression_dungeons = nameToProgressionDungeons(arg1.toStdString());
-    // Grey out the race mode dungeons combobox if race mode/standard is not selected
+    // Grey out the required dungeons combobox if dungeons are disabled
     if (config.settings.progression_dungeons == ProgressionDungeons::RaceMode)
     {
         ui->num_required_dungeons->setEnabled(true);
diff --git a/logic/Dungeon.hpp b/logic/Dungeon.hpp
@@ -16,13 +16,13 @@ struct Dungeon {
     Item map = Item();
     Item compass = Item();
     std::list<Location*> locations = {};
-    Location* raceModeLocation = nullptr;
+    Location* bossLocation = nullptr;
     Area* startingArea = nullptr;
     Entrance* startingEntrance = nullptr;
     std::list<std::string> islands = {};
     std::string name = "";
     bool isRequiredDungeon = false;
-    bool hasNaturalRaceModeLocation = false;
+    bool hasNaturalBossLocation = false;
     std::string windWarpExitStage = "";
     uint8_t windWarpExitRoom = 0;
     uint8_t windWarpExitSpawn = 0;
diff --git a/logic/EntranceShuffle.cpp b/logic/EntranceShuffle.cpp
@@ -306,25 +306,24 @@ static EntranceShuffleError validateWorld(WorldPool& worlds, const Entrance* ent
 
     for (auto& world : worlds)
     {
-        // Ensure that all race mode bosses are assigned to a single island
+        // Ensure that all required bosses are assigned to a single island
         auto& settings = world.getSettings();
         if (settings.progression_dungeons != ProgressionDungeons::Disabled && settings.num_required_dungeons > 0)
         {
-            std::unordered_set<std::string> raceModeIslands = {};
-            for (auto loc : world.raceModeLocations)
+            for (auto loc : world.bossLocations)
             {
-                auto bossIslands = loc->accessPoints.front()->area->findIslands();
+                const auto& bossIslands = loc->accessPoints.front()->area->findIslands();
 
                 if (bossIslands.size() > 1)
                 {
                     #ifdef ENABLE_DEBUG
-                        LOG_TO_DEBUG("Error: More than 1 island leading to race mode boss room " + loc->accessPoints.front()->area->name);
+                        LOG_TO_DEBUG("Error: More than 1 island leading to required boss room " + loc->accessPoints.front()->area->name);
                         for (auto& island : bossIslands)
                         {
                             LOG_TO_DEBUG("\t" + island);
                         }
                     #endif
-                    return EntranceShuffleError::AMBIGUOUS_RACE_MODE_ISLAND;
+                    return EntranceShuffleError::AMBIGUOUS_BOSS_ISLAND;
                 }
             }
         }
@@ -952,7 +951,7 @@ EntranceShuffleError randomizeEntrances(WorldPool& worlds)
             }
         }
 
-        // Now set the islands the race mode dungeons are in
+        // Now set the islands the dungeons are in
         for (auto& [name, dungeon] : world.dungeons)
         {
             dungeon.islands = dungeon.startingArea->findIslands();
@@ -982,12 +981,8 @@ const std::string errorToName(EntranceShuffleError err)
             return "NO_MORE_VALID_ENTRANCES";
         case EntranceShuffleError::ALL_LOCATIONS_NOT_REACHABLE:
             return "ALL_LOCATIONS_NOT_REACHABLE";
-        case EntranceShuffleError::AMBIGUOUS_RACE_MODE_ISLAND:
-            return "AMBIGUOUS_RACE_MODE_ISLAND";
-        case EntranceShuffleError::AMBIGUOUS_RACE_MODE_DUNGEON:
-            return "AMBIGUOUS_RACE_MODE_DUNGEON";
-        case EntranceShuffleError::NO_RACE_MODE_ISLAND:
-            return "NO_RACE_MODE_ISLAND";
+        case EntranceShuffleError::AMBIGUOUS_BOSS_ISLAND:
+            return "AMBIGUOUS_BOSS_ISLAND";
         case EntranceShuffleError::NOT_ENOUGH_SPHERE_ZERO_LOCATIONS:
             return "NOT_ENOUGH_SPHERE_ZERO_LOCATIONS";
         case EntranceShuffleError::ATTEMPTED_SELF_CONNECTION:
diff --git a/logic/EntranceShuffle.hpp b/logic/EntranceShuffle.hpp
@@ -12,9 +12,7 @@ enum struct EntranceShuffleError
     RAN_OUT_OF_RETRIES,
     NO_MORE_VALID_ENTRANCES,
     ALL_LOCATIONS_NOT_REACHABLE,
-    AMBIGUOUS_RACE_MODE_ISLAND,
-    AMBIGUOUS_RACE_MODE_DUNGEON,
-    NO_RACE_MODE_ISLAND,
+    AMBIGUOUS_BOSS_ISLAND,
     NOT_ENOUGH_SPHERE_ZERO_LOCATIONS,
     ATTEMPTED_SELF_CONNECTION,
     FAILED_TO_DISCONNECT_TARGET,
diff --git a/logic/Fill.cpp b/logic/Fill.cpp
@@ -323,8 +323,7 @@ void placeVanillaItems(WorldPool& worlds)
 // Determine which items are major items. A major item is any item required
 // for access to any progression location and/or game beatability. This function
 // is called multiple times during the fill algorithm as the items required for
-// beatability may change depending on which items are placed in race mode locations
-// and/or plandomized
+// beatability may change depending on which items are placed in boss locations and/or plandomized
 void determineMajorItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)
 {
     LOG_TO_DEBUG("Determining Major Items");
@@ -405,7 +404,7 @@ static FillError randomizeOwnDungeon(WorldPool& worlds, ItemPool& itemPool)
         {
             // Filter to only the dungeons locations which are progression locations
             // If dungeons are not progression locations, or if race mode is on
-            // and this isn't a race mode dungeon, then take all locations in
+            // and this isn't a required dungeon, then take all locations in
             // the dungeon since none of them are progression anyway
             auto worldLocations = world.getLocations();
             auto dungeonLocations = filterFromPool(worldLocations, [&dungeon = dungeon, &settings = settings](const Location* loc){
@@ -586,66 +585,67 @@ static FillError handleDungeonItems(WorldPool& worlds, ItemPool& itemPool)
     return FillError::NONE;
 }
 
-static void generateRaceModeItems(const LocationPool& raceModeLocations, ItemPool& raceModeItems, ItemPool& itemsToChooseFrom, ItemPool& mainItemPool)
+static void generateBossItems(const LocationPool& bossLocations, ItemPool& chosenItems, ItemPool& itemsToChooseFrom, ItemPool& mainItemPool)
 {
     shufflePool(itemsToChooseFrom);
-    while (!itemsToChooseFrom.empty() && raceModeItems.size() < raceModeLocations.size())
+    while (!itemsToChooseFrom.empty() && chosenItems.size() < bossLocations.size())
     {
-        raceModeItems.push_back(popRandomElement(itemsToChooseFrom));
+        chosenItems.push_back(popRandomElement(itemsToChooseFrom));
     }
     // Add back any unused elements
     addElementsToPool(mainItemPool, itemsToChooseFrom);
 }
 
 // Place progression items in specific locations at the end of dungeons to require the player
 // to beat those dungeons.
-static FillError placeRaceModeItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)
+static FillError placeBossItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)
 {
-    LocationPool raceModeLocations;
-    ItemPool raceModeItems;
+    LocationPool bossLocations;
+    ItemPool bossItems;
     for (auto& world : worlds)
     {
         if(world.getSettings().required_boss_items) {
             for (auto& [name, dungeon] : world.dungeons)
             {
                 if (dungeon.isRequiredDungeon)
                 {
-                    auto raceModeLocation = dungeon.raceModeLocation;
+                    auto bossLocation = dungeon.bossLocation;
                     // If this location already has an item placed at it, then skip it
-                    if (raceModeLocation->currentItem.getGameItemId() != GameItem::INVALID)
+                    if (bossLocation->currentItem.getGameItemId() != GameItem::INVALID)
                     {
                         continue;
                     }
-                    raceModeLocations.push_back(raceModeLocation);
+                    bossLocations.push_back(bossLocation);
                 }
             }
         }
     }
 
     // Build up the list of boss items with major items.
     auto majorItems = filterAndEraseFromPool(itemPool, [](const Item& item){return item.isMajorItem();});
-    generateRaceModeItems(raceModeLocations, raceModeItems, majorItems, itemPool);
+    generateBossItems(bossLocations, bossItems, majorItems, itemPool);
 
-    // logItemPool("raceModeItems", raceModeItems);
+    logItemPool("Boss Items", bossItems);
 
-    if (raceModeItems.size() < raceModeLocations.size())
+    if (bossItems.size() < bossLocations.size())
     {
-        Utility::platformLog("WARNING: Not enough major items to place at race mode locations.");
+        Utility::platformLog("WARNING: Not enough major items to place at boss locations.");
     }
 
-    // Then place the items in the race mode locations
+    // Then place the items in the boss locations
     FillError err;
-    FILL_ERROR_CHECK(assumedFill(worlds, raceModeItems, itemPool, raceModeLocations));
+    FILL_ERROR_CHECK(assumedFill(worlds, bossItems, itemPool, bossLocations));
 
-    // Set race mode locations which had items placed at them as having expected items
-    for (auto raceModeLoc : raceModeLocations)
+    // Set boss locations which had items placed at them as having expected items
+    for (auto loc : bossLocations)
     {
-        raceModeLoc->hasExpectedItem = true;
+        loc->hasExpectedItem = true;
     }
 
     // Recalculate major items since new items may now be required depending on
-    // what items were placed at race mode locations
+    // what items were placed at boss locations
     determineMajorItems(worlds, itemPool, allLocations);
+
     return FillError::NONE;
 }
 
@@ -734,10 +734,10 @@ FillError fill(WorldPool& worlds)
 
     determineMajorItems(worlds, itemPool, allLocations);
     FILL_ERROR_CHECK(placeNonProgressLocationPlandomizerItems(worlds, itemPool));
-    // Handle dungeon items and race mode dungeons first if necessary. Generally
+    // Handle dungeon and/or boss items first if necessary. Generally
     // we need to place items that go into more restrictive location pools first before
     // we can place other items.
-    FILL_ERROR_CHECK(placeRaceModeItems(worlds, itemPool, allLocations));
+    FILL_ERROR_CHECK(placeBossItems(worlds, itemPool, allLocations));
     FILL_ERROR_CHECK(handleDungeonItems(worlds, itemPool));
 
     // Recalculate major items again since new items may now be required depending on
diff --git a/logic/Generate.cpp b/logic/Generate.cpp
@@ -156,13 +156,13 @@ int generateWorlds(WorldPool& worlds, std::vector<Settings>& settingsVector)
 
       // Now that all entrances have been randomized, we can flatten the world's
       // logic requirements for some useful operations later on
-      // Determine race mode dungeons after entrance randomizer to ensure we pick
+      // Determine required dungeons after entrance randomizer to ensure we pick
       // dungeons which can be properly reached depending on any entrance rando settings
       for (auto& world : worlds)
       {
           world.flattenLogicRequirements();
           WORLD_LOADING_ERROR_CHECK(world.setDungeonLocations(worlds));
-          WORLD_LOADING_ERROR_CHECK(world.determineRaceModeDungeons(worlds));
+          WORLD_LOADING_ERROR_CHECK(world.determineRequiredDungeons(worlds));
       }
 
       // Retry the main fill algorithm a couple times incase it completely fails.
diff --git a/logic/Hints.cpp b/logic/Hints.cpp
@@ -33,10 +33,10 @@ static HintError calculatePossiblePathLocations(WorldPool& worlds)
         world.goalLocations.push_back(world.locationTable["Ganon's Tower - Defeat Ganondorf"].get());
         for (auto& [name, dungeon] : world.dungeons)
         {
-            // Race mode locations are also goal locations
+            // Boss locations are also goal locations
             if (dungeon.isRequiredDungeon)
             {
-                world.goalLocations.push_back(dungeon.raceModeLocation);
+                world.goalLocations.push_back(dungeon.bossLocation);
             }
         }
 
@@ -311,7 +311,7 @@ static HintError generatePathHintLocations(World& world, std::list<Hint>& hints)
     for (auto& goalLocation : world.goalLocations)
     {
         shufflePool(goalLocation->pathLocations);
-        // Initially we want to pull path hints from race mode dungeons before pulling from Ganondorf
+        // Initially we want to pull path hints from required dungeons before pulling from Ganondorf
         if (goalLocation->getName() != "Ganon's Tower - Defeat Ganondorf")
         {
             goalLocations.push_back(goalLocation);
@@ -321,15 +321,15 @@ static HintError generatePathHintLocations(World& world, std::list<Hint>& hints)
     bool addedGanonPathLocation = false;
     for (uint8_t i = 0; i < world.getSettings().path_hints; i++)
     {
-        // Try to get at least one hint for each race mode dungeon first
+        // Try to get at least one hint for each required dungeon first
         Location* goalLocation = nullptr;
         if (i < goalLocations.size())
         {
             goalLocation = goalLocations[i];
         }
         else
         {
-            // Once we've pulled from all race mode dungeons, then add Ganondorf to the list
+            // Once we've pulled from all required dungeons, then add Ganondorf to the list
             // and choose randomly
             if (i == goalLocations.size() && !addedGanonPathLocation)
             {
@@ -650,7 +650,7 @@ static HintError generateLocationHintLocations(World& world, std::list<Hint>& hi
     {
         if (location->progression && 
            !location->hasBeenHinted && 
-           !location->isRaceModeLocation && 
+           !location->isBossLocation && 
             location->hintPriority == "Sometimes" && 
            !(world.getSettings().ho_ho_triforce_hints && location->currentItem.isTriforceShard()))
             {
diff --git a/logic/Location.cpp b/logic/Location.cpp
@@ -187,7 +187,7 @@ bool Location::currentItemCanBeBarren() const
 // if it's a required race mode location
 bool Location::isBarrenAsChainLocation() const
 {
-    return !progression || (currentItem.canBeInBarrenRegion() && !isRequiredRaceModeLocation);
+    return !progression || (currentItem.canBeInBarrenRegion() && !isRequiredBossLocation);
 }
 
 std::u16string Location::generateImportanceText(const std::string& language)
diff --git a/logic/Location.hpp b/logic/Location.hpp
@@ -71,8 +71,8 @@ class Location
     std::unordered_map<std::string, std::string> names = {};
     std::unordered_set<LocationCategory> categories;
     bool progression;
-    bool isRaceModeLocation;
-    bool isRequiredRaceModeLocation;
+    bool isBossLocation;
+    bool isRequiredBossLocation;
     uint8_t stageId = 0;
     bool plandomized;
     bool hasBeenHinted;
@@ -100,7 +100,7 @@ class Location
     // Message Label if this is a hint location
     std::string messageLabel;
 
-    // goal names if this is a race mode location (one for each language)
+    // goal names if this is a boss location (one for each language)
     std::unordered_map<std::string, std::string> goalNames = {};
 
     // Tracker properties
@@ -112,8 +112,8 @@ class Location
         names({}),
         categories({LocationCategory::INVALID}),
         progression(false),
-        isRaceModeLocation(false),
-        isRequiredRaceModeLocation(false),
+        isBossLocation(false),
+        isRequiredBossLocation(false),
         stageId(0),
         plandomized(false),
         hasBeenHinted(false),
diff --git a/logic/World.cpp b/logic/World.cpp
diff --git a/logic/World.hpp b/logic/World.hpp
diff --git a/logic/data/location_data.yaml b/logic/data/location_data.yaml
diff --git a/tweaks.cpp b/tweaks.cpp

Original file line number	Diff line number	Diff line change
`@@ -545,7 +545,7 @@ void MainWindow::apply_config_settings()`
`545`	`545`	`APPLY_SPINBOX_SETTING(config, ui, damage_multiplier, float(2.0f), float(MAXIMUM_DAMAGE_MULTIPLIER));`
`546`	`546`
`547`	`547`	`auto& num_required_dungeons = config.settings.num_required_dungeons;`
`548`		`- // Race mode dungeons must be between 1 and 6 if race mode is enabled`
	`548`	`+ // Required dungeons must be between 1 and 6 if race mode is enabled`
`549`	`549`	`if (config.settings.progression_dungeons == ProgressionDungeons::RaceMode)`
`550`	`550`	`{`
`551`	`551`	`num_required_dungeons = std::clamp(num_required_dungeons, uint8_t(1), uint8_t(MAXIMUM_NUM_DUNGEONS));`
`@@ -771,7 +771,7 @@ DEFINE_STATE_CHANGE_FUNCTION(progression_combat_secret_caves)`
`771`	`771`	`void MainWindow::on_progression_dungeons_currentTextChanged(const QString &arg1)`
`772`	`772`	`{`
`773`	`773`	`config.settings.progression_dungeons = nameToProgressionDungeons(arg1.toStdString());`
`774`		`- // Grey out the race mode dungeons combobox if race mode/standard is not selected`
	`774`	`+ // Grey out the required dungeons combobox if dungeons are disabled`
`775`	`775`	`if (config.settings.progression_dungeons == ProgressionDungeons::RaceMode)`
`776`	`776`	`{`
`777`	`777`	`ui->num_required_dungeons->setEnabled(true);`
Original file line number	Diff line number	Diff line change
`@@ -306,25 +306,24 @@ static EntranceShuffleError validateWorld(WorldPool& worlds, const Entrance* ent`
`306`	`306`
`307`	`307`	`for (auto& world : worlds)`
`308`	`308`	`{`
`309`		`- // Ensure that all race mode bosses are assigned to a single island`
	`309`	`+ // Ensure that all required bosses are assigned to a single island`
`310`	`310`	`auto& settings = world.getSettings();`
`311`	`311`	`if (settings.progression_dungeons != ProgressionDungeons::Disabled && settings.num_required_dungeons > 0)`
`312`	`312`	`{`
`313`		`- std::unordered_set<std::string> raceModeIslands = {};`
`314`		`- for (auto loc : world.raceModeLocations)`
	`313`	`+ for (auto loc : world.bossLocations)`
`315`	`314`	`{`
`316`		`- auto bossIslands = loc->accessPoints.front()->area->findIslands();`
	`315`	`+ const auto& bossIslands = loc->accessPoints.front()->area->findIslands();`
`317`	`316`
`318`	`317`	`if (bossIslands.size() > 1)`
`319`	`318`	`{`
`320`	`319`	`#ifdef ENABLE_DEBUG`
`321`		`- LOG_TO_DEBUG("Error: More than 1 island leading to race mode boss room " + loc->accessPoints.front()->area->name);`
	`320`	`+ LOG_TO_DEBUG("Error: More than 1 island leading to required boss room " + loc->accessPoints.front()->area->name);`
`322`	`321`	`for (auto& island : bossIslands)`
`323`	`322`	`{`
`324`	`323`	`LOG_TO_DEBUG("\t" + island);`
`325`	`324`	`}`
`326`	`325`	`#endif`
`327`		`- return EntranceShuffleError::AMBIGUOUS_RACE_MODE_ISLAND;`
	`326`	`+ return EntranceShuffleError::AMBIGUOUS_BOSS_ISLAND;`
`328`	`327`	`}`
`329`	`328`	`}`
`330`	`329`	`}`
`@@ -952,7 +951,7 @@ EntranceShuffleError randomizeEntrances(WorldPool& worlds)`
`952`	`951`	`}`
`953`	`952`	`}`
`954`	`953`
`955`		`- // Now set the islands the race mode dungeons are in`
	`954`	`+ // Now set the islands the dungeons are in`
`956`	`955`	`for (auto& [name, dungeon] : world.dungeons)`
`957`	`956`	`{`
`958`	`957`	`dungeon.islands = dungeon.startingArea->findIslands();`
`@@ -982,12 +981,8 @@ const std::string errorToName(EntranceShuffleError err)`
`982`	`981`	`return "NO_MORE_VALID_ENTRANCES";`
`983`	`982`	`case EntranceShuffleError::ALL_LOCATIONS_NOT_REACHABLE:`
`984`	`983`	`return "ALL_LOCATIONS_NOT_REACHABLE";`
`985`		`- case EntranceShuffleError::AMBIGUOUS_RACE_MODE_ISLAND:`
`986`		`- return "AMBIGUOUS_RACE_MODE_ISLAND";`
`987`		`- case EntranceShuffleError::AMBIGUOUS_RACE_MODE_DUNGEON:`
`988`		`- return "AMBIGUOUS_RACE_MODE_DUNGEON";`
`989`		`- case EntranceShuffleError::NO_RACE_MODE_ISLAND:`
`990`		`- return "NO_RACE_MODE_ISLAND";`
	`984`	`+ case EntranceShuffleError::AMBIGUOUS_BOSS_ISLAND:`
	`985`	`+ return "AMBIGUOUS_BOSS_ISLAND";`
`991`	`986`	`case EntranceShuffleError::NOT_ENOUGH_SPHERE_ZERO_LOCATIONS:`
`992`	`987`	`return "NOT_ENOUGH_SPHERE_ZERO_LOCATIONS";`
`993`	`988`	`case EntranceShuffleError::ATTEMPTED_SELF_CONNECTION:`
Original file line number	Diff line number	Diff line change
`@@ -323,8 +323,7 @@ void placeVanillaItems(WorldPool& worlds)`
`323`	`323`	`// Determine which items are major items. A major item is any item required`
`324`	`324`	`// for access to any progression location and/or game beatability. This function`
`325`	`325`	`// is called multiple times during the fill algorithm as the items required for`
`326`		`-// beatability may change depending on which items are placed in race mode locations`
`327`		`-// and/or plandomized`
	`326`	`+// beatability may change depending on which items are placed in boss locations and/or plandomized`
`328`	`327`	`void determineMajorItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)`
`329`	`328`	`{`
`330`	`329`	`LOG_TO_DEBUG("Determining Major Items");`
`@@ -405,7 +404,7 @@ static FillError randomizeOwnDungeon(WorldPool& worlds, ItemPool& itemPool)`
`405`	`404`	`{`
`406`	`405`	`// Filter to only the dungeons locations which are progression locations`
`407`	`406`	`// If dungeons are not progression locations, or if race mode is on`
`408`		`- // and this isn't a race mode dungeon, then take all locations in`
	`407`	`+ // and this isn't a required dungeon, then take all locations in`
`409`	`408`	`// the dungeon since none of them are progression anyway`
`410`	`409`	`auto worldLocations = world.getLocations();`
`411`	`410`	`auto dungeonLocations = filterFromPool(worldLocations, [&dungeon = dungeon, &settings = settings](const Location* loc){`
`@@ -586,66 +585,67 @@ static FillError handleDungeonItems(WorldPool& worlds, ItemPool& itemPool)`
`586`	`585`	`return FillError::NONE;`
`587`	`586`	`}`
`588`	`587`
`589`		`-static void generateRaceModeItems(const LocationPool& raceModeLocations, ItemPool& raceModeItems, ItemPool& itemsToChooseFrom, ItemPool& mainItemPool)`
	`588`	`+static void generateBossItems(const LocationPool& bossLocations, ItemPool& chosenItems, ItemPool& itemsToChooseFrom, ItemPool& mainItemPool)`
`590`	`589`	`{`
`591`	`590`	`shufflePool(itemsToChooseFrom);`
`592`		`- while (!itemsToChooseFrom.empty() && raceModeItems.size() < raceModeLocations.size())`
	`591`	`+ while (!itemsToChooseFrom.empty() && chosenItems.size() < bossLocations.size())`
`593`	`592`	`{`
`594`		`- raceModeItems.push_back(popRandomElement(itemsToChooseFrom));`
	`593`	`+ chosenItems.push_back(popRandomElement(itemsToChooseFrom));`
`595`	`594`	`}`
`596`	`595`	`// Add back any unused elements`
`597`	`596`	`addElementsToPool(mainItemPool, itemsToChooseFrom);`
`598`	`597`	`}`
`599`	`598`
`600`	`599`	`// Place progression items in specific locations at the end of dungeons to require the player`
`601`	`600`	`// to beat those dungeons.`
`602`		`-static FillError placeRaceModeItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)`
	`601`	`+static FillError placeBossItems(WorldPool& worlds, ItemPool& itemPool, LocationPool& allLocations)`
`603`	`602`	`{`
`604`		`- LocationPool raceModeLocations;`
`605`		`- ItemPool raceModeItems;`
	`603`	`+ LocationPool bossLocations;`
	`604`	`+ ItemPool bossItems;`
`606`	`605`	`for (auto& world : worlds)`
`607`	`606`	`{`
`608`	`607`	`if(world.getSettings().required_boss_items) {`
`609`	`608`	`for (auto& [name, dungeon] : world.dungeons)`
`610`	`609`	`{`
`611`	`610`	`if (dungeon.isRequiredDungeon)`
`612`	`611`	`{`
`613`		`- auto raceModeLocation = dungeon.raceModeLocation;`
	`612`	`+ auto bossLocation = dungeon.bossLocation;`
`614`	`613`	`// If this location already has an item placed at it, then skip it`
`615`		`- if (raceModeLocation->currentItem.getGameItemId() != GameItem::INVALID)`
	`614`	`+ if (bossLocation->currentItem.getGameItemId() != GameItem::INVALID)`
`616`	`615`	`{`
`617`	`616`	`continue;`
`618`	`617`	`}`
`619`		`- raceModeLocations.push_back(raceModeLocation);`
	`618`	`+ bossLocations.push_back(bossLocation);`
`620`	`619`	`}`
`621`	`620`	`}`
`622`	`621`	`}`
`623`	`622`	`}`
`624`	`623`
`625`	`624`	`// Build up the list of boss items with major items.`
`626`	`625`	`auto majorItems = filterAndEraseFromPool(itemPool, [](const Item& item){return item.isMajorItem();});`
`627`		`- generateRaceModeItems(raceModeLocations, raceModeItems, majorItems, itemPool);`
	`626`	`+ generateBossItems(bossLocations, bossItems, majorItems, itemPool);`
`628`	`627`
`629`		`- // logItemPool("raceModeItems", raceModeItems);`
	`628`	`+ logItemPool("Boss Items", bossItems);`
`630`	`629`
`631`		`- if (raceModeItems.size() < raceModeLocations.size())`
	`630`	`+ if (bossItems.size() < bossLocations.size())`
`632`	`631`	`{`
`633`		`- Utility::platformLog("WARNING: Not enough major items to place at race mode locations.");`
	`632`	`+ Utility::platformLog("WARNING: Not enough major items to place at boss locations.");`
`634`	`633`	`}`
`635`	`634`
`636`		`- // Then place the items in the race mode locations`
	`635`	`+ // Then place the items in the boss locations`
`637`	`636`	`FillError err;`
`638`		`- FILL_ERROR_CHECK(assumedFill(worlds, raceModeItems, itemPool, raceModeLocations));`
	`637`	`+ FILL_ERROR_CHECK(assumedFill(worlds, bossItems, itemPool, bossLocations));`
`639`	`638`
`640`		`- // Set race mode locations which had items placed at them as having expected items`
`641`		`- for (auto raceModeLoc : raceModeLocations)`
	`639`	`+ // Set boss locations which had items placed at them as having expected items`
	`640`	`+ for (auto loc : bossLocations)`
`642`	`641`	`{`
`643`		`- raceModeLoc->hasExpectedItem = true;`
	`642`	`+ loc->hasExpectedItem = true;`
`644`	`643`	`}`
`645`	`644`
`646`	`645`	`// Recalculate major items since new items may now be required depending on`
`647`		`- // what items were placed at race mode locations`
	`646`	`+ // what items were placed at boss locations`
`648`	`647`	`determineMajorItems(worlds, itemPool, allLocations);`
	`648`	`+`
`649`	`649`	`return FillError::NONE;`
`650`	`650`	`}`
`651`	`651`
`@@ -734,10 +734,10 @@ FillError fill(WorldPool& worlds)`
`734`	`734`
`735`	`735`	`determineMajorItems(worlds, itemPool, allLocations);`
`736`	`736`	`FILL_ERROR_CHECK(placeNonProgressLocationPlandomizerItems(worlds, itemPool));`
`737`		`- // Handle dungeon items and race mode dungeons first if necessary. Generally`
	`737`	`+ // Handle dungeon and/or boss items first if necessary. Generally`
`738`	`738`	`// we need to place items that go into more restrictive location pools first before`
`739`	`739`	`// we can place other items.`
`740`		`- FILL_ERROR_CHECK(placeRaceModeItems(worlds, itemPool, allLocations));`
	`740`	`+ FILL_ERROR_CHECK(placeBossItems(worlds, itemPool, allLocations));`
`741`	`741`	`FILL_ERROR_CHECK(handleDungeonItems(worlds, itemPool));`
`742`	`742`
`743`	`743`	`// Recalculate major items again since new items may now be required depending on`
Original file line number	Diff line number	Diff line change
`@@ -156,13 +156,13 @@ int generateWorlds(WorldPool& worlds, std::vector<Settings>& settingsVector)`
`156`	`156`
`157`	`157`	`// Now that all entrances have been randomized, we can flatten the world's`
`158`	`158`	`// logic requirements for some useful operations later on`
`159`		`- // Determine race mode dungeons after entrance randomizer to ensure we pick`
	`159`	`+ // Determine required dungeons after entrance randomizer to ensure we pick`
`160`	`160`	`// dungeons which can be properly reached depending on any entrance rando settings`
`161`	`161`	`for (auto& world : worlds)`
`162`	`162`	`{`
`163`	`163`	`world.flattenLogicRequirements();`
`164`	`164`	`WORLD_LOADING_ERROR_CHECK(world.setDungeonLocations(worlds));`
`165`		`- WORLD_LOADING_ERROR_CHECK(world.determineRaceModeDungeons(worlds));`
	`165`	`+ WORLD_LOADING_ERROR_CHECK(world.determineRequiredDungeons(worlds));`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`// Retry the main fill algorithm a couple times incase it completely fails.`
Original file line number	Diff line number	Diff line change
`@@ -33,10 +33,10 @@ static HintError calculatePossiblePathLocations(WorldPool& worlds)`
`33`	`33`	`world.goalLocations.push_back(world.locationTable["Ganon's Tower - Defeat Ganondorf"].get());`
`34`	`34`	`for (auto& [name, dungeon] : world.dungeons)`
`35`	`35`	`{`
`36`		`- // Race mode locations are also goal locations`
	`36`	`+ // Boss locations are also goal locations`
`37`	`37`	`if (dungeon.isRequiredDungeon)`
`38`	`38`	`{`
`39`		`- world.goalLocations.push_back(dungeon.raceModeLocation);`
	`39`	`+ world.goalLocations.push_back(dungeon.bossLocation);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`@@ -311,7 +311,7 @@ static HintError generatePathHintLocations(World& world, std::list<Hint>& hints)`
`311`	`311`	`for (auto& goalLocation : world.goalLocations)`
`312`	`312`	`{`
`313`	`313`	`shufflePool(goalLocation->pathLocations);`
`314`		`- // Initially we want to pull path hints from race mode dungeons before pulling from Ganondorf`
	`314`	`+ // Initially we want to pull path hints from required dungeons before pulling from Ganondorf`
`315`	`315`	`if (goalLocation->getName() != "Ganon's Tower - Defeat Ganondorf")`
`316`	`316`	`{`
`317`	`317`	`goalLocations.push_back(goalLocation);`
`@@ -321,15 +321,15 @@ static HintError generatePathHintLocations(World& world, std::list<Hint>& hints)`
`321`	`321`	`bool addedGanonPathLocation = false;`
`322`	`322`	`for (uint8_t i = 0; i < world.getSettings().path_hints; i++)`
`323`	`323`	`{`
`324`		`- // Try to get at least one hint for each race mode dungeon first`
	`324`	`+ // Try to get at least one hint for each required dungeon first`
`325`	`325`	`Location* goalLocation = nullptr;`
`326`	`326`	`if (i < goalLocations.size())`
`327`	`327`	`{`
`328`	`328`	`goalLocation = goalLocations[i];`
`329`	`329`	`}`
`330`	`330`	`else`
`331`	`331`	`{`
`332`		`- // Once we've pulled from all race mode dungeons, then add Ganondorf to the list`
	`332`	`+ // Once we've pulled from all required dungeons, then add Ganondorf to the list`
`333`	`333`	`// and choose randomly`
`334`	`334`	`if (i == goalLocations.size() && !addedGanonPathLocation)`
`335`	`335`	`{`
`@@ -650,7 +650,7 @@ static HintError generateLocationHintLocations(World& world, std::list<Hint>& hi`
`650`	`650`	`{`
`651`	`651`	`if (location->progression &&`
`652`	`652`	`!location->hasBeenHinted &&`
`653`		`- !location->isRaceModeLocation &&`
	`653`	`+ !location->isBossLocation &&`
`654`	`654`	`location->hintPriority == "Sometimes" &&`
`655`	`655`	`!(world.getSettings().ho_ho_triforce_hints && location->currentItem.isTriforceShard()))`
`656`	`656`	`{`
Original file line number	Diff line number	Diff line change
`@@ -187,7 +187,7 @@ bool Location::currentItemCanBeBarren() const`
`187`	`187`	`// if it's a required race mode location`
`188`	`188`	`bool Location::isBarrenAsChainLocation() const`
`189`	`189`	`{`
`190`		`- return !progression \|\| (currentItem.canBeInBarrenRegion() && !isRequiredRaceModeLocation);`
	`190`	`+ return !progression \|\| (currentItem.canBeInBarrenRegion() && !isRequiredBossLocation);`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`std::u16string Location::generateImportanceText(const std::string& language)`