mirror/Shipwright
1
0
Fork 0
mirror of https://github.com/HarbourMasters/Shipwright.git synced 2024-11-25 10:52:19 -05:00
Code Issues Projects Releases Wiki Activity

Clean up location table (#4258)

Browse Source 
* Remove categories

* Remove SpoilerCollectionCheckGroup

* Remove unused Location constructors

* Remove LocationType

* Remove unused SpoilerCollectionCheckTypes

* Remove hints' isVanillaCompletion, it's always false

* Remove SpoilerCollectionCheck::None

Same effect as default constructor

* Fix mistake

* Update location.h

* Deduce RC Area by scene when possible

* Remove useless constructors

* Remove flag in most situations

* Format improvements

* Replace overworldLocations with a function

* Replace shopLocationLists with a function

* Replace gossipStoneLocations with a function

Also add a new RCType for static hints

* Replace scrubLocations with a function

* Replace staticHintLocations with a function

* Replace overworldFishLocations with a function

* Replace pondFishLocations with a function

* Remove RC_TRIFORCE_COMPLETED from GetOverworldLocations

* Update fill.cpp

Re-add filter for dungeonLocations for song shuffle dungeon rewards (and fix erroneous check for song locations there).
Modify songLocations filter for dungeon rewards to check for RCTYPE_BOSS_HEART_OR_OTHER_REWARD and then the two song locations added for it.

* Update fill.cpp

Fix bracketing.

* Apply Pepper0ni's patch

---------

Co-authored-by: Malkierian <malkierian@live.com>
This commit is contained in:
Pepe20129 2024-10-01 18:50:47 +02:00 committed by GitHub
parent 668f0fe4c6
commit 0cfd535fe6
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
22 changed files with 1404 additions and 2199 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
soh/soh/Enhancements/randomizer/3drando/category.hpp
View File

@ -1,26 +1,5 @@
#pragma once #pragma once
enum class Category {
cNull,
cChestMinigame,
cDekuScrub,
cDekuScrubUpgrades,
cSkulltula,
cSong,
cSongDungeonReward,
cCow,
cFish,
cShop,
cMerchant,
cVanillaSmallKey,
cVanillaGFSmallKey,
cVanillaBossKey,
cVanillaMap,
cVanillaCompass,
cAdultTrade,
cBeehive,
};
enum class OptionCategory { enum class OptionCategory {
Setting, Setting,
Toggle, Toggle,

62
soh/soh/Enhancements/randomizer/3drando/fill.cpp
View File

@ -977,12 +977,14 @@ static void RandomizeOwnDungeon(const Rando::DungeonInfo* dungeon) {
}); });
//filter out locations that may be required to have songs placed at them //filter out locations that may be required to have songs placed at them
dungeonLocations = FilterFromPool(dungeonLocations, [ctx](const auto loc){ dungeonLocations = FilterFromPool(dungeonLocations, [ctx](const auto loc) {
if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_SONG_LOCATIONS)) { if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_SONG_LOCATIONS)) {
return !(Rando::StaticData::GetLocation(loc)->IsCategory(Category::cSong)); return !(Rando::StaticData::GetLocation(loc)->GetRCType() == RCTYPE_SONG_LOCATION);
} }
if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_SONG_LOCATIONS)) { if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_DUNGEON_REWARDS)) {
return !(Rando::StaticData::GetLocation(loc)->IsCategory(Category::cSongDungeonReward)); return !(Rando::StaticData::GetLocation(loc)->GetRCType() == RCTYPE_BOSS_HEART_OR_OTHER_REWARD ||
loc == RC_SHEIK_IN_ICE_CAVERN ||
loc == RC_SONG_FROM_IMPA);
} }
return true; return true;
}); });
@ -1022,7 +1024,7 @@ static void RandomizeDungeonItems() {
//Get Any Dungeon and Overworld group locations //Get Any Dungeon and Overworld group locations
std::vector<RandomizerCheck> anyDungeonLocations = FilterFromPool(ctx->allLocations, [](const auto loc){return Rando::StaticData::GetLocation(loc)->IsDungeon();}); std::vector<RandomizerCheck> anyDungeonLocations = FilterFromPool(ctx->allLocations, [](const auto loc){return Rando::StaticData::GetLocation(loc)->IsDungeon();});
//overworldLocations defined in item_location.cpp //Rando::StaticData::GetOverworldLocations() defined in item_location.cpp
//Create Any Dungeon and Overworld item pools //Create Any Dungeon and Overworld item pools
std::vector<RandomizerGet> anyDungeonItems; std::vector<RandomizerGet> anyDungeonItems;
@ -1074,7 +1076,7 @@ static void RandomizeDungeonItems() {
//Randomize Any Dungeon and Overworld pools //Randomize Any Dungeon and Overworld pools
AssumedFill(anyDungeonItems, anyDungeonLocations, true); AssumedFill(anyDungeonItems, anyDungeonLocations, true);
AssumedFill(overworldItems, Rando::StaticData::overworldLocations, true); AssumedFill(overworldItems, Rando::StaticData::GetOverworldLocations(), true);
//Randomize maps and compasses after since they're not advancement items //Randomize maps and compasses after since they're not advancement items
for (auto dungeon : ctx->GetDungeons()->GetDungeonList()) { for (auto dungeon : ctx->GetDungeons()->GetDungeonList()) {
@ -1083,7 +1085,7 @@ static void RandomizeDungeonItems() {
AssumedFill(mapAndCompassItems, anyDungeonLocations, true); AssumedFill(mapAndCompassItems, anyDungeonLocations, true);
} else if (ctx->GetOption(RSK_SHUFFLE_MAPANDCOMPASS).Is(RO_DUNGEON_ITEM_LOC_OVERWORLD)) { } else if (ctx->GetOption(RSK_SHUFFLE_MAPANDCOMPASS).Is(RO_DUNGEON_ITEM_LOC_OVERWORLD)) {
auto mapAndCompassItems = FilterAndEraseFromPool(ItemPool, [dungeon](const RandomizerGet i){return i == dungeon->GetMap() || i == dungeon->GetCompass();}); auto mapAndCompassItems = FilterAndEraseFromPool(ItemPool, [dungeon](const RandomizerGet i){return i == dungeon->GetMap() || i == dungeon->GetCompass();});
AssumedFill(mapAndCompassItems, Rando::StaticData::overworldLocations, true); AssumedFill(mapAndCompassItems, Rando::StaticData::GetOverworldLocations(), true);
} }
} }
} }
@ -1192,17 +1194,19 @@ int Fill() {
//Indices from OoTR. So shopsanity one will overwrite 7, three will overwrite 7, 5, 8, etc. //Indices from OoTR. So shopsanity one will overwrite 7, three will overwrite 7, 5, 8, etc.
const std::array<int, 4> indices = {7, 5, 8, 6}; const std::array<int, 4> indices = {7, 5, 8, 6};
//Overwrite appropriate number of shop items //Overwrite appropriate number of shop items
for (size_t i = 0; i < Rando::StaticData::shopLocationLists.size(); i++) { #define LOCATIONS_PER_SHOP 8
for (size_t i = 0; i < Rando::StaticData::GetShopLocations().size() / LOCATIONS_PER_SHOP; i++) {
int num_to_replace = GetShopsanityReplaceAmount(); //1-4 shop items will be overwritten, depending on settings int num_to_replace = GetShopsanityReplaceAmount(); //1-4 shop items will be overwritten, depending on settings
total_replaced += num_to_replace; total_replaced += num_to_replace;
for (int j = 0; j < num_to_replace; j++) { for (int j = 0; j < num_to_replace; j++) {
int itemindex = indices[j]; int itemindex = indices[j];
int shopsanityPrice = GetRandomShopPrice(); int shopsanityPrice = GetRandomShopPrice();
NonShopItems[TransformShopIndex(i * 8 + itemindex - 1)].Price = NonShopItems[TransformShopIndex(i * LOCATIONS_PER_SHOP + itemindex - 1)].Price =
shopsanityPrice; // Set price to be retrieved by the patch and textboxes shopsanityPrice; // Set price to be retrieved by the patch and textboxes
ctx->GetItemLocation(Rando::StaticData::shopLocationLists[i][itemindex - 1])->SetCustomPrice(shopsanityPrice); ctx->GetItemLocation(Rando::StaticData::GetShopLocations()[i * LOCATIONS_PER_SHOP + itemindex - 1])->SetCustomPrice(shopsanityPrice);
} }
} }
#undef LOCATIONS_PER_SHOP
} }
//Get all locations and items that don't have a shopsanity price attached //Get all locations and items that don't have a shopsanity price attached
std::vector<RandomizerCheck> shopLocations = {}; std::vector<RandomizerCheck> shopLocations = {};
@ -1210,12 +1214,9 @@ int Fill() {
//So shopsanity 0 will get all 64 vanilla items, shopsanity 4 will get 32, etc. //So shopsanity 0 will get all 64 vanilla items, shopsanity 4 will get 32, etc.
std::vector<RandomizerGet> shopItems = GetMinVanillaShopItems(total_replaced); std::vector<RandomizerGet> shopItems = GetMinVanillaShopItems(total_replaced);
for (size_t i = 0; i < Rando::StaticData::shopLocationLists.size(); i++) { for (RandomizerCheck& randomizerCheck : Rando::StaticData::GetShopLocations()) {
for (size_t j = 0; j < Rando::StaticData::shopLocationLists[i].size(); j++) { if (!(ctx->GetItemLocation(randomizerCheck)->HasCustomPrice())) {
RandomizerCheck loc = Rando::StaticData::shopLocationLists[i][j]; shopLocations.push_back(randomizerCheck);
if (!(ctx->GetItemLocation(loc)->HasCustomPrice())) {
shopLocations.push_back(loc);
}
} }
} }
//Place the shop items which will still be at shop locations //Place the shop items which will still be at shop locations
@ -1246,11 +1247,13 @@ int Fill() {
std::vector<RandomizerCheck> songLocations; std::vector<RandomizerCheck> songLocations;
if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_SONG_LOCATIONS)) { if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_SONG_LOCATIONS)) {
songLocations = FilterFromPool( songLocations = FilterFromPool(
ctx->allLocations, [](const auto loc) { return Rando::StaticData::GetLocation(loc)->IsCategory(Category::cSong); }); ctx->allLocations, [](const auto loc) { return Rando::StaticData::GetLocation(loc)->GetRCType() == RCTYPE_SONG_LOCATION; });
} else if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_DUNGEON_REWARDS)) { } else if (ctx->GetOption(RSK_SHUFFLE_SONGS).Is(RO_SONG_SHUFFLE_DUNGEON_REWARDS)) {
songLocations = FilterFromPool(ctx->allLocations, [](const auto loc) { songLocations = FilterFromPool(ctx->allLocations, [](const auto loc) {
return Rando::StaticData::GetLocation(loc)->IsCategory(Category::cSongDungeonReward); return Rando::StaticData::GetLocation(loc)->GetRCType() == RCTYPE_BOSS_HEART_OR_OTHER_REWARD ||
loc == RC_SHEIK_IN_ICE_CAVERN ||
loc == RC_SONG_FROM_IMPA;
}); });
} }
@ -1282,26 +1285,25 @@ int Fill() {
StopPerformanceTimer(PT_REMAINING_ITEMS); StopPerformanceTimer(PT_REMAINING_ITEMS);
//Add default prices to scrubs //Add default prices to scrubs
for (size_t i = 0; i < Rando::StaticData::scrubLocations.size(); i++) { for (RandomizerCheck& randomizerCheck : Rando::StaticData::GetScrubLocations()) {
if (Rando::StaticData::scrubLocations[i] == RC_LW_DEKU_SCRUB_NEAR_BRIDGE || Rando::StaticData::scrubLocations[i] == RC_LW_DEKU_SCRUB_GROTTO_FRONT) { if (randomizerCheck == RC_LW_DEKU_SCRUB_NEAR_BRIDGE || randomizerCheck == RC_LW_DEKU_SCRUB_GROTTO_FRONT) {
ctx->GetItemLocation(Rando::StaticData::scrubLocations[i])->SetCustomPrice(40); ctx->GetItemLocation(randomizerCheck)->SetCustomPrice(40);
} else if (Rando::StaticData::scrubLocations[i] == RC_HF_DEKU_SCRUB_GROTTO) { } else if (randomizerCheck == RC_HF_DEKU_SCRUB_GROTTO) {
ctx->GetItemLocation(Rando::StaticData::scrubLocations[i])->SetCustomPrice(10); ctx->GetItemLocation(randomizerCheck)->SetCustomPrice(10);
} else { } else {
auto loc = Rando::StaticData::GetLocation(Rando::StaticData::scrubLocations[i]); auto loc = Rando::StaticData::GetLocation(randomizerCheck);
auto item = Rando::StaticData::RetrieveItem(loc->GetVanillaItem()); auto item = Rando::StaticData::RetrieveItem(loc->GetVanillaItem());
ctx->GetItemLocation(Rando::StaticData::scrubLocations[i])->SetCustomPrice(item.GetPrice()); ctx->GetItemLocation(randomizerCheck)->SetCustomPrice(item.GetPrice());
} }
} }
if (ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_AFFORDABLE)) { if (ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_AFFORDABLE)) {
for (size_t i = 0; i < Rando::StaticData::scrubLocations.size(); i++) { for (RandomizerCheck& randomizerCheck : Rando::StaticData::GetScrubLocations()) {
ctx->GetItemLocation(Rando::StaticData::scrubLocations[i])->SetCustomPrice(10); ctx->GetItemLocation(randomizerCheck)->SetCustomPrice(10);
} }
} else if (ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_RANDOM)) { } else if (ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_RANDOM)) {
for (size_t i = 0; i < Rando::StaticData::scrubLocations.size(); i++) { for (RandomizerCheck& randomizerCheck : Rando::StaticData::GetScrubLocations()) {
int randomPrice = GetRandomScrubPrice(); ctx->GetItemLocation(randomizerCheck)->SetCustomPrice(GetRandomScrubPrice());
ctx->GetItemLocation(Rando::StaticData::scrubLocations[i])->SetCustomPrice(randomPrice);
} }
} }

6
soh/soh/Enhancements/randomizer/3drando/hints.cpp
View File

@ -136,7 +136,7 @@ bool FilterFoolishLocations(RandomizerCheck loc){
bool FilterSongLocations(RandomizerCheck loc){ bool FilterSongLocations(RandomizerCheck loc){
auto ctx = Rando::Context::GetInstance(); auto ctx = Rando::Context::GetInstance();
return Rando::StaticData::GetLocation(loc)->IsCategory(Category::cSong); return Rando::StaticData::GetLocation(loc)->GetRCType() == RCTYPE_SONG_LOCATION;
} }
bool FilterOverworldLocations(RandomizerCheck loc){ bool FilterOverworldLocations(RandomizerCheck loc){
@ -316,7 +316,7 @@ std::vector<std::pair<RandomizerCheck, std::function<bool()>>> conditionalAlways
}; };
static std::vector<RandomizerCheck> GetEmptyGossipStones() { static std::vector<RandomizerCheck> GetEmptyGossipStones() {
auto emptyGossipStones = GetEmptyLocations(Rando::StaticData::gossipStoneLocations); auto emptyGossipStones = GetEmptyLocations(Rando::StaticData::GetGossipStoneLocations());
return emptyGossipStones; return emptyGossipStones;
} }
@ -328,7 +328,7 @@ static std::vector<RandomizerCheck> GetAccessibleGossipStones(const RandomizerCh
ctx->GetItemLocation(hintedLocation)->SetPlacedItem(RG_NONE); ctx->GetItemLocation(hintedLocation)->SetPlacedItem(RG_NONE);
ctx->GetLogic()->Reset(); ctx->GetLogic()->Reset();
auto accessibleGossipStones = ReachabilitySearch(Rando::StaticData::gossipStoneLocations); auto accessibleGossipStones = ReachabilitySearch(Rando::StaticData::GetGossipStoneLocations());
//Give the item back to the location //Give the item back to the location
ctx->GetItemLocation(hintedLocation)->SetPlacedItem(originalItem); ctx->GetItemLocation(hintedLocation)->SetPlacedItem(originalItem);

10
soh/soh/Enhancements/randomizer/3drando/item_pool.cpp
View File

@ -613,7 +613,7 @@ static void PlaceVanillaCowMilk() {
static void PlaceVanillaOverworldFish() { static void PlaceVanillaOverworldFish() {
auto ctx = Rando::Context::GetInstance(); auto ctx = Rando::Context::GetInstance();
for (auto rc : Rando::StaticData::overworldFishLocations) { for (auto rc : Rando::StaticData::GetOverworldFishLocations()) {
ctx->PlaceItemInLocation(rc, RG_FISH, false, true); ctx->PlaceItemInLocation(rc, RG_FISH, false, true);
} }
} }
@ -830,7 +830,7 @@ void GenerateItemPool() {
} }
// 9 grotto fish, 5 zora's domain fish // 9 grotto fish, 5 zora's domain fish
if (fsMode.Is(RO_FISHSANITY_OVERWORLD) || fsMode.Is(RO_FISHSANITY_BOTH)) { if (fsMode.Is(RO_FISHSANITY_OVERWORLD) || fsMode.Is(RO_FISHSANITY_BOTH)) {
for (uint8_t i = 0; i < Rando::StaticData::overworldFishLocations.size(); i++) for (uint8_t i = 0; i < Rando::StaticData::GetOverworldFishLocations().size(); i++)
AddItemToMainPool(GetJunkItem()); AddItemToMainPool(GetJunkItem());
} else { } else {
PlaceVanillaOverworldFish(); PlaceVanillaOverworldFish();
@ -936,11 +936,11 @@ void GenerateItemPool() {
}; };
if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OFF)) { if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OFF)) {
for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, Category::cSkulltula)) { for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, RCTYPE_SKULL_TOKEN)) {
ctx->PlaceItemInLocation(loc, RG_GOLD_SKULLTULA_TOKEN, false, true); ctx->PlaceItemInLocation(loc, RG_GOLD_SKULLTULA_TOKEN, false, true);
} }
} else if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_DUNGEONS)) { } else if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_DUNGEONS)) {
for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, Category::cSkulltula)) { for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, RCTYPE_SKULL_TOKEN)) {
if (Rando::StaticData::GetLocation(loc)->IsOverworld()) { if (Rando::StaticData::GetLocation(loc)->IsOverworld()) {
ctx->PlaceItemInLocation((RandomizerCheck)loc, RG_GOLD_SKULLTULA_TOKEN, false, true); ctx->PlaceItemInLocation((RandomizerCheck)loc, RG_GOLD_SKULLTULA_TOKEN, false, true);
} else { } else {
@ -948,7 +948,7 @@ void GenerateItemPool() {
} }
} }
} else if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OVERWORLD)) { } else if (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OVERWORLD)) {
for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, Category::cSkulltula)) { for (RandomizerCheck loc : ctx->GetLocations(ctx->allLocations, RCTYPE_SKULL_TOKEN)) {
if (Rando::StaticData::GetLocation(loc)->IsDungeon()) { if (Rando::StaticData::GetLocation(loc)->IsDungeon()) {
ctx->PlaceItemInLocation((RandomizerCheck)loc, RG_GOLD_SKULLTULA_TOKEN, false, true); ctx->PlaceItemInLocation((RandomizerCheck)loc, RG_GOLD_SKULLTULA_TOKEN, false, true);
} else { } else {

2
soh/soh/Enhancements/randomizer/3drando/location_access.cpp
View File

@ -47,7 +47,7 @@ bool LocationAccess::ConditionsMet() const {
bool LocationAccess::CanBuy() const { bool LocationAccess::CanBuy() const {
auto ctx = Rando::Context::GetInstance(); auto ctx = Rando::Context::GetInstance();
//Not a shop or scrub location, don't need to check if buyable //Not a shop or scrub location, don't need to check if buyable
if (!(Rando::StaticData::GetLocation(location)->IsCategory(Category::cShop)) && !(Rando::StaticData::GetLocation(location)->IsCategory(Category::cDekuScrub))) { if (Rando::StaticData::GetLocation(location)->GetRCType() != RCTYPE_SHOP && Rando::StaticData::GetLocation(location)->GetRCType() != RCTYPE_SCRUB) {
return true; return true;
} }

6
soh/soh/Enhancements/randomizer/3drando/shops.cpp
View File

@ -17,10 +17,8 @@ bool initTrickNames = false; //Indicates if trick ice trap names have been initi
void PlaceVanillaShopItems() { void PlaceVanillaShopItems() {
auto ctx = Rando::Context::GetInstance(); auto ctx = Rando::Context::GetInstance();
//Loop to place vanilla items in each location //Loop to place vanilla items in each location
for (size_t i = 0; i < Rando::StaticData::shopLocationLists.size(); i++) { for (RandomizerCheck& randomizerCheck : Rando::StaticData::GetShopLocations()) {
for (size_t j = 0; j < Rando::StaticData::shopLocationLists[i].size(); j++) { ctx->GetItemLocation(randomizerCheck)->PlaceVanillaItem();
ctx->GetItemLocation(Rando::StaticData::shopLocationLists[i][j])->PlaceVanillaItem();
}
} }
} }

65
soh/soh/Enhancements/randomizer/3drando/spoiler_log.cpp
View File

@ -85,9 +85,9 @@ void WriteIngameSpoilerLog() {
uint16_t spoilerItemIndex = 0; uint16_t spoilerItemIndex = 0;
uint32_t spoilerStringOffset = 0; uint32_t spoilerStringOffset = 0;
uint16_t spoilerSphereItemoffset = 0; uint16_t spoilerSphereItemoffset = 0;
uint16_t spoilerGroupOffset = 0; uint16_t spoilerAreaOffset = 0;
// Intentionally junk value so we trigger the 'new group, record some stuff' code // Intentionally junk value so we trigger the 'new area, record some stuff' code
uint8_t currentGroup = SpoilerCollectionCheckGroup::SPOILER_COLLECTION_GROUP_COUNT; RandomizerCheckArea currentArea = RandomizerCheckArea::RCAREA_INVALID;
bool spoilerOutOfSpace = false; bool spoilerOutOfSpace = false;
// Create map of string data offsets for all _unique_ item locations and names in the playthrough // Create map of string data offsets for all _unique_ item locations and names in the playthrough
@ -99,12 +99,12 @@ void WriteIngameSpoilerLog() {
stringOffsetMap; // Map of strings to their offset into spoiler string data array stringOffsetMap; // Map of strings to their offset into spoiler string data array
stringOffsetMap.reserve(ctx->allLocations.size() * 2); stringOffsetMap.reserve(ctx->allLocations.size() * 2);
// Sort all locations by their group, so the in-game log can show a group of items by simply starting/ending at // Sort all locations by their area, so the in-game log can show a area of items by simply starting/ending at
// certain indices // certain indices
std::stable_sort(ctx->allLocations.begin(), ctx->allLocations.end(), [](const RandomizerCheck& a, const RandomizerCheck& b) { std::stable_sort(ctx->allLocations.begin(), ctx->allLocations.end(), [](const RandomizerCheck& a, const RandomizerCheck& b) {
auto groupA = Rando::StaticData::GetLocation(a)->GetCollectionCheckGroup(); RandomizerCheckArea areaA = Rando::StaticData::GetLocation(a)->GetArea();
auto groupB = Rando::StaticData::GetLocation(b)->GetCollectionCheckGroup(); RandomizerCheckArea areaB = Rando::StaticData::GetLocation(b)->GetArea();
return groupA < groupB; return areaA < areaB;
}); });
for (const RandomizerCheck key : ctx->allLocations) { for (const RandomizerCheck key : ctx->allLocations) {
@ -116,30 +116,29 @@ void WriteIngameSpoilerLog() {
// continue; // continue;
// } // }
// Beehives // Beehives
if (!ctx->GetOption(RSK_SHUFFLE_BEEHIVES) && loc->IsCategory(Category::cBeehive)) { if (!ctx->GetOption(RSK_SHUFFLE_BEEHIVES) && loc->GetRCType() == RCTYPE_BEEHIVE) {
continue; continue;
} }
// Cows // Cows
else if (!ctx->GetOption(RSK_SHUFFLE_COWS) && loc->IsCategory(Category::cCow)) { else if (!ctx->GetOption(RSK_SHUFFLE_COWS) && loc->GetRCType() == RCTYPE_COW) {
continue; continue;
} }
// Merchants // Merchants
else if (ctx->GetOption(RSK_SHUFFLE_MERCHANTS).Is(RO_SHUFFLE_MERCHANTS_OFF) && loc->IsCategory(Category::cMerchant)) { else if (ctx->GetOption(RSK_SHUFFLE_MERCHANTS).Is(RO_SHUFFLE_MERCHANTS_OFF) && loc->GetRCType() == RCTYPE_MERCHANT) {
continue; continue;
} }
// Adult Trade // Adult Trade
else if (!ctx->GetOption(RSK_SHUFFLE_ADULT_TRADE) && loc->IsCategory(Category::cAdultTrade)) { else if (!ctx->GetOption(RSK_SHUFFLE_ADULT_TRADE) && loc->GetRCType() == RCTYPE_ADULT_TRADE) {
continue; continue;
} }
// Chest Minigame // Chest Minigame
else if (ctx->GetOption(RSK_SHUFFLE_CHEST_MINIGAME).Is(RO_GENERIC_OFF) && else if (ctx->GetOption(RSK_SHUFFLE_CHEST_MINIGAME).Is(RO_GENERIC_OFF) && loc->GetRCType() == RCTYPE_CHEST_GAME) {
loc->IsCategory(Category::cChestMinigame)) {
continue; continue;
} }
// Gerudo Fortress // Gerudo Fortress
else if ((ctx->GetOption(RSK_GERUDO_FORTRESS).Is(RO_GF_NORMAL) && else if ((ctx->GetOption(RSK_GERUDO_FORTRESS).Is(RO_GF_NORMAL) &&
(loc->IsCategory(Category::cVanillaGFSmallKey) || loc->GetHintKey() == RHT_GF_GERUDO_MEMBERSHIP_CARD)) || (loc->GetRCType() == RCTYPE_GF_KEY || loc->GetHintKey() == RHT_GF_GERUDO_MEMBERSHIP_CARD)) ||
(ctx->GetOption(RSK_GERUDO_FORTRESS).Is(RO_GF_FAST) && loc->IsCategory(Category::cVanillaGFSmallKey) && (ctx->GetOption(RSK_GERUDO_FORTRESS).Is(RO_GF_FAST) && loc->GetRCType() == RCTYPE_GF_KEY &&
loc->GetHintKey() != RHT_GF_NORTH_F1_CARPENTER)) { loc->GetHintKey() != RHT_GF_NORTH_F1_CARPENTER)) {
continue; continue;
} }
@ -160,7 +159,7 @@ void WriteIngameSpoilerLog() {
} }
// PURPLE TODO: LOCALIZATION // PURPLE TODO: LOCALIZATION
auto locItem = itemLocation->GetPlacedItemName().GetEnglish(); auto locItem = itemLocation->GetPlacedItemName().GetEnglish();
if (itemLocation->GetPlacedRandomizerGet() == RG_ICE_TRAP && loc->IsCategory(Category::cShop)) { if (itemLocation->GetPlacedRandomizerGet() == RG_ICE_TRAP && loc->GetRCType() == RCTYPE_SHOP) {
locItem = NonShopItems[TransformShopIndex(GetShopIndex(key))].Name.GetEnglish(); locItem = NonShopItems[TransformShopIndex(GetShopIndex(key))].Name.GetEnglish();
} }
if (stringOffsetMap.find(locItem) == stringOffsetMap.end()) { if (stringOffsetMap.find(locItem) == stringOffsetMap.end()) {
@ -201,29 +200,37 @@ void WriteIngameSpoilerLog() {
} }
} }
// Gold Skulltulas // Gold Skulltulas
else if (loc->IsCategory(Category::cSkulltula) && else if (loc->GetRCType() == RCTYPE_SKULL_TOKEN &&
((ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OFF)) || ((ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OFF)) ||
(ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_DUNGEONS) && !loc->IsDungeon()) || (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_DUNGEONS) && !loc->IsDungeon()) ||
(ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OVERWORLD) && loc->IsDungeon()))) { (ctx->GetOption(RSK_SHUFFLE_TOKENS).Is(RO_TOKENSANITY_OVERWORLD) && loc->IsDungeon()))) {
spoilerData.ItemLocations[spoilerItemIndex].RevealType = REVEALTYPE_ALWAYS; spoilerData.ItemLocations[spoilerItemIndex].RevealType = REVEALTYPE_ALWAYS;
} }
// Deku Scrubs // Deku Scrubs
else if (loc->IsCategory(Category::cDekuScrub) && !loc->IsCategory(Category::cDekuScrubUpgrades) && else if (
ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_OFF)) { loc->GetRCType() == RCTYPE_SCRUB &&
// these 3 scrubs are always randomized
!(
loc->GetRandomizerCheck() == RC_LW_DEKU_SCRUB_NEAR_BRIDGE ||
loc->GetRandomizerCheck() == RC_LW_DEKU_SCRUB_GROTTO_FRONT ||
loc->GetRandomizerCheck() == RC_HF_DEKU_SCRUB_GROTTO
) &&
ctx->GetOption(RSK_SHUFFLE_SCRUBS).Is(RO_SCRUBS_OFF)
) {
spoilerData.ItemLocations[spoilerItemIndex].CollectType = COLLECTTYPE_REPEATABLE; spoilerData.ItemLocations[spoilerItemIndex].CollectType = COLLECTTYPE_REPEATABLE;
spoilerData.ItemLocations[spoilerItemIndex].RevealType = REVEALTYPE_ALWAYS; spoilerData.ItemLocations[spoilerItemIndex].RevealType = REVEALTYPE_ALWAYS;
} }
auto checkGroup = loc->GetCollectionCheckGroup(); RandomizerCheckArea checkArea = loc->GetArea();
spoilerData.ItemLocations[spoilerItemIndex].Group = checkGroup; spoilerData.ItemLocations[spoilerItemIndex].Area = checkArea;
// Group setup // Area setup
if (checkGroup != currentGroup) { if (checkArea != currentArea) {
currentGroup = checkGroup; currentArea = checkArea;
spoilerData.GroupOffsets[currentGroup] = spoilerGroupOffset; spoilerData.AreaOffsets[currentArea] = spoilerAreaOffset;
} }
++spoilerData.GroupItemCounts[currentGroup]; ++spoilerData.AreaItemCounts[currentArea];
++spoilerGroupOffset; ++spoilerAreaOffset;
itemLocationsMap[key] = spoilerItemIndex++; itemLocationsMap[key] = spoilerItemIndex++;
} }
@ -287,7 +294,7 @@ static void WriteLocation(
// // Insert a padding so we get a kind of table in the XML document. // // Insert a padding so we get a kind of table in the XML document.
// int16_t requiredPadding = LONGEST_NAME - location->GetName().length(); // int16_t requiredPadding = LONGEST_NAME - location->GetName().length();
// if (location->IsCategory(Category::cShop)) { // if (location->GetRCType() == RCTYPE_SHOP) {
// // Shop items have short location names, but come with an additional price attribute. // // Shop items have short location names, but come with an additional price attribute.
// requiredPadding -= PRICE_ATTRIBUTE; // requiredPadding -= PRICE_ATTRIBUTE;
// } // }
@ -297,7 +304,7 @@ static void WriteLocation(
// } // }
// } // }
// if (location->IsCategory(Category::cShop)) { // if (location->GetRCType() == RCTYPE_SHOP) {
// char price[6]; // char price[6];
// sprintf(price, "%03d", location->GetPrice()); // sprintf(price, "%03d", location->GetPrice());
// node->SetAttribute("price", price); // node->SetAttribute("price", price);

43
soh/soh/Enhancements/randomizer/3drando/spoiler_log.hpp
View File

@ -11,53 +11,16 @@ using RandomizerHash = std::array<std::string, 5>;
typedef enum { typedef enum {
SPOILER_CHK_NONE, SPOILER_CHK_NONE,
SPOILER_CHK_ALWAYS_COLLECTED,
SPOILER_CHK_CHEST, SPOILER_CHK_CHEST,
SPOILER_CHK_COLLECTABLE, SPOILER_CHK_COLLECTABLE,
SPOILER_CHK_GOLD_SKULLTULA, SPOILER_CHK_GOLD_SKULLTULA,
SPOILER_CHK_ITEM_GET_INF, SPOILER_CHK_ITEM_GET_INF,
SPOILER_CHK_EVENT_CHK_INF, SPOILER_CHK_EVENT_CHK_INF,
SPOILER_CHK_INF_TABLE, SPOILER_CHK_INF_TABLE,
SPOILER_CHK_FISH,
SPOILER_CHK_MINIGAME,
SPOILER_CHK_POE_POINTS,
SPOILER_CHK_SHOP_ITEM,
SPOILER_CHK_MASTER_SWORD,
SPOILER_CHK_GRAVEDIGGER, SPOILER_CHK_GRAVEDIGGER,
SPOILER_CHK_RANDOMIZER_INF, SPOILER_CHK_RANDOMIZER_INF,
} SpoilerCollectionCheckType; } SpoilerCollectionCheckType;
// GetLocation groups for checks, used to group the checks by logical location
typedef enum {
GROUP_NO_GROUP,
GROUP_KOKIRI_FOREST, // 0x55, 0x28
GROUP_LOST_WOODS, // 0x5B, 0x56
GROUP_DUNGEON_DEKU_TREE, // 0x00, 0x11
GROUP_DUNGEON_FOREST_TEMPLE, // 0x03
GROUP_KAKARIKO, // 0x37, 0x42, 0x3F, 0x40, 0x41, 0x48, 0x52, 0x53
GROUP_DUNGEON_BOTTOM_OF_THE_WELL, // 0x08
GROUP_DUNGEON_SHADOW_TEMPLE, // 0x07
GROUP_DEATH_MOUNTAIN, // 0x60, 0x61
GROUP_GORON_CITY, // 0x62
GROUP_DUNGEON_DODONGOS_CAVERN, // 0x01, 0x12
GROUP_DUNGEON_FIRE_TEMPLE, // 0x04
GROUP_ZORAS_RIVER, // 0x54
GROUP_ZORAS_DOMAIN, // 0x58, 0x59
GROUP_DUNGEON_JABUJABUS_BELLY, // 0x02, 0x13
GROUP_DUNGEON_ICE_CAVERN, // 0x09
GROUP_HYRULE_FIELD, // 0x51
GROUP_LON_LON_RANCH, // 0x4C
GROUP_LAKE_HYLIA, // 0x57
GROUP_DUNGEON_WATER_TEMPLE, // 0x05
GROUP_GERUDO_VALLEY, // 0x5A, 0x5D, 0x0C, 0x5E, 0x5C
GROUP_GERUDO_TRAINING_GROUND, // 0x0B
GROUP_DUNGEON_SPIRIT_TEMPLE, // 0x06
GROUP_HYRULE_CASTLE, // 0x10, 0x4B, 0x35, 0x42, 0x4D, 0x5F, 0x4A
GROUP_DUNGEON_GANONS_CASTLE, // 0x0A, 0x0D, 0x0E, 0x0F
SPOILER_COLLECTION_GROUP_COUNT,
// Grottos are all 0x3E
} SpoilerCollectionCheckGroup;
typedef enum { typedef enum {
COLLECTTYPE_NORMAL, COLLECTTYPE_NORMAL,
COLLECTTYPE_REPEATABLE, COLLECTTYPE_REPEATABLE,
@ -82,7 +45,7 @@ typedef struct {
SpoilerCollectionCheckType CollectionCheckType; SpoilerCollectionCheckType CollectionCheckType;
uint8_t LocationScene; uint8_t LocationScene;
uint8_t LocationFlag; uint8_t LocationFlag;
SpoilerCollectionCheckGroup Group; RandomizerCheckArea Area;
SpoilerItemCollectType CollectType; SpoilerItemCollectType CollectType;
SpoilerItemRevealType RevealType; SpoilerItemRevealType RevealType;
} SpoilerItemLocation; } SpoilerItemLocation;
@ -99,8 +62,8 @@ typedef struct {
SpoilerItemLocation ItemLocations[SPOILER_ITEMS_MAX]; SpoilerItemLocation ItemLocations[SPOILER_ITEMS_MAX];
uint16_t SphereItemLocations[SPOILER_ITEMS_MAX]; uint16_t SphereItemLocations[SPOILER_ITEMS_MAX];
char StringData[SPOILER_STRING_DATA_SIZE]; char StringData[SPOILER_STRING_DATA_SIZE];
uint16_t GroupItemCounts[SPOILER_COLLECTION_GROUP_COUNT]; uint16_t AreaItemCounts[RCAREA_INVALID];
uint16_t GroupOffsets[SPOILER_COLLECTION_GROUP_COUNT]; uint16_t AreaOffsets[RCAREA_INVALID];
} SpoilerData; } SpoilerData;
void GenerateHash(); void GenerateHash();

28
soh/soh/Enhancements/randomizer/context.cpp
View File

@ -105,7 +105,7 @@ void Context::PlaceItemInLocation(const RandomizerCheck locKey, const Randomizer
// If we're placing a non-shop item in a shop location, we want to record it for custom messages // If we're placing a non-shop item in a shop location, we want to record it for custom messages
if (StaticData::RetrieveItem(item).GetItemType() != ITEMTYPE_SHOP && if (StaticData::RetrieveItem(item).GetItemType() != ITEMTYPE_SHOP &&
StaticData::GetLocation(locKey)->IsCategory(Category::cShop)) { StaticData::GetLocation(locKey)->GetRCType() == RCTYPE_SHOP) {
const int index = TransformShopIndex(GetShopIndex(locKey)); const int index = TransformShopIndex(GetShopIndex(locKey));
NonShopItems[index].Name = StaticData::RetrieveItem(item).GetName(); NonShopItems[index].Name = StaticData::RetrieveItem(item).GetName();
NonShopItems[index].Repurchaseable = NonShopItems[index].Repurchaseable =
@ -136,11 +136,11 @@ void Context::AddLocations(const Container& locations, std::vector<RandomizerChe
void Context::GenerateLocationPool() { void Context::GenerateLocationPool() {
allLocations.clear(); allLocations.clear();
AddLocation(RC_LINKS_POCKET); //AddLocation(RC_LINKS_POCKET); this is being added twice now
if (mSettings->GetOption(RSK_TRIFORCE_HUNT)) { if (mSettings->GetOption(RSK_TRIFORCE_HUNT)) {
AddLocation(RC_TRIFORCE_COMPLETED); AddLocation(RC_TRIFORCE_COMPLETED);
} }
AddLocations(StaticData::overworldLocations); AddLocations(StaticData::GetOverworldLocations());
if (mSettings->GetOption(RSK_FISHSANITY).IsNot(RO_FISHSANITY_OFF)) { if (mSettings->GetOption(RSK_FISHSANITY).IsNot(RO_FISHSANITY_OFF)) {
AddLocations(mFishsanity->GetFishsanityLocations().first); AddLocations(mFishsanity->GetFishsanityLocations().first);
@ -152,7 +152,7 @@ void Context::GenerateLocationPool() {
} }
void Context::AddExcludedOptions() { void Context::AddExcludedOptions() {
AddLocations(StaticData::overworldLocations, &everyPossibleLocation); AddLocations(StaticData::GetOverworldLocations(), &everyPossibleLocation);
for (const auto dungeon : mDungeons->GetDungeonList()) { for (const auto dungeon : mDungeons->GetDungeonList()) {
AddLocations(dungeon->GetEveryLocation(), &everyPossibleLocation); AddLocations(dungeon->GetEveryLocation(), &everyPossibleLocation);
} }
@ -161,16 +161,14 @@ void Context::AddExcludedOptions() {
} }
} }
std::vector<RandomizerCheck> Context::GetLocations(const std::vector<RandomizerCheck>& locationPool, std::vector<RandomizerCheck> Context::GetLocations(const std::vector<RandomizerCheck>& locationPool, const RandomizerCheckType checkType) {
const Category categoryInclude, const Category categoryExclude) { std::vector<RandomizerCheck> locationsOfType;
std::vector<RandomizerCheck> locationsInCategory;
for (RandomizerCheck locKey : locationPool) { for (RandomizerCheck locKey : locationPool) {
if (StaticData::GetLocation(locKey)->IsCategory(categoryInclude) && if (StaticData::GetLocation(locKey)->GetRCType() == checkType) {
!StaticData::GetLocation(locKey)->IsCategory(categoryExclude)) { locationsOfType.push_back(locKey);
locationsInCategory.push_back(locKey);
} }
} }
return locationsInCategory; return locationsOfType;
} }
void Context::ClearItemLocations() { void Context::ClearItemLocations() {
@ -198,17 +196,17 @@ void Context::LocationReset() {
GetItemLocation(il)->RemoveFromPool(); GetItemLocation(il)->RemoveFromPool();
} }
for (const RandomizerCheck il : StaticData::gossipStoneLocations) { for (const RandomizerCheck il : StaticData::GetGossipStoneLocations()) {
GetItemLocation(il)->RemoveFromPool(); GetItemLocation(il)->RemoveFromPool();
} }
for (const RandomizerCheck il : StaticData::staticHintLocations) { for (const RandomizerCheck il : StaticData::GetStaticHintLocations()) {
GetItemLocation(il)->RemoveFromPool(); GetItemLocation(il)->RemoveFromPool();
} }
} }
void Context::HintReset() { void Context::HintReset() {
for (const RandomizerCheck il : StaticData::gossipStoneLocations) { for (const RandomizerCheck il : StaticData::GetGossipStoneLocations()) {
GetItemLocation(il)->ResetVariables(); GetItemLocation(il)->ResetVariables();
} }
for (Hint& hint : hintTable){ for (Hint& hint : hintTable){
@ -227,7 +225,7 @@ void Context::CreateItemOverrides() {
iceTrapModels[locKey] = val.LooksLike(); iceTrapModels[locKey] = val.LooksLike();
val.SetTrickName(GetIceTrapName(val.LooksLike())); val.SetTrickName(GetIceTrapName(val.LooksLike()));
// If this is ice trap is in a shop, change the name based on what the model will look like // If this is ice trap is in a shop, change the name based on what the model will look like
if (loc->IsCategory(Category::cShop)) { if (loc->GetRCType() == RCTYPE_SHOP) {
NonShopItems[TransformShopIndex(GetShopIndex(locKey))].Name = val.GetTrickName(); NonShopItems[TransformShopIndex(GetShopIndex(locKey))].Name = val.GetTrickName();
} }
overrides[locKey] = val; overrides[locKey] = val;

3
soh/soh/Enhancements/randomizer/context.h
View File

@ -50,8 +50,7 @@ class Context {
template <typename Container> template <typename Container>
void AddLocations(const Container& locations, std::vector<RandomizerCheck>* destination = nullptr); void AddLocations(const Container& locations, std::vector<RandomizerCheck>* destination = nullptr);
void GenerateLocationPool(); void GenerateLocationPool();
static std::vector<RandomizerCheck> GetLocations(const std::vector<RandomizerCheck>& locationPool, static std::vector<RandomizerCheck> GetLocations(const std::vector<RandomizerCheck>& locationPool, const RandomizerCheckType checkType);
Category categoryInclude, Category categoryExclude = Category::cNull);
void AddExcludedOptions(); void AddExcludedOptions();
void LocationReset(); void LocationReset();
void ClearItemLocations(); void ClearItemLocations();

8
soh/soh/Enhancements/randomizer/dungeon.cpp
View File

@ -100,7 +100,7 @@ void DungeonInfo::PlaceVanillaMap() const {
auto dungeonLocations = GetDungeonLocations(); auto dungeonLocations = GetDungeonLocations();
const auto mapLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) { const auto mapLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) {
return StaticData::GetLocation(loc)->IsCategory(Category::cVanillaMap); return StaticData::GetLocation(loc)->GetRCType() == RCTYPE_MAP;
})[0]; })[0];
Context::GetInstance()->PlaceItemInLocation(mapLocation, map); Context::GetInstance()->PlaceItemInLocation(mapLocation, map);
} }
@ -112,7 +112,7 @@ void DungeonInfo::PlaceVanillaCompass() const {
auto dungeonLocations = GetDungeonLocations(); auto dungeonLocations = GetDungeonLocations();
const auto compassLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) { const auto compassLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) {
return StaticData::GetLocation(loc)->IsCategory(Category::cVanillaCompass); return StaticData::GetLocation(loc)->GetRCType() == RCTYPE_COMPASS;
})[0]; })[0];
Context::GetInstance()->PlaceItemInLocation(compassLocation, compass); Context::GetInstance()->PlaceItemInLocation(compassLocation, compass);
} }
@ -124,7 +124,7 @@ void DungeonInfo::PlaceVanillaBossKey() const {
auto dungeonLocations = GetDungeonLocations(); auto dungeonLocations = GetDungeonLocations();
const auto bossKeyLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) { const auto bossKeyLocation = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) {
return StaticData::GetLocation(loc)->IsCategory(Category::cVanillaBossKey); return StaticData::GetLocation(loc)->GetRCType() == RCTYPE_BOSS_KEY;
})[0]; })[0];
Context::GetInstance()->PlaceItemInLocation(bossKeyLocation, bossKey); Context::GetInstance()->PlaceItemInLocation(bossKeyLocation, bossKey);
} }
@ -136,7 +136,7 @@ void DungeonInfo::PlaceVanillaSmallKeys() const {
auto dungeonLocations = GetDungeonLocations(); auto dungeonLocations = GetDungeonLocations();
const auto smallKeyLocations = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) { const auto smallKeyLocations = FilterFromPool(dungeonLocations, [](const RandomizerCheck loc) {
return StaticData::GetLocation(loc)->IsCategory(Category::cVanillaSmallKey); return StaticData::GetLocation(loc)->GetRCType() == RCTYPE_SMALL_KEY;
}); });
for (const auto location : smallKeyLocations) { for (const auto location : smallKeyLocations) {
Context::GetInstance()->PlaceItemInLocation(location, smallKey); Context::GetInstance()->PlaceItemInLocation(location, smallKey);

12
soh/soh/Enhancements/randomizer/fishsanity.cpp
View File

@ -87,10 +87,10 @@ namespace Rando {
auto [mode, numFish, ageSplit] = GetOptions(optionsSource); auto [mode, numFish, ageSplit] = GetOptions(optionsSource);
std::vector<RandomizerCheck> activeFish; std::vector<RandomizerCheck> activeFish;
std::vector<RandomizerCheck> remainingFish; std::vector<RandomizerCheck> remainingFish;
std::vector<RandomizerCheck> pondFish = Rando::StaticData::GetPondFishLocations();
// Fishsanity_InitializeHelpers(); // Fishsanity_InitializeHelpers();
remainingFish.insert(remainingFish.end(), Rando::StaticData::pondFishLocations.begin(), remainingFish.insert(remainingFish.end(), pondFish.begin(), pondFish.end());
Rando::StaticData::pondFishLocations.end());
// No pond fish shuffled // No pond fish shuffled
if (numFish == 0) { if (numFish == 0) {
@ -138,8 +138,8 @@ namespace Rando {
// Add overworld fish // Add overworld fish
if (mode == RO_FISHSANITY_OVERWORLD || mode == RO_FISHSANITY_BOTH) { if (mode == RO_FISHSANITY_OVERWORLD || mode == RO_FISHSANITY_BOTH) {
activeFish.insert(activeFish.end(), Rando::StaticData::overworldFishLocations.begin(), std::vector<RandomizerCheck> overworldFish = Rando::StaticData::GetOverworldFishLocations();
Rando::StaticData::overworldFishLocations.end()); activeFish.insert(activeFish.end(), overworldFish.begin(), overworldFish.end());
} }
return std::make_pair(activeFish, remainingFish); return std::make_pair(activeFish, remainingFish);
@ -299,11 +299,11 @@ namespace Rando {
FishsanityCheckType Fishsanity::GetCheckType(RandomizerCheck rc) { FishsanityCheckType Fishsanity::GetCheckType(RandomizerCheck rc) {
// Is this a pond fish? // Is this a pond fish?
if (std::binary_search(Rando::StaticData::pondFishLocations.begin(), Rando::StaticData::pondFishLocations.end(), rc)) if (std::binary_search(Rando::StaticData::GetPondFishLocations().begin(), Rando::StaticData::GetPondFishLocations().end(), rc))
return FSC_POND; return FSC_POND;
// Is this an overworld fish? // Is this an overworld fish?
if (std::binary_search(Rando::StaticData::overworldFishLocations.begin(), Rando::StaticData::overworldFishLocations.end(), rc)) { if (std::binary_search(Rando::StaticData::GetOverworldFishLocations().begin(), Rando::StaticData::GetOverworldFishLocations().end(), rc)) {
if (rc < RC_ZD_FISH_1) if (rc < RC_ZD_FISH_1)
return FSC_GROTTO; return FSC_GROTTO;
else else

4
soh/soh/Enhancements/randomizer/item_location.cpp
View File

@ -174,13 +174,13 @@ void ItemLocation::AddExcludeOption() {
// RANDOTODO: this without string compares and loops // RANDOTODO: this without string compares and loops
bool alreadyAdded = false; bool alreadyAdded = false;
const Location* loc = StaticData::GetLocation(rc); const Location* loc = StaticData::GetLocation(rc);
for (const Option* location : Context::GetInstance()->GetSettings()->GetExcludeOptionsForGroup(loc->GetCollectionCheckGroup())) { for (const Option* location : Context::GetInstance()->GetSettings()->GetExcludeOptionsForArea(loc->GetArea())) {
if (location->GetName() == excludedOption.GetName()) { if (location->GetName() == excludedOption.GetName()) {
alreadyAdded = true; alreadyAdded = true;
} }
} }
if (!alreadyAdded) { if (!alreadyAdded) {
Context::GetInstance()->GetSettings()->GetExcludeOptionsForGroup(loc->GetCollectionCheckGroup()).push_back(&excludedOption); Context::GetInstance()->GetSettings()->GetExcludeOptionsForArea(loc->GetArea()).push_back(&excludedOption);
} }
} }

530
soh/soh/Enhancements/randomizer/location.cpp
View File

@ -1,6 +1,7 @@
#include "location.h" #include "location.h"
#include "static_data.h" #include "static_data.h"
#include <algorithm> #include <algorithm>
#include <assert.h>
RandomizerCheck Rando::Location::GetRandomizerCheck() const { RandomizerCheck Rando::Location::GetRandomizerCheck() const {
return rc; return rc;
@ -10,10 +11,6 @@ Rando::SpoilerCollectionCheck Rando::Location::GetCollectionCheck() const {
return collectionCheck; return collectionCheck;
} }
SpoilerCollectionCheckGroup Rando::Location::GetCollectionCheckGroup() const {
return collectionCheckGroup;
}
RandomizerCheckQuest Rando::Location::GetQuest() const { RandomizerCheckQuest Rando::Location::GetQuest() const {
return quest; return quest;
} }
@ -35,11 +32,7 @@ int32_t Rando::Location::GetActorParams() const {
} }
SceneID Rando::Location::GetScene() const { SceneID Rando::Location::GetScene() const {
return static_cast<SceneID>(scene); return scene;
}
uint8_t Rando::Location::GetFlag() const {
return flag;
} }
RandomizerHintTextKey Rando::Location::GetHintKey() const { RandomizerHintTextKey Rando::Location::GetHintKey() const {
@ -58,19 +51,11 @@ const std::string& Rando::Location::GetShortName() const {
return shortName; return shortName;
} }
Rando::LocationType Rando::Location::GetLocationType() const {
return locationType;
}
bool Rando::Location::IsCategory(Category category) const {
return std::any_of(categories.begin(), categories.end(), [category](auto entry) { return entry == category; });
}
bool Rando::Location::IsDungeon() const { bool Rando::Location::IsDungeon() const {
return (locationType != LocationType::GSToken && return (checkType != RCTYPE_SKULL_TOKEN &&
(scene < SCENE_GANONS_TOWER_COLLAPSE_INTERIOR || (scene < SCENE_GANONS_TOWER_COLLAPSE_INTERIOR ||
(scene > SCENE_TREASURE_BOX_SHOP && scene < SCENE_GANONS_TOWER_COLLAPSE_EXTERIOR))) || (scene > SCENE_TREASURE_BOX_SHOP && scene < SCENE_GANONS_TOWER_COLLAPSE_EXTERIOR))) ||
(locationType == LocationType::GSToken && scene < SCENE_GANONS_TOWER); (checkType == RCTYPE_SKULL_TOKEN && scene < SCENE_GANONS_TOWER);
} }
bool Rando::Location::IsOverworld() const { bool Rando::Location::IsOverworld() const {
@ -97,312 +82,277 @@ RandomizerGet Rando::Location::GetVanillaItem() const {
return vanillaItem; return vanillaItem;
} }
Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea GetAreaFromScene(uint8_t scene) {
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, switch (scene) {
uint8_t flag_, std::string&& shortName_, std::string&& spoilerName_, case SCENE_LINKS_HOUSE:
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, case SCENE_KOKIRI_FOREST:
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck, case SCENE_KOKIRI_SHOP:
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) { case SCENE_MIDOS_HOUSE:
return {rc, quest_, checkType_, area_, LocationType::Base, actorId_, scene_, actorParams_, flag_, case SCENE_KNOW_IT_ALL_BROS_HOUSE:
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories), case SCENE_TWINS_HOUSE:
isVanillaCompletion_, collectionCheck, collectionCheckGroup}; case SCENE_SARIAS_HOUSE:
return RCAREA_KOKIRI_FOREST;
case SCENE_LOST_WOODS:
return RCAREA_LOST_WOODS;
case SCENE_SACRED_FOREST_MEADOW:
return RCAREA_SACRED_FOREST_MEADOW;
case SCENE_HYRULE_FIELD:
return RCAREA_HYRULE_FIELD;
case SCENE_LAKE_HYLIA:
case SCENE_FISHING_POND:
case SCENE_LAKESIDE_LABORATORY:
return RCAREA_LAKE_HYLIA;
case SCENE_GERUDO_VALLEY:
case SCENE_CARPENTERS_TENT:
return RCAREA_GERUDO_VALLEY;
case SCENE_GERUDOS_FORTRESS:
case SCENE_THIEVES_HIDEOUT:
return RCAREA_GERUDO_FORTRESS;
case SCENE_HAUNTED_WASTELAND:
return RCAREA_WASTELAND;
case SCENE_DESERT_COLOSSUS:
return RCAREA_DESERT_COLOSSUS;
case SCENE_MARKET_ENTRANCE_DAY:
case SCENE_MARKET_ENTRANCE_NIGHT:
case SCENE_MARKET_ENTRANCE_RUINS:
case SCENE_BACK_ALLEY_DAY:
case SCENE_BACK_ALLEY_NIGHT:
case SCENE_BACK_ALLEY_HOUSE:
case SCENE_MARKET_DAY:
case SCENE_MARKET_NIGHT:
case SCENE_MARKET_RUINS:
case SCENE_TEMPLE_OF_TIME_EXTERIOR_DAY:
case SCENE_TEMPLE_OF_TIME_EXTERIOR_NIGHT:
case SCENE_TEMPLE_OF_TIME_EXTERIOR_RUINS:
case SCENE_TREASURE_BOX_SHOP:
case SCENE_BOMBCHU_BOWLING_ALLEY:
case SCENE_DOG_LADY_HOUSE:
case SCENE_MARKET_GUARD_HOUSE:
case SCENE_POTION_SHOP_MARKET:
case SCENE_BOMBCHU_SHOP:
case SCENE_HAPPY_MASK_SHOP:
case SCENE_TEMPLE_OF_TIME:
return RCAREA_MARKET;
case SCENE_HYRULE_CASTLE:
case SCENE_CASTLE_COURTYARD_GUARDS_DAY:
case SCENE_CASTLE_COURTYARD_GUARDS_NIGHT:
case SCENE_CASTLE_COURTYARD_ZELDA:
case SCENE_OUTSIDE_GANONS_CASTLE:
return RCAREA_HYRULE_CASTLE;
case SCENE_KAKARIKO_VILLAGE:
case SCENE_KAKARIKO_CENTER_GUEST_HOUSE:
case SCENE_HOUSE_OF_SKULLTULA:
case SCENE_POTION_SHOP_GRANNY:
case SCENE_IMPAS_HOUSE:
case SCENE_POTION_SHOP_KAKARIKO:
case SCENE_TEST01:
return RCAREA_KAKARIKO_VILLAGE;
case SCENE_GRAVEYARD:
case SCENE_ROYAL_FAMILYS_TOMB:
case SCENE_GRAVEKEEPERS_HUT:
return RCAREA_GRAVEYARD;
case SCENE_DEATH_MOUNTAIN_TRAIL:
return RCAREA_DEATH_MOUNTAIN_TRAIL;
case SCENE_GORON_CITY:
case SCENE_GORON_SHOP:
return RCAREA_GORON_CITY;
case SCENE_DEATH_MOUNTAIN_CRATER:
return RCAREA_DEATH_MOUNTAIN_CRATER;
case SCENE_ZORAS_RIVER:
return RCAREA_ZORAS_RIVER;
case SCENE_ZORAS_DOMAIN:
case SCENE_ZORA_SHOP:
return RCAREA_ZORAS_DOMAIN;
case SCENE_ZORAS_FOUNTAIN:
return RCAREA_ZORAS_FOUNTAIN;
case SCENE_LON_LON_RANCH:
case SCENE_LON_LON_BUILDINGS:
case SCENE_STABLE:
return RCAREA_LON_LON_RANCH;
case SCENE_DEKU_TREE:
case SCENE_DEKU_TREE_BOSS:
return RCAREA_DEKU_TREE;
case SCENE_DODONGOS_CAVERN:
case SCENE_DODONGOS_CAVERN_BOSS:
return RCAREA_DODONGOS_CAVERN;
case SCENE_JABU_JABU:
case SCENE_JABU_JABU_BOSS:
return RCAREA_JABU_JABUS_BELLY;
case SCENE_FOREST_TEMPLE:
case SCENE_FOREST_TEMPLE_BOSS:
return RCAREA_FOREST_TEMPLE;
case SCENE_FIRE_TEMPLE:
case SCENE_FIRE_TEMPLE_BOSS:
return RCAREA_FIRE_TEMPLE;
case SCENE_WATER_TEMPLE:
case SCENE_WATER_TEMPLE_BOSS:
return RCAREA_WATER_TEMPLE;
case SCENE_SPIRIT_TEMPLE:
case SCENE_SPIRIT_TEMPLE_BOSS:
return RCAREA_SPIRIT_TEMPLE;
case SCENE_SHADOW_TEMPLE:
case SCENE_SHADOW_TEMPLE_BOSS:
return RCAREA_SHADOW_TEMPLE;
case SCENE_BOTTOM_OF_THE_WELL:
return RCAREA_BOTTOM_OF_THE_WELL;
case SCENE_ICE_CAVERN:
return RCAREA_ICE_CAVERN;
case SCENE_GERUDO_TRAINING_GROUND:
return RCAREA_GERUDO_TRAINING_GROUND;
case SCENE_INSIDE_GANONS_CASTLE:
case SCENE_GANONS_TOWER_COLLAPSE_INTERIOR:
case SCENE_GANONS_TOWER_COLLAPSE_EXTERIOR:
case SCENE_INSIDE_GANONS_CASTLE_COLLAPSE:
case SCENE_GANONS_TOWER:
case SCENE_GANON_BOSS:
return RCAREA_GANONS_CASTLE;
default:
assert(false);
return RCAREA_INVALID;
}
} }
Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, std::string&& shortName_, std::string&& spoilerName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
uint8_t flag_, std::string&& shortName_, SpoilerCollectionCheck collectionCheck, bool isVanillaCompletion_) {
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck, isVanillaCompletion_, collectionCheck };
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Base, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, std::string&& shortName_, std::string&& spoilerName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, SpoilerCollectionCheck collectionCheck, bool isVanillaCompletion_) {
std::string&& spoilerName_, const RandomizerHintTextKey hintKey, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Chest, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene_, flag_),
collectionCheckGroup};
} }
Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
const RandomizerHintTextKey hintKey,
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Chest, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey,
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Chest, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
}
Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
const RandomizerHintTextKey hintKey,
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Chest, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
}
Rando::Location Rando::Location::Collectable(
RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::Collectable(
RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_,
RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_,
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, const uint8_t collectFlag_,
SpoilerCollectionCheckGroup collectionCheckGroup,
bool isVanillaCompletion_) { bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_, return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, collectFlag_),
collectionCheckGroup};
} }
Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, int32_t actorParams_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, SpoilerCollectionCheck collectionCheck, bool isVanillaCompletion_) {
std::string&& shortName_, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, }
std::vector<Category>&& categories, const uint8_t collectFlag_,
SpoilerCollectionCheckGroup collectionCheckGroup, Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
uint8_t flag_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, bool isVanillaCompletion_) {
return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene_, flag_) };
}
Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
bool isVanillaCompletion_) { bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories), SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene_, flag_) };
isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, collectFlag_),
collectionCheckGroup};
} }
Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_,
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup,
bool isVanillaCompletion_) { bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_, return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, int32_t actorParams_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, SpoilerCollectionCheck collectionCheck, bool isVanillaCompletion_) {
std::string&& shortName_, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, }
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
uint8_t flag_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, bool isVanillaCompletion_) {
return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, flag_) };
}
Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
bool isVanillaCompletion_) { bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Collectable, actorId_, scene_, actorParams_, flag_, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories), SpoilerCollectionCheck(SPOILER_CHK_COLLECTABLE, scene_, flag_) };
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey,
std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_SKULL_TOKEN, area_, LocationType::GSToken, ACTOR_EN_SI, scene_, actorParams_,
flag_, std::move(shortName_), std::move(spoilerName_), hintKey, RG_GOLD_SKULLTULA_TOKEN,
std::move(categories), isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, scene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
const RandomizerHintTextKey hintKey,
std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_SKULL_TOKEN, area_, LocationType::GSToken, ACTOR_EN_SI, scene_, actorParams_,
flag_, std::move(shortName_), hintKey, RG_GOLD_SKULLTULA_TOKEN,
std::move(categories), isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, scene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey,
std::vector<Category>&& categories, const uint8_t skullScene_,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_SKULL_TOKEN, area_, LocationType::GSToken, ACTOR_EN_SI, scene_, actorParams_,
flag_, std::move(shortName_), std::move(spoilerName_), hintKey, RG_GOLD_SKULLTULA_TOKEN,
std::move(categories), isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, skullScene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
const RandomizerHintTextKey hintKey,
std::vector<Category>&& categories, const uint8_t skullScene_,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_SKULL_TOKEN, area_, LocationType::GSToken, ACTOR_EN_SI, scene_, actorParams_,
flag_, std::move(shortName_), hintKey, RG_GOLD_SKULLTULA_TOKEN,
std::move(categories), isVanillaCompletion_,
SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, skullScene_, flag_),
collectionCheckGroup};
}
Rando::Location Rando::Location::GrottoScrub(RandomizerCheck rc, RandomizerCheckQuest quest_,
RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_,
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup,
bool isVanillaCompletion_) { bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::GrottoScrub, actorId_, scene_, actorParams_, flag_, return { rc, quest_, checkType_, GetAreaFromScene(scene_), actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::GrottoScrub(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, int32_t actorParams_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, SpoilerCollectionCheck collectionCheck, bool isVanillaCompletion_) {
std::string&& shortName_, return { rc, quest_, checkType_, area_, actorId_, scene_, actorParams_, std::move(shortName_), hintKey, vanillaItem, isVanillaCompletion_, collectionCheck };
const RandomizerHintTextKey hintKey, const RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup,
bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::GrottoScrub, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Delayed(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, const RandomizerHintTextKey hintKey) {
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_, return { rc, quest_, RCTYPE_SKULL_TOKEN, GetAreaFromScene(scene_), ACTOR_EN_SI, scene_, actorParams_, std::move(shortName_), hintKey, RG_GOLD_SKULLTULA_TOKEN, true,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey, SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, scene_, flag_) };
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Delayed, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Delayed(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, const RandomizerHintTextKey hintKey, const uint8_t skullScene_) {
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_, return { rc, quest_, RCTYPE_SKULL_TOKEN, GetAreaFromScene(scene_), ACTOR_EN_SI, scene_, actorParams_, std::move(shortName_), hintKey, RG_GOLD_SKULLTULA_TOKEN, true,
const RandomizerHintTextKey hintKey, SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, skullScene_, flag_) };
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::Delayed, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Reward(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, Rando::Location Rando::Location::GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, SceneID scene_, int32_t actorParams_, uint8_t flag_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, std::string&& shortName_, const RandomizerHintTextKey hintKey, const uint8_t skullScene_) {
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, return { rc, quest_, RCTYPE_SKULL_TOKEN, area_, ACTOR_EN_SI, scene_, actorParams_, std::move(shortName_), hintKey, RG_GOLD_SKULLTULA_TOKEN, true,
std::string&& spoilerName_, const RandomizerHintTextKey hintKey, SpoilerCollectionCheck(SPOILER_CHK_GOLD_SKULLTULA, skullScene_, flag_) };
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::TempleReward, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::Reward(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, Rando::Location Rando::Location::OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_, std::string&& shortName_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, std::string&& spoilerName_) {
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, return { rc, quest_, RCTYPE_STATIC_HINT, area_, actorId_, scene_, 0x00, std::move(shortName_), std::move(spoilerName_), RHT_NONE, RG_NONE, false };
const RandomizerHintTextKey hintKey,
const RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup, bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::TempleReward, actorId_, scene_, actorParams_, flag_,
std::move(shortName_), hintKey, vanillaItem, std::move(categories),
isVanillaCompletion_, collectionCheck, collectionCheckGroup};
} }
Rando::Location Rando::Location::OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, ActorID actorId_, SceneID scene_, std::string&& shortName_) {
RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, return { rc, quest_, RCTYPE_STATIC_HINT, GetAreaFromScene(scene_), actorId_, scene_, 0x00, std::move(shortName_), RHT_NONE, RG_NONE, false };
uint8_t scene_,
std::string&& shortName_, std::string&& spoilerName_,
bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::OtherHint, actorId_, scene_, 0x00, 0x00,
std::move(shortName_), std::move(spoilerName_), RHT_NONE, RG_NONE, {}, isVanillaCompletion_};
} }
Rando::Location Rando::Location::OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, Rando::Location Rando::Location::OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_, std::string&& shortName_) {
RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, return { rc, quest_, RCTYPE_STATIC_HINT, area_, actorId_, scene_, 0x00, std::move(shortName_), RHT_NONE, RG_NONE, false };
uint8_t scene_,
std::string&& shortName_,
bool isVanillaCompletion_) {
return {rc, quest_, checkType_, area_, LocationType::OtherHint, actorId_, scene_, 0x00, 0x00,
std::move(shortName_), RHT_NONE, RG_NONE, {}, isVanillaCompletion_};
} }
Rando::Location Rando::Location::HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, Rando::Location Rando::Location::HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, std::string&& shortName_) {
uint8_t scene_, int32_t actorParams_, uint8_t flag_, return { rc, quest_, RCTYPE_GOSSIP_STONE, GetAreaFromScene(scene_), ACTOR_EN_GS, scene_, actorParams_, std::move(shortName_), RHT_NONE, RG_NONE, false };
std::string&& shortName_, std::string&& spoilerName_,
std::vector<Category>&& categories, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_GOSSIP_STONE, area_, LocationType::Base, ACTOR_EN_GS, scene_, actorParams_, flag_,
std::move(shortName_), std::move(spoilerName_), RHT_NONE, RG_NONE, std::move(categories),
isVanillaCompletion_};
} }
Rando::Location Rando::Location::HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, Rando::Location Rando::Location::HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, SceneID scene_, int32_t actorParams_, std::string&& shortName_) {
uint8_t scene_, int32_t actorParams_, uint8_t flag_, return { rc, quest_, RCTYPE_GOSSIP_STONE, area_, ACTOR_EN_GS, scene_, actorParams_, std::move(shortName_), RHT_NONE, RG_NONE, false };
std::string&& shortName_,
std::vector<Category>&& categories, bool isVanillaCompletion_) {
return {rc, quest_, RCTYPE_GOSSIP_STONE, area_, LocationType::Base, ACTOR_EN_GS, scene_, actorParams_, flag_,
std::move(shortName_), RHT_NONE, RG_NONE, std::move(categories),
isVanillaCompletion_};
} }

329
soh/soh/Enhancements/randomizer/location.h
View File

@ -4,7 +4,6 @@
#include <vector> #include <vector>
#include "3drando/spoiler_log.hpp" #include "3drando/spoiler_log.hpp"
#include "3drando/category.hpp"
#include "3drando/hints.hpp" #include "3drando/hints.hpp"
#include "randomizerTypes.h" #include "randomizerTypes.h"
@ -20,17 +19,7 @@ class SpoilerCollectionCheck {
uint16_t flag = 0; uint16_t flag = 0;
SpoilerCollectionCheck() = default; SpoilerCollectionCheck() = default;
SpoilerCollectionCheck(const SpoilerCollectionCheckType type_, const uint8_t scene_, const uint16_t flag_) SpoilerCollectionCheck(const SpoilerCollectionCheckType type_, const uint8_t scene_, const uint16_t flag_) : type(type_), scene(scene_), flag(flag_) {}
: type(type_), scene(scene_), flag(flag_) {
}
static auto None() {
return SpoilerCollectionCheck(SPOILER_CHK_NONE, 0x00, 0x00);
}
static auto AlwaysCollected() {
return SpoilerCollectionCheck(SPOILER_CHK_ALWAYS_COLLECTED, 0x00, 0x00);
}
static auto ItemGetInf(const uint8_t slot) { static auto ItemGetInf(const uint8_t slot) {
return SpoilerCollectionCheck(SPOILER_CHK_ITEM_GET_INF, 0x00, slot); return SpoilerCollectionCheck(SPOILER_CHK_ITEM_GET_INF, 0x00, slot);
@ -52,76 +41,30 @@ class SpoilerCollectionCheck {
return SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene, flag); return SpoilerCollectionCheck(SPOILER_CHK_CHEST, scene, flag);
} }
static auto Fish(const uint8_t flag, const uint8_t scene = SCENE_FISHING_POND) {
return SpoilerCollectionCheck(SPOILER_CHK_FISH, scene, flag);
}
static auto Fishing(const uint8_t bit) {
return SpoilerCollectionCheck(SPOILER_CHK_MINIGAME, 0x00, bit);
}
static auto BigPoePoints() {
return SpoilerCollectionCheck(SPOILER_CHK_POE_POINTS, 0x00, 0x00);
}
static auto Gravedigger(const uint8_t scene, const uint8_t flag) {
return SpoilerCollectionCheck(SPOILER_CHK_GRAVEDIGGER, scene, flag);
}
static auto ShopItem(const uint8_t scene, const uint8_t itemSlot) {
return SpoilerCollectionCheck(SPOILER_CHK_SHOP_ITEM, scene, itemSlot);
}
static auto MasterSword() {
return SpoilerCollectionCheck(SPOILER_CHK_MASTER_SWORD, 0x00, 0x00);
}
static auto RandomizerInf(const uint16_t flag) { static auto RandomizerInf(const uint16_t flag) {
return SpoilerCollectionCheck(SPOILER_CHK_RANDOMIZER_INF, 0x00, flag); return SpoilerCollectionCheck(SPOILER_CHK_RANDOMIZER_INF, 0x00, flag);
} }
}; };
enum class LocationType {
Base,
Chest,
Collectable,
GSToken,
GrottoScrub,
Delayed,
TempleReward,
HintStone,
OtherHint,
};
class Location { class Location {
public: public:
Location() : rc(RC_UNKNOWN_CHECK), quest(RCQUEST_BOTH), checkType(RCTYPE_STANDARD), area(RCAREA_INVALID), Location() : rc(RC_UNKNOWN_CHECK), quest(RCQUEST_BOTH), checkType(RCTYPE_STANDARD), area(RCAREA_INVALID), actorId(ACTOR_ID_MAX), scene(SCENE_ID_MAX), actorParams(0),
locationType(LocationType::Base), actorId(ACTOR_ID_MAX), scene(SCENE_ID_MAX), actorParams(0), hintKey(RHT_NONE), vanillaItem(RG_NONE), isVanillaCompletion(false), collectionCheck(SpoilerCollectionCheck()) {}
flag(0), hintKey(RHT_NONE), vanillaItem(RG_NONE), isVanillaCompletion(false),
collectionCheck(SpoilerCollectionCheck()), collectionCheckGroup(GROUP_NO_GROUP) {} Location(const RandomizerCheck rc_, const RandomizerCheckQuest quest_, const RandomizerCheckType checkType_, const RandomizerCheckArea area_, const ActorID actorId_,
Location(const RandomizerCheck rc_, const RandomizerCheckQuest quest_, const RandomizerCheckType checkType_, const SceneID scene_, const int32_t actorParams_, std::string shortName_, std::string spoilerName_, const RandomizerHintTextKey hintKey_,
const RandomizerCheckArea area_, const LocationType locationType_, const ActorID actorId_, const uint8_t scene_, const RandomizerGet vanillaItem_, const bool isVanillaCompletion_ = false, const SpoilerCollectionCheck collectionCheck_ = SpoilerCollectionCheck())
const int32_t actorParams_, const uint8_t flag_, std::string shortName_, std::string spoilerName_, : rc(rc_), quest(quest_), checkType(checkType_), area(area_), actorId(actorId_),
const RandomizerHintTextKey hintKey_, const RandomizerGet vanillaItem_, std::vector<Category> categories_, scene(scene_), actorParams(actorParams_), shortName(std::move(shortName_)),
const bool isVanillaCompletion_ = false, const SpoilerCollectionCheck collectionCheck_ = SpoilerCollectionCheck(), spoilerName(std::move(spoilerName_)), hintKey(hintKey_), vanillaItem(vanillaItem_),
const SpoilerCollectionCheckGroup collectionCheckGroup_ = GROUP_NO_GROUP) isVanillaCompletion(isVanillaCompletion_), collectionCheck(collectionCheck_) {}
: rc(rc_), quest(quest_), checkType(checkType_), area(area_), locationType(locationType_), actorId(actorId_),
scene(scene_), actorParams(actorParams_), flag(flag_), shortName(std::move(shortName_)), Location(const RandomizerCheck rc_, const RandomizerCheckQuest quest_, const RandomizerCheckType checkType_, const RandomizerCheckArea area_, const ActorID actorId_,
spoilerName(std::move(spoilerName_)), hintKey(hintKey_), vanillaItem(vanillaItem_), categories(std::move(categories_)), const SceneID scene_, const int32_t actorParams_, std::string shortName_, const RandomizerHintTextKey hintKey_, const RandomizerGet vanillaItem_,
isVanillaCompletion(isVanillaCompletion_), collectionCheck(collectionCheck_), const bool isVanillaCompletion_ = false, const SpoilerCollectionCheck collectionCheck_ = SpoilerCollectionCheck())
collectionCheckGroup(collectionCheckGroup_) { : rc(rc_), quest(quest_), checkType(checkType_), area(area_), actorId(actorId_), scene(scene_), actorParams(actorParams_), shortName(shortName_),
} spoilerName(SpoilerNameFromShortName(shortName_, area_)), hintKey(hintKey_), vanillaItem(vanillaItem_), isVanillaCompletion(isVanillaCompletion_),
Location(const RandomizerCheck rc_, const RandomizerCheckQuest quest_, const RandomizerCheckType checkType_, collectionCheck(collectionCheck_) {}
const RandomizerCheckArea area_, const LocationType locationType_, const ActorID actorId_, const uint8_t scene_,
const int32_t actorParams_, const uint8_t flag_, std::string shortName_,
const RandomizerHintTextKey hintKey_, const RandomizerGet vanillaItem_, std::vector<Category> categories_,
const bool isVanillaCompletion_ = false, const SpoilerCollectionCheck collectionCheck_ = SpoilerCollectionCheck(),
const SpoilerCollectionCheckGroup collectionCheckGroup_ = GROUP_NO_GROUP)
: rc(rc_), quest(quest_), checkType(checkType_), area(area_), locationType(locationType_), actorId(actorId_),
scene(scene_), actorParams(actorParams_), flag(flag_), shortName(shortName_),
spoilerName(SpoilerNameFromShortName(shortName_, area_)), hintKey(hintKey_), vanillaItem(vanillaItem_), categories(std::move(categories_)),
isVanillaCompletion(isVanillaCompletion_), collectionCheck(collectionCheck_),
collectionCheckGroup(collectionCheckGroup_) {}
static std::string SpoilerNameFromShortName(std::string shortName, RandomizerCheckArea area) { static std::string SpoilerNameFromShortName(std::string shortName, RandomizerCheckArea area) {
if (area < 0 || area >= RCAREA_INVALID) { if (area < 0 || area >= RCAREA_INVALID) {
@ -132,20 +75,16 @@ class Location {
RandomizerCheck GetRandomizerCheck() const; RandomizerCheck GetRandomizerCheck() const;
SpoilerCollectionCheck GetCollectionCheck() const; SpoilerCollectionCheck GetCollectionCheck() const;
SpoilerCollectionCheckGroup GetCollectionCheckGroup() const;
RandomizerCheckQuest GetQuest() const; RandomizerCheckQuest GetQuest() const;
RandomizerCheckArea GetArea() const; RandomizerCheckArea GetArea() const;
RandomizerCheckType GetRCType() const; RandomizerCheckType GetRCType() const;
ActorID GetActorID() const; ActorID GetActorID() const;
int32_t GetActorParams() const; int32_t GetActorParams() const;
SceneID GetScene() const; SceneID GetScene() const;
uint8_t GetFlag() const;
RandomizerHintTextKey GetHintKey() const; RandomizerHintTextKey GetHintKey() const;
HintText* GetHint(); HintText* GetHint();
const std::string& GetName() const; const std::string& GetName() const;
const std::string& GetShortName() const; const std::string& GetShortName() const;
LocationType GetLocationType() const;
bool IsCategory(Category category) const;
bool IsDungeon() const; bool IsDungeon() const;
bool IsOverworld() const; bool IsOverworld() const;
bool IsShop() const; bool IsShop() const;
@ -154,119 +93,53 @@ class Location {
const HintText& GetHint() const; const HintText& GetHint() const;
RandomizerGet GetVanillaItem() const; RandomizerGet GetVanillaItem() const;
static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
uint8_t flag_, std::string&& shortName_, std::string&& spoilerName_, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), bool isVanillaCompletion_ = false);
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false); bool isVanillaCompletion_ = false);
static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, int32_t actorParams_, std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
uint8_t flag_, std::string&& shortName_, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), bool isVanillaCompletion_ = false);
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, static Location Base(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), int32_t actorParams_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), bool isVanillaCompletion_ = false);
static Location Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, bool isVanillaCompletion_ = false);
static Location Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
int32_t actorParams_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck,
bool isVanillaCompletion_ = false); bool isVanillaCompletion_ = false);
static Location static Location Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_, uint8_t flag_,
Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, bool isVanillaCompletion_ = false);
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, static Location Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
std::vector<Category>&& categories, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false); bool isVanillaCompletion_ = false);
static Location static Location Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_, uint8_t flag_,
Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, bool isVanillaCompletion_ = false);
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, static Location Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_,
std::vector<Category>&& categories, int32_t actorParams_, uint8_t flag_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false); bool isVanillaCompletion_ = false);
static Location static Location Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, ActorID actorId_, SceneID scene_, int32_t actorParams_,
Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false); bool isVanillaCompletion_ = false);
static Location static Location Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, ActorID actorId_,
Chest(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_, SceneID scene_, int32_t actorParams_, std::string&& shortName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(), bool isVanillaCompletion_ = false);
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location static Location GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerHintTextKey hintKey);
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories, uint8_t collectFlag_,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories, uint8_t collectFlag_,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
Collectable(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location
GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = true);
static Location
GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_,
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerHintTextKey hintKey, std::vector<Category>&& categories,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = true);
/// @brief For certain scenes, the sceneId and the "Scene" in spoiler collection check later used to check the /// @brief For certain scenes, the sceneId and the "Scene" in spoiler collection check later used to check the
/// GS flags don't necessarily match. Use this constructor (or the next one) for those. scene_ should be the actual scene where /// GS flags don't necessarily match. Use this constructor (or the next one) for those. scene_ should be the actual scene where
@ -274,117 +147,45 @@ class Location {
/// and expected that these don't always match, and the naming is a holdover from 3drando. /// and expected that these don't always match, and the naming is a holdover from 3drando.
/// @param rc /// @param rc
/// @param quest_ /// @param quest_
/// @param area_
/// @param scene_ /// @param scene_
/// @param actorParams_ /// @param actorParams_
/// @param flag_ /// @param flag_
/// @param shortName_ /// @param shortName_
/// @param spoilerName_
/// @param hintKey /// @param hintKey
/// @param categories
/// @param collectionCheckGroup
/// @param skullScene_ /// @param skullScene_
/// @param isVanillaCompletion_
/// @return /// @return
static Location static Location GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, RandomizerHintTextKey hintKey, uint8_t skullScene_);
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, std::vector<Category>&& categories,
uint8_t skullScene_,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = true);
static Location static Location GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, SceneID scene_, int32_t actorParams_, uint8_t flag_,
GSToken(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, std::string&& shortName_, RandomizerHintTextKey hintKey, uint8_t skullScene_);
uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerHintTextKey hintKey, std::vector<Category>&& categories,
uint8_t skullScene_,
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = true);
static Location static Location OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_, std::string&& shortName_,
GrottoScrub(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, std::string&& spoilerName_);
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, std::string&& spoilerName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location static Location OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, ActorID actorId_, SceneID scene_, std::string&& shortName_);
GrottoScrub(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_,
std::string&& shortName_, RandomizerHintTextKey hintKey,
RandomizerGet vanillaItem, std::vector<Category>&& categories,
SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location static Location OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, ActorID actorId_, SceneID scene_, std::string&& shortName_);
Delayed(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location static Location HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, SceneID scene_, int32_t actorParams_, std::string&& shortName_);
Delayed(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP,
bool isVanillaCompletion_ = false);
static Location static Location HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, SceneID scene_, int32_t actorParams_, std::string&& shortName_);
Reward(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::string&& spoilerName_, RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP, bool isVanillaCompletion_ = false);
static Location
Reward(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_, RandomizerCheckArea area_,
ActorID actorId_, uint8_t scene_, int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
RandomizerHintTextKey hintKey, RandomizerGet vanillaItem,
std::vector<Category>&& categories, SpoilerCollectionCheck collectionCheck = SpoilerCollectionCheck(),
SpoilerCollectionCheckGroup collectionCheckGroup = GROUP_NO_GROUP, bool isVanillaCompletion_ = false);
static Location OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_,
std::string&& shortName_, std::string&& spoilerName_, bool isVanillaCompletion_ = false);
static Location OtherHint(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckType checkType_,
RandomizerCheckArea area_, ActorID actorId_, uint8_t scene_,
std::string&& shortName_, bool isVanillaCompletion_ = false);
static Location HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, uint8_t scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_, std::string&& spoilerName_,
std::vector<Category>&& categories, bool isVanillaCompletion_ = false);
static Location HintStone(RandomizerCheck rc, RandomizerCheckQuest quest_, RandomizerCheckArea area_, uint8_t scene_,
int32_t actorParams_, uint8_t flag_, std::string&& shortName_,
std::vector<Category>&& categories, bool isVanillaCompletion_ = false);
private: private:
RandomizerCheck rc; RandomizerCheck rc;
RandomizerCheckQuest quest; RandomizerCheckQuest quest;
RandomizerCheckType checkType; RandomizerCheckType checkType;
RandomizerCheckArea area; RandomizerCheckArea area;
LocationType locationType;
ActorID actorId; ActorID actorId;
uint8_t scene; SceneID scene;
int32_t actorParams; int32_t actorParams;
uint8_t flag;
bool checked = false; bool checked = false;
std::string shortName; std::string shortName;
std::string spoilerName; std::string spoilerName;
RandomizerHintTextKey hintKey; RandomizerHintTextKey hintKey;
RandomizerGet vanillaItem; RandomizerGet vanillaItem;
std::vector<Category> categories;
bool isVanillaCompletion; bool isVanillaCompletion;
SpoilerCollectionCheck collectionCheck; SpoilerCollectionCheck collectionCheck;
SpoilerCollectionCheckGroup collectionCheckGroup;
bool isHintable = false; bool isHintable = false;
}; };
} // namespace Rando } // namespace Rando

2337
soh/soh/Enhancements/randomizer/location_list.cpp
View File

File diff suppressed because it is too large Load Diff

22
soh/soh/Enhancements/randomizer/randomizerTypes.h
View File

@ -247,23 +247,25 @@ typedef enum {
RCTYPE_COW, // Cows RCTYPE_COW, // Cows
RCTYPE_ADULT_TRADE, // Adult trade quest checks RCTYPE_ADULT_TRADE, // Adult trade quest checks
RCTYPE_FROG_SONG, // Frog song purple rupee checks RCTYPE_FROG_SONG, // Frog song purple rupee checks
RCTYPE_MAP_COMPASS, // Maps/Compasses RCTYPE_MAP, // Maps
RCTYPE_COMPASS, // Compasses
RCTYPE_SMALL_KEY, // Small Keys RCTYPE_SMALL_KEY, // Small Keys
RCTYPE_GF_KEY, // Gerudo Fortress Keys RCTYPE_GF_KEY, // Gerudo Fortress Keys
RCTYPE_BOSS_KEY, // Boss Keys RCTYPE_BOSS_KEY, // Boss Keys
RCTYPE_GANON_BOSS_KEY, // Ganon's boss key RCTYPE_GANON_BOSS_KEY, // Ganon's boss key
RCTYPE_SHOP, // shops RCTYPE_SHOP, // Shops
RCTYPE_SCRUB, // scrubs RCTYPE_SCRUB, // Scrubs
RCTYPE_MERCHANT, // merchants RCTYPE_MERCHANT, // Merchants
RCTYPE_CHEST_GAME, // RANDOTODO replace this once we implement it, just using it to exclude for now RCTYPE_CHEST_GAME, // RANDOTODO replace this once we implement it, just using it to exclude for now
RCTYPE_LINKS_POCKET, // RANDOTODO this feels hacky, replace with better starting items RCTYPE_LINKS_POCKET, // RANDOTODO this feels hacky, replace with better starting items
RCTYPE_GOSSIP_STONE, // RANDOTODO make these into event access RCTYPE_GOSSIP_STONE, // RANDOTODO make these into event access
RCTYPE_STATIC_HINT, // RANDOTODO make these into event access
RCTYPE_SONG_LOCATION, // Song locations RCTYPE_SONG_LOCATION, // Song locations
RCTYPE_BOSS_HEART_OR_OTHER_REWARD, // Boss heart container or lesser dungeon rewards (lens, ice arrow) RCTYPE_BOSS_HEART_OR_OTHER_REWARD, // Boss heart container or lesser dungeon rewards (lens, ice arrow)
RCTYPE_DUNGEON_REWARD, // Dungeon rewards (blue warps) RCTYPE_DUNGEON_REWARD, // Dungeon rewards (blue warps)
RCTYPE_OCARINA, // Ocarina locations RCTYPE_OCARINA, // Ocarina locations
RCTYPE_BEEHIVE, // Beehives RCTYPE_BEEHIVE, // Beehives
RCTYPE_FISH, RCTYPE_FISH, // Fishes
} RandomizerCheckType; } RandomizerCheckType;
typedef enum { RCQUEST_VANILLA, RCQUEST_MQ, RCQUEST_BOTH } RandomizerCheckQuest; typedef enum { RCQUEST_VANILLA, RCQUEST_MQ, RCQUEST_BOTH } RandomizerCheckQuest;
@ -3651,17 +3653,21 @@ typedef enum {
RSG_LOGIC, RSG_LOGIC,
RSG_EXCLUDES_KOKIRI_FOREST, RSG_EXCLUDES_KOKIRI_FOREST,
RSG_EXCLUDES_LOST_WOODS, RSG_EXCLUDES_LOST_WOODS,
RSG_EXCLUDES_SACRED_FOREST_MEADOW,
RSG_EXCLUDES_DEKU_TREE, RSG_EXCLUDES_DEKU_TREE,
RSG_EXCLUDES_FOREST_TEMPLE, RSG_EXCLUDES_FOREST_TEMPLE,
RSG_EXCLUDES_KAKARIKO_VILLAGE, RSG_EXCLUDES_KAKARIKO_VILLAGE,
RSG_EXCLUDES_GRAVEYARD,
RSG_EXCLUDES_BOTTOM_OF_THE_WELL, RSG_EXCLUDES_BOTTOM_OF_THE_WELL,
RSG_EXCLUDES_SHADOW_TEMPLE, RSG_EXCLUDES_SHADOW_TEMPLE,
RSG_EXCLUDES_DEATH_MOUNTAIN, RSG_EXCLUDES_DEATH_MOUNTAIN_TRAIL,
RSG_EXCLUDES_DEATH_MOUNTAIN_CRATER,
RSG_EXCLUDES_GORON_CITY, RSG_EXCLUDES_GORON_CITY,
RSG_EXCLUDES_DODONGOS_CAVERN, RSG_EXCLUDES_DODONGOS_CAVERN,
RSG_EXCLUDES_FIRE_TEMPLE, RSG_EXCLUDES_FIRE_TEMPLE,
RSG_EXCLUDES_ZORAS_RIVER, RSG_EXCLUDES_ZORAS_RIVER,
RSG_EXCLUDES_ZORAS_DOMAIN, RSG_EXCLUDES_ZORAS_DOMAIN,
RSG_EXCLUDES_ZORAS_FOUNTAIN,
RSG_EXCLUDES_JABU_JABU, RSG_EXCLUDES_JABU_JABU,
RSG_EXCLUDES_ICE_CAVERN, RSG_EXCLUDES_ICE_CAVERN,
RSG_EXCLUDES_HYRULE_FIELD, RSG_EXCLUDES_HYRULE_FIELD,
@ -3669,9 +3675,13 @@ typedef enum {
RSG_EXCLUDES_LAKE_HYLIA, RSG_EXCLUDES_LAKE_HYLIA,
RSG_EXCLUDES_WATER_TEMPLE, RSG_EXCLUDES_WATER_TEMPLE,
RSG_EXCLUDES_GERUDO_VALLEY, RSG_EXCLUDES_GERUDO_VALLEY,
RSG_EXCLUDES_GERUDO_FORTRESS,
RSG_EXCLUDES_HAUNTED_WASTELAND,
RSG_EXCLUDES_DESERT_COLOSSUS,
RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS, RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS,
RSG_EXCLUDES_SPIRIT_TEMPLE, RSG_EXCLUDES_SPIRIT_TEMPLE,
RSG_EXCLUDES_HYRULE_CASTLE, RSG_EXCLUDES_HYRULE_CASTLE,
RSG_EXCLUDES_MARKET,
RSG_EXCLUDES_GANONS_CASTLE, RSG_EXCLUDES_GANONS_CASTLE,
RSG_EXCLUDES, RSG_EXCLUDES,
RSG_TRICKS, RSG_TRICKS,

6
soh/soh/Enhancements/randomizer/randomizer_check_objects.cpp
View File

@ -143,8 +143,8 @@ void RandomizerCheckObjects::UpdateImGuiVisibility() {
(location.GetRCType() != RCTYPE_OCARINA || (location.GetRCType() != RCTYPE_OCARINA ||
CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleOcarinas"), RO_GENERIC_NO)) && // ocarina locations CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleOcarinas"), RO_GENERIC_NO)) && // ocarina locations
(location.GetRandomizerCheck() != RC_HC_ZELDAS_LETTER) && // don't show until we support shuffling letter (location.GetRandomizerCheck() != RC_HC_ZELDAS_LETTER) && // don't show until we support shuffling letter
(location.GetRCType() != (location.GetRCType() != RCTYPE_GOSSIP_STONE) && // don't show gossip stones (maybe gossipsanity will be a thing eventually?)
RCTYPE_GOSSIP_STONE) && // don't show gossip stones (maybe gossipsanity will be a thing eventually?) (location.GetRCType() != RCTYPE_STATIC_HINT) && // don't show static hints
(location.GetRCType() != RCTYPE_LINKS_POCKET) && // links pocket can be set to nothing if needed (location.GetRCType() != RCTYPE_LINKS_POCKET) && // links pocket can be set to nothing if needed
(location.GetRCType() != (location.GetRCType() !=
RCTYPE_CHEST_GAME) && // don't show non final reward chest game checks until we support shuffling them RCTYPE_CHEST_GAME) && // don't show non final reward chest game checks until we support shuffling them
@ -169,7 +169,7 @@ void RandomizerCheckObjects::UpdateImGuiVisibility() {
CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleWeirdEgg"), RO_GENERIC_NO)) && CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleWeirdEgg"), RO_GENERIC_NO)) &&
(location.GetRCType() != RCTYPE_FROG_SONG || (location.GetRCType() != RCTYPE_FROG_SONG ||
CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleFrogSongRupees"), RO_GENERIC_NO)) && CVarGetInteger(CVAR_RANDOMIZER_SETTING("ShuffleFrogSongRupees"), RO_GENERIC_NO)) &&
(location.GetRCType() != RCTYPE_MAP_COMPASS || ((location.GetRCType() != RCTYPE_MAP && location.GetRCType() != RCTYPE_COMPASS) ||
CVarGetInteger(CVAR_RANDOMIZER_SETTING("StartingMapsCompasses"), RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) != CVarGetInteger(CVAR_RANDOMIZER_SETTING("StartingMapsCompasses"), RO_DUNGEON_ITEM_LOC_OWN_DUNGEON) !=
RO_DUNGEON_ITEM_LOC_VANILLA) && RO_DUNGEON_ITEM_LOC_VANILLA) &&
(location.GetRCType() != RCTYPE_SMALL_KEY || (location.GetRCType() != RCTYPE_SMALL_KEY ||

9
soh/soh/Enhancements/randomizer/randomizer_check_tracker.cpp
View File

@ -734,11 +734,7 @@ void CheckTrackerFlagSet(int16_t flagType, int32_t flag) {
} }
Rando::SpoilerCollectionCheck scCheck = loc.GetCollectionCheck(); Rando::SpoilerCollectionCheck scCheck = loc.GetCollectionCheck();
SpoilerCollectionCheckType scCheckType = scCheck.type; SpoilerCollectionCheckType scCheckType = scCheck.type;
if (checkMatchType == SpoilerCollectionCheckType::SPOILER_CHK_RANDOMIZER_INF && if (checkMatchType == SpoilerCollectionCheckType::SPOILER_CHK_RANDOMIZER_INF && scCheckType == SpoilerCollectionCheckType::SPOILER_CHK_RANDOMIZER_INF) {
(scCheckType == SpoilerCollectionCheckType::SPOILER_CHK_SHOP_ITEM ||
scCheckType == SpoilerCollectionCheckType::SPOILER_CHK_FISH ||
scCheckType == SpoilerCollectionCheckType::SPOILER_CHK_MASTER_SWORD ||
scCheckType == SpoilerCollectionCheckType::SPOILER_CHK_RANDOMIZER_INF)) {
if (flag == OTRGlobals::Instance->gRandomizer->GetRandomizerInfFromCheck(loc.GetRandomizerCheck())) { if (flag == OTRGlobals::Instance->gRandomizer->GetRandomizerInfFromCheck(loc.GetRandomizerCheck())) {
SetCheckCollected(loc.GetRandomizerCheck()); SetCheckCollected(loc.GetRandomizerCheck());
return; return;
@ -1225,6 +1221,7 @@ bool IsCheckShuffled(RandomizerCheck rc) {
return return
(loc->GetArea() != RCAREA_INVALID) && // don't show Invalid locations (loc->GetArea() != RCAREA_INVALID) && // don't show Invalid locations
(loc->GetRCType() != RCTYPE_GOSSIP_STONE) && //TODO: Don't show hints until tracker supports them (loc->GetRCType() != RCTYPE_GOSSIP_STONE) && //TODO: Don't show hints until tracker supports them
(loc->GetRCType() != RCTYPE_STATIC_HINT) && //TODO: Don't show hints until tracker supports them
(loc->GetRCType() != RCTYPE_CHEST_GAME) && // don't show non final reward chest game checks until we support shuffling them (loc->GetRCType() != RCTYPE_CHEST_GAME) && // don't show non final reward chest game checks until we support shuffling them
(rc != RC_HC_ZELDAS_LETTER) && // don't show zeldas letter until we support shuffling it (rc != RC_HC_ZELDAS_LETTER) && // don't show zeldas letter until we support shuffling it
(rc != RC_LINKS_POCKET || showLinksPocket) && (rc != RC_LINKS_POCKET || showLinksPocket) &&
@ -1262,7 +1259,7 @@ bool IsCheckShuffled(RandomizerCheck rc) {
(rc != RC_ZR_MAGIC_BEAN_SALESMAN || showBeans) && (rc != RC_ZR_MAGIC_BEAN_SALESMAN || showBeans) &&
(rc != RC_HC_MALON_EGG || showWeirdEgg) && (rc != RC_HC_MALON_EGG || showWeirdEgg) &&
(loc->GetRCType() != RCTYPE_FROG_SONG || showFrogSongRupees) && (loc->GetRCType() != RCTYPE_FROG_SONG || showFrogSongRupees) &&
(loc->GetRCType() != RCTYPE_MAP_COMPASS || showStartingMapsCompasses) && ((loc->GetRCType() != RCTYPE_MAP && loc->GetRCType() != RCTYPE_COMPASS) || showStartingMapsCompasses) &&
(loc->GetRCType() != RCTYPE_SMALL_KEY || showKeysanity) && (loc->GetRCType() != RCTYPE_SMALL_KEY || showKeysanity) &&
(loc->GetRCType() != RCTYPE_BOSS_KEY || showBossKeysanity) && (loc->GetRCType() != RCTYPE_BOSS_KEY || showBossKeysanity) &&
(loc->GetRCType() != RCTYPE_GANON_BOSS_KEY || showGanonBossKey) && (loc->GetRCType() != RCTYPE_GANON_BOSS_KEY || showGanonBossKey) &&

76
soh/soh/Enhancements/randomizer/settings.cpp
View File

@ -36,7 +36,7 @@ std::vector<std::string> MultiVecOpts(const std::vector<std::vector<std::string>
return options; return options;
} }
Settings::Settings() : mExcludeLocationsOptionsGroups(SPOILER_COLLECTION_GROUP_COUNT) { Settings::Settings() : mExcludeLocationsOptionsAreas(RCAREA_INVALID) {
} }
void Settings::CreateOptions() { void Settings::CreateOptions() {
@ -217,7 +217,7 @@ void Settings::CreateOptions() {
mOptions[RSK_DAMAGE_MULTIPLIER] = Option::U8("Damage Multiplier", {"x1/2", "x1", "x2", "x4", "x8", "x16", "OHKO"}, OptionCategory::Setting, "", "", WidgetType::Slider, RO_DAMAGE_MULTIPLIER_DEFAULT); mOptions[RSK_DAMAGE_MULTIPLIER] = Option::U8("Damage Multiplier", {"x1/2", "x1", "x2", "x4", "x8", "x16", "OHKO"}, OptionCategory::Setting, "", "", WidgetType::Slider, RO_DAMAGE_MULTIPLIER_DEFAULT);
// clang-format on // clang-format on
mExcludeLocationsOptionsGroups.reserve(SPOILER_COLLECTION_GROUP_COUNT); mExcludeLocationsOptionsAreas.reserve(RCAREA_INVALID);
mTrickOptions[RT_ACUTE_ANGLE_CLIP] = TrickOption::LogicTrick(RCQUEST_BOTH, RA_NONE, {Tricks::Tag::ADVANCED}, true, "Acute angle clip", "Enables locations requiring jumpslash clips through walls which meet at an acute angle."); mTrickOptions[RT_ACUTE_ANGLE_CLIP] = TrickOption::LogicTrick(RCQUEST_BOTH, RA_NONE, {Tricks::Tag::ADVANCED}, true, "Acute angle clip", "Enables locations requiring jumpslash clips through walls which meet at an acute angle.");
mTrickOptions[RT_ADVANCED_CLIPS] = TrickOption::LogicTrick(RCQUEST_BOTH, RA_NONE, {Tricks::Tag::ADVANCED}, true, "Advanced clips", "Enables locations requiring clips through walls and objects requiring precise jumps or other tricks."); mTrickOptions[RT_ADVANCED_CLIPS] = TrickOption::LogicTrick(RCQUEST_BOTH, RA_NONE, {Tricks::Tag::ADVANCED}, true, "Advanced clips", "Enables locations requiring clips through walls and objects requiring precise jumps or other tricks.");
@ -1007,44 +1007,56 @@ void Settings::CreateOptions() {
&mOptions[RSK_ICE_TRAPS] &mOptions[RSK_ICE_TRAPS]
})); }));
// TODO: Progressive Goron Sword, Remove Double Defense // TODO: Progressive Goron Sword, Remove Double Defense
mOptionGroups[RSG_EXCLUDES_KOKIRI_FOREST] = OptionGroup::SubGroup("Kokiri Forest", mExcludeLocationsOptionsGroups[GROUP_KOKIRI_FOREST], false); mOptionGroups[RSG_EXCLUDES_KOKIRI_FOREST] = OptionGroup::SubGroup("Kokiri Forest", mExcludeLocationsOptionsAreas[RCAREA_KOKIRI_FOREST], false);
mOptionGroups[RSG_EXCLUDES_LOST_WOODS] = OptionGroup::SubGroup("Lost Woods", mExcludeLocationsOptionsGroups[GROUP_LOST_WOODS], false); mOptionGroups[RSG_EXCLUDES_LOST_WOODS] = OptionGroup::SubGroup("Lost Woods", mExcludeLocationsOptionsAreas[RCAREA_LOST_WOODS], false);
mOptionGroups[RSG_EXCLUDES_DEKU_TREE] = OptionGroup::SubGroup("Deku Tree", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_DEKU_TREE], false); mOptionGroups[RSG_EXCLUDES_SACRED_FOREST_MEADOW] = OptionGroup::SubGroup("Sacred Forest Meadow", mExcludeLocationsOptionsAreas[RCAREA_SACRED_FOREST_MEADOW], false);
mOptionGroups[RSG_EXCLUDES_FOREST_TEMPLE] = OptionGroup::SubGroup("Forest Temple", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_FOREST_TEMPLE], false); mOptionGroups[RSG_EXCLUDES_DEKU_TREE] = OptionGroup::SubGroup("Deku Tree", mExcludeLocationsOptionsAreas[RCAREA_DEKU_TREE], false);
mOptionGroups[RSG_EXCLUDES_KAKARIKO_VILLAGE] = OptionGroup::SubGroup("Kakariko Village", mExcludeLocationsOptionsGroups[GROUP_KAKARIKO], false); mOptionGroups[RSG_EXCLUDES_FOREST_TEMPLE] = OptionGroup::SubGroup("Forest Temple", mExcludeLocationsOptionsAreas[RCAREA_FOREST_TEMPLE], false);
mOptionGroups[RSG_EXCLUDES_BOTTOM_OF_THE_WELL] = OptionGroup::SubGroup("Bottom of the Well", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_BOTTOM_OF_THE_WELL], false); mOptionGroups[RSG_EXCLUDES_KAKARIKO_VILLAGE] = OptionGroup::SubGroup("Kakariko Village", mExcludeLocationsOptionsAreas[RCAREA_KAKARIKO_VILLAGE], false);
mOptionGroups[RSG_EXCLUDES_SHADOW_TEMPLE] = OptionGroup::SubGroup("Shadow Temple", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_SHADOW_TEMPLE], false); mOptionGroups[RSG_EXCLUDES_GRAVEYARD] = OptionGroup::SubGroup("Graveyard", mExcludeLocationsOptionsAreas[RCAREA_GRAVEYARD], false);
mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN] = OptionGroup::SubGroup("Death Mountain", mExcludeLocationsOptionsGroups[GROUP_DEATH_MOUNTAIN], false); mOptionGroups[RSG_EXCLUDES_BOTTOM_OF_THE_WELL] = OptionGroup::SubGroup("Bottom of the Well", mExcludeLocationsOptionsAreas[RCAREA_BOTTOM_OF_THE_WELL], false);
mOptionGroups[RSG_EXCLUDES_GORON_CITY] = OptionGroup::SubGroup("Goron City", mExcludeLocationsOptionsGroups[GROUP_GORON_CITY], false); mOptionGroups[RSG_EXCLUDES_SHADOW_TEMPLE] = OptionGroup::SubGroup("Shadow Temple", mExcludeLocationsOptionsAreas[RCAREA_SHADOW_TEMPLE], false);
mOptionGroups[RSG_EXCLUDES_DODONGOS_CAVERN] = OptionGroup::SubGroup("Dodongo's Cavern", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_DODONGOS_CAVERN], false); mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN_TRAIL] = OptionGroup::SubGroup("Death Mountain Trail", mExcludeLocationsOptionsAreas[RCAREA_DEATH_MOUNTAIN_TRAIL], false);
mOptionGroups[RSG_EXCLUDES_FIRE_TEMPLE] = OptionGroup::SubGroup("Fire Temple", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_FIRE_TEMPLE], false); mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN_CRATER] = OptionGroup::SubGroup("Death Mountain Crater", mExcludeLocationsOptionsAreas[RCAREA_DEATH_MOUNTAIN_CRATER], false);
mOptionGroups[RSG_EXCLUDES_ZORAS_RIVER] = OptionGroup::SubGroup("Zora's River", mExcludeLocationsOptionsGroups[GROUP_ZORAS_RIVER], false); mOptionGroups[RSG_EXCLUDES_GORON_CITY] = OptionGroup::SubGroup("Goron City", mExcludeLocationsOptionsAreas[RCAREA_GORON_CITY], false);
mOptionGroups[RSG_EXCLUDES_ZORAS_DOMAIN] = OptionGroup::SubGroup("Zora's Domain", mExcludeLocationsOptionsGroups[GROUP_ZORAS_DOMAIN], false); mOptionGroups[RSG_EXCLUDES_DODONGOS_CAVERN] = OptionGroup::SubGroup("Dodongo's Cavern", mExcludeLocationsOptionsAreas[RCAREA_DODONGOS_CAVERN], false);
mOptionGroups[RSG_EXCLUDES_JABU_JABU] = OptionGroup::SubGroup("Jabu Jabu's Belly", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_JABUJABUS_BELLY], false); mOptionGroups[RSG_EXCLUDES_FIRE_TEMPLE] = OptionGroup::SubGroup("Fire Temple", mExcludeLocationsOptionsAreas[RCAREA_FIRE_TEMPLE], false);
mOptionGroups[RSG_EXCLUDES_ICE_CAVERN] = OptionGroup::SubGroup("Ice Cavern", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_ICE_CAVERN], false); mOptionGroups[RSG_EXCLUDES_ZORAS_RIVER] = OptionGroup::SubGroup("Zora's River", mExcludeLocationsOptionsAreas[RCAREA_ZORAS_RIVER], false);
mOptionGroups[RSG_EXCLUDES_HYRULE_FIELD] = OptionGroup::SubGroup("Hyrule Field", mExcludeLocationsOptionsGroups[GROUP_HYRULE_FIELD], false); mOptionGroups[RSG_EXCLUDES_ZORAS_DOMAIN] = OptionGroup::SubGroup("Zora's Domain", mExcludeLocationsOptionsAreas[RCAREA_ZORAS_DOMAIN], false);
mOptionGroups[RSG_EXCLUDES_LON_LON_RANCH] = OptionGroup::SubGroup("Lon Lon Ranch", mExcludeLocationsOptionsGroups[GROUP_LON_LON_RANCH], false); mOptionGroups[RSG_EXCLUDES_ZORAS_FOUNTAIN] = OptionGroup::SubGroup("Zora's Fountain", mExcludeLocationsOptionsAreas[RCAREA_ZORAS_FOUNTAIN], false);
mOptionGroups[RSG_EXCLUDES_LAKE_HYLIA] = OptionGroup::SubGroup("Lake Hylia", mExcludeLocationsOptionsGroups[GROUP_LAKE_HYLIA], false); mOptionGroups[RSG_EXCLUDES_JABU_JABU] = OptionGroup::SubGroup("Jabu Jabu's Belly", mExcludeLocationsOptionsAreas[RCAREA_JABU_JABUS_BELLY], false);
mOptionGroups[RSG_EXCLUDES_WATER_TEMPLE] = OptionGroup::SubGroup("Water Temple", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_WATER_TEMPLE], false); mOptionGroups[RSG_EXCLUDES_ICE_CAVERN] = OptionGroup::SubGroup("Ice Cavern", mExcludeLocationsOptionsAreas[RCAREA_ICE_CAVERN], false);
mOptionGroups[RSG_EXCLUDES_GERUDO_VALLEY] = OptionGroup::SubGroup("Gerudo Valley", mExcludeLocationsOptionsGroups[GROUP_GERUDO_VALLEY], false); mOptionGroups[RSG_EXCLUDES_HYRULE_FIELD] = OptionGroup::SubGroup("Hyrule Field", mExcludeLocationsOptionsAreas[RCAREA_HYRULE_FIELD], false);
mOptionGroups[RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS] = OptionGroup::SubGroup("Gerudo Training Grounds", mExcludeLocationsOptionsGroups[GROUP_GERUDO_TRAINING_GROUND], false); mOptionGroups[RSG_EXCLUDES_LON_LON_RANCH] = OptionGroup::SubGroup("Lon Lon Ranch", mExcludeLocationsOptionsAreas[RCAREA_LON_LON_RANCH], false);
mOptionGroups[RSG_EXCLUDES_SPIRIT_TEMPLE] = OptionGroup::SubGroup("Spirit Temple", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_SPIRIT_TEMPLE], false); mOptionGroups[RSG_EXCLUDES_LAKE_HYLIA] = OptionGroup::SubGroup("Lake Hylia", mExcludeLocationsOptionsAreas[RCAREA_LAKE_HYLIA], false);
mOptionGroups[RSG_EXCLUDES_HYRULE_CASTLE] = OptionGroup::SubGroup("Hyrule Castle", mExcludeLocationsOptionsGroups[GROUP_HYRULE_CASTLE], false); mOptionGroups[RSG_EXCLUDES_WATER_TEMPLE] = OptionGroup::SubGroup("Water Temple", mExcludeLocationsOptionsAreas[RCAREA_WATER_TEMPLE], false);
mOptionGroups[RSG_EXCLUDES_GANONS_CASTLE] = OptionGroup::SubGroup("Ganon's Castle", mExcludeLocationsOptionsGroups[GROUP_DUNGEON_GANONS_CASTLE], false); mOptionGroups[RSG_EXCLUDES_GERUDO_VALLEY] = OptionGroup::SubGroup("Gerudo Valley", mExcludeLocationsOptionsAreas[RCAREA_GERUDO_VALLEY], false);
mOptionGroups[RSG_EXCLUDES_GERUDO_FORTRESS] = OptionGroup::SubGroup("Gerudo Fortress", mExcludeLocationsOptionsAreas[RCAREA_GERUDO_FORTRESS], false);
mOptionGroups[RSG_EXCLUDES_HAUNTED_WASTELAND] = OptionGroup::SubGroup("Haunted Wasteland", mExcludeLocationsOptionsAreas[RCAREA_WASTELAND], false);
mOptionGroups[RSG_EXCLUDES_DESERT_COLOSSUS] = OptionGroup::SubGroup("Desert Colossus", mExcludeLocationsOptionsAreas[RCAREA_DESERT_COLOSSUS], false);
mOptionGroups[RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS] = OptionGroup::SubGroup("Gerudo Training Grounds", mExcludeLocationsOptionsAreas[RCAREA_GERUDO_TRAINING_GROUND], false);
mOptionGroups[RSG_EXCLUDES_SPIRIT_TEMPLE] = OptionGroup::SubGroup("Spirit Temple", mExcludeLocationsOptionsAreas[RCAREA_SPIRIT_TEMPLE], false);
mOptionGroups[RSG_EXCLUDES_HYRULE_CASTLE] = OptionGroup::SubGroup("Hyrule Castle", mExcludeLocationsOptionsAreas[RCAREA_HYRULE_CASTLE], false);
mOptionGroups[RSG_EXCLUDES_MARKET] = OptionGroup::SubGroup("Market", mExcludeLocationsOptionsAreas[RCAREA_MARKET], false);
mOptionGroups[RSG_EXCLUDES_GANONS_CASTLE] = OptionGroup::SubGroup("Ganon's Castle", mExcludeLocationsOptionsAreas[RCAREA_GANONS_CASTLE], false);
mOptionGroups[RSG_EXCLUDES] = OptionGroup::SubGroup("Exclude Locations", { mOptionGroups[RSG_EXCLUDES] = OptionGroup::SubGroup("Exclude Locations", {
&mOptionGroups[RSG_EXCLUDES_KOKIRI_FOREST], &mOptionGroups[RSG_EXCLUDES_KOKIRI_FOREST],
&mOptionGroups[RSG_EXCLUDES_LOST_WOODS], &mOptionGroups[RSG_EXCLUDES_LOST_WOODS],
&mOptionGroups[RSG_EXCLUDES_SACRED_FOREST_MEADOW],
&mOptionGroups[RSG_EXCLUDES_DEKU_TREE], &mOptionGroups[RSG_EXCLUDES_DEKU_TREE],
&mOptionGroups[RSG_EXCLUDES_FOREST_TEMPLE], &mOptionGroups[RSG_EXCLUDES_FOREST_TEMPLE],
&mOptionGroups[RSG_EXCLUDES_KAKARIKO_VILLAGE], &mOptionGroups[RSG_EXCLUDES_KAKARIKO_VILLAGE],
&mOptionGroups[RSG_EXCLUDES_GRAVEYARD],
&mOptionGroups[RSG_EXCLUDES_BOTTOM_OF_THE_WELL], &mOptionGroups[RSG_EXCLUDES_BOTTOM_OF_THE_WELL],
&mOptionGroups[RSG_EXCLUDES_SHADOW_TEMPLE], &mOptionGroups[RSG_EXCLUDES_SHADOW_TEMPLE],
&mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN], &mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN_TRAIL],
&mOptionGroups[RSG_EXCLUDES_DEATH_MOUNTAIN_CRATER],
&mOptionGroups[RSG_EXCLUDES_GORON_CITY], &mOptionGroups[RSG_EXCLUDES_GORON_CITY],
&mOptionGroups[RSG_EXCLUDES_DODONGOS_CAVERN], &mOptionGroups[RSG_EXCLUDES_DODONGOS_CAVERN],
&mOptionGroups[RSG_EXCLUDES_FIRE_TEMPLE], &mOptionGroups[RSG_EXCLUDES_FIRE_TEMPLE],
&mOptionGroups[RSG_EXCLUDES_ZORAS_RIVER], &mOptionGroups[RSG_EXCLUDES_ZORAS_RIVER],
&mOptionGroups[RSG_EXCLUDES_ZORAS_DOMAIN], &mOptionGroups[RSG_EXCLUDES_ZORAS_DOMAIN],
&mOptionGroups[RSG_EXCLUDES_ZORAS_FOUNTAIN],
&mOptionGroups[RSG_EXCLUDES_JABU_JABU], &mOptionGroups[RSG_EXCLUDES_JABU_JABU],
&mOptionGroups[RSG_EXCLUDES_ICE_CAVERN], &mOptionGroups[RSG_EXCLUDES_ICE_CAVERN],
&mOptionGroups[RSG_EXCLUDES_HYRULE_FIELD], &mOptionGroups[RSG_EXCLUDES_HYRULE_FIELD],
@ -1052,9 +1064,13 @@ void Settings::CreateOptions() {
&mOptionGroups[RSG_EXCLUDES_LAKE_HYLIA], &mOptionGroups[RSG_EXCLUDES_LAKE_HYLIA],
&mOptionGroups[RSG_EXCLUDES_WATER_TEMPLE], &mOptionGroups[RSG_EXCLUDES_WATER_TEMPLE],
&mOptionGroups[RSG_EXCLUDES_GERUDO_VALLEY], &mOptionGroups[RSG_EXCLUDES_GERUDO_VALLEY],
&mOptionGroups[RSG_EXCLUDES_GERUDO_FORTRESS],
&mOptionGroups[RSG_EXCLUDES_HAUNTED_WASTELAND],
&mOptionGroups[RSG_EXCLUDES_DESERT_COLOSSUS],
&mOptionGroups[RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS], &mOptionGroups[RSG_EXCLUDES_GERUDO_TRAINING_GROUNDS],
&mOptionGroups[RSG_EXCLUDES_SPIRIT_TEMPLE], &mOptionGroups[RSG_EXCLUDES_SPIRIT_TEMPLE],
&mOptionGroups[RSG_EXCLUDES_HYRULE_CASTLE], &mOptionGroups[RSG_EXCLUDES_HYRULE_CASTLE],
&mOptionGroups[RSG_EXCLUDES_MARKET],
&mOptionGroups[RSG_EXCLUDES_GANONS_CASTLE], &mOptionGroups[RSG_EXCLUDES_GANONS_CASTLE],
}, false); }, false);
mOptionGroups[RSG_DETAILED_LOGIC] = OptionGroup("Detailed Logic Settings", { mOptionGroups[RSG_DETAILED_LOGIC] = OptionGroup("Detailed Logic Settings", {
@ -1267,12 +1283,12 @@ const std::array<Option, RSK_MAX>& Settings::GetAllOptions() const {
return mOptions; return mOptions;
} }
std::vector<Option *>& Settings::GetExcludeOptionsForGroup(const SpoilerCollectionCheckGroup group) { std::vector<Option *>& Settings::GetExcludeOptionsForArea(const RandomizerCheckArea area) {
return mExcludeLocationsOptionsGroups[group]; return mExcludeLocationsOptionsAreas[area];
} }
const std::vector<std::vector<Option *>>& Settings::GetExcludeLocationsOptions() const { const std::vector<std::vector<Option *>>& Settings::GetExcludeLocationsOptions() const {
return mExcludeLocationsOptionsGroups; return mExcludeLocationsOptionsAreas;
} }
RandoOptionStartingAge Settings::ResolvedStartingAge() const { RandoOptionStartingAge Settings::ResolvedStartingAge() const {

6
soh/soh/Enhancements/randomizer/settings.h
View File

@ -50,12 +50,12 @@ class Settings {
/** /**
* @brief Get a list of Location Exclude `Option`s for the given * @brief Get a list of Location Exclude `Option`s for the given
* SpoilerCollectionCheckGroup * RandomizerCheckArea
* *
* @param group * @param group
* @return std::vector<Option*>& * @return std::vector<Option*>&
*/ */
std::vector<Option*>& GetExcludeOptionsForGroup(SpoilerCollectionCheckGroup group); std::vector<Option*>& GetExcludeOptionsForArea(RandomizerCheckArea area);
/** /**
* @brief Get a reference to all of the Exclude Location `Option` lists. * @brief Get a reference to all of the Exclude Location `Option` lists.
@ -185,7 +185,7 @@ class Settings {
std::array<std::string, RSK_MAX> mOptionDescriptions = {}; std::array<std::string, RSK_MAX> mOptionDescriptions = {};
std::array<OptionGroup, RSG_MAX> mOptionGroups = {}; std::array<OptionGroup, RSG_MAX> mOptionGroups = {};
std::array<TrickOption, RT_MAX> mTrickOptions = {}; std::array<TrickOption, RT_MAX> mTrickOptions = {};
std::vector<std::vector<Option*>> mExcludeLocationsOptionsGroups = {}; std::vector<std::vector<Option*>> mExcludeLocationsOptionsAreas = {};
std::unordered_map<std::string, RandomizerSettingKey> mSpoilerfileSettingNameToEnum; std::unordered_map<std::string, RandomizerSettingKey> mSpoilerfileSettingNameToEnum;
RandoOptionStartingAge mResolvedStartingAge = RO_AGE_CHILD; RandoOptionStartingAge mResolvedStartingAge = RO_AGE_CHILD;
RandoOptionLACSCondition mLACSCondition = RO_LACS_VANILLA; RandoOptionLACSCondition mLACSCondition = RO_LACS_VANILLA;

14
soh/soh/Enhancements/randomizer/static_data.h
View File

@ -35,14 +35,14 @@ class StaticData {
static std::unordered_map<std::string, uint32_t> PopulateTranslationMap(std::unordered_map<uint32_t, CustomMessage> input); static std::unordered_map<std::string, uint32_t> PopulateTranslationMap(std::unordered_map<uint32_t, CustomMessage> input);
static std::unordered_map<std::string, uint32_t> PopulateTranslationMap(std::unordered_map<uint32_t, RandomizerHintTextKey> input); static std::unordered_map<std::string, uint32_t> PopulateTranslationMap(std::unordered_map<uint32_t, RandomizerHintTextKey> input);
static std::multimap<std::tuple<s16, s16, s32>, RandomizerCheck> CheckFromActorMultimap; static std::multimap<std::tuple<s16, s16, s32>, RandomizerCheck> CheckFromActorMultimap;
static std::vector<RandomizerCheck> overworldLocations; static std::vector<RandomizerCheck> GetOverworldLocations();
static std::vector<RandomizerCheck> dungeonRewardLocations; static std::vector<RandomizerCheck> dungeonRewardLocations;
static std::vector<std::vector<RandomizerCheck>> shopLocationLists; static std::vector<RandomizerCheck> GetShopLocations();
static std::vector<RandomizerCheck> scrubLocations; static std::vector<RandomizerCheck> GetScrubLocations();
static std::vector<RandomizerCheck> gossipStoneLocations; static std::vector<RandomizerCheck> GetGossipStoneLocations();
static std::vector<RandomizerCheck> staticHintLocations; static std::vector<RandomizerCheck> GetStaticHintLocations();
static std::vector<RandomizerCheck> pondFishLocations; static std::vector<RandomizerCheck> GetPondFishLocations();
static std::vector<RandomizerCheck> overworldFishLocations; static std::vector<RandomizerCheck> GetOverworldFishLocations();
static std::array<std::pair<RandomizerCheck, RandomizerCheck>, 17> randomizerFishingPondFish; static std::array<std::pair<RandomizerCheck, RandomizerCheck>, 17> randomizerFishingPondFish;
static std::unordered_map<int8_t, RandomizerCheck> randomizerGrottoFishMap; static std::unordered_map<int8_t, RandomizerCheck> randomizerGrottoFishMap;
static std::vector<RandomizerHint> oldVerHintOrder; static std::vector<RandomizerHint> oldVerHintOrder;