mirror/Shipwright
1
0
Fork 0
mirror of https://github.com/HarbourMasters/Shipwright.git synced 2024-12-21 23:58:51 -05:00
Code Issues Projects Releases Wiki Activity

Trick logic (#2681)

Browse Source 
* Trick and Glitch Rando UI implemented

* initial temp connection between ui and backend trick logic

Hacky way to connect the logic for testing. Ran into 1 crash but cannot reproduce

* UI overhaul to look more like AudioEditor tag section

* Mapped 3d tricks to enums and save cvar bug fixes

* Trick Logic Complete

Testing on whether the logic works as expected needs to be done

* Releasable trick version, tricks match text fixes also

* Remove 3D glitch logic location access

Easier to clean it up now than get confused

* Variable typo fix & initial trick enum reorganisation

* Removal of oot3d glitches

* bongo logic fix

* UI includes difficulty tags + cleanup and removal of glitched logic interface

* Bug fixes

* added enabled tricks to spoiler log

* comment clean up

* completed once over through logic

* merge fix

* update sohimgui to LUS

* Remove redundant 3d rando trick options

* Comment clean up

* Central GS Irons Logic Fix

* Farores wind central logic fix

---------

Co-authored-by: Christopher Leggett <chris@leggett.dev>
This commit is contained in:
inspectredc 2023-06-02 21:53:07 +01:00 committed by GitHub
parent c9bcd64beb
commit d922b91e15
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
40 changed files with 2308 additions and 1540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
soh/CMakeLists.txt
View File

@ -278,7 +278,7 @@ if (CMAKE_SYSTEM_NAME STREQUAL "Windows")
endif()
elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
set_target_properties(${PROJECT_NAME} PROPERTIES
XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES
XCODE_ATTRIBUTE_CLANG_ENABLE_OBJC_ARC YES
OUTPUT_NAME "soh-macos"
)
elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")

2
soh/soh/Enhancements/presets.h
View File

@ -282,6 +282,8 @@ const std::vector<const char*> randomizerCvars = {
"gRandomizeDungeonCount",
"gRandomizeEnableBombchuDrops",
"gRandomizeEnableGlitchCutscenes",
"gRandomizeEnabledGlitches",
"gRandomizeEnabledTricks",
"gRandomizeExcludedLocations",
"gRandomizeForest",
"gRandomizeFullWallets",

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

@ -266,24 +266,12 @@ void AreaTable_Init() {
//Exits
Entrance(CHILD_SPAWN, {[]{return IsChild;}}),
Entrance(ADULT_SPAWN, {[]{return IsAdult;}}),
Entrance(MINUET_OF_FOREST_WARP, {[]{return CanPlay(MinuetOfForest);},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && MinuetOfForest;}}),
Entrance(BOLERO_OF_FIRE_WARP, {[]{return CanPlay(BoleroOfFire) && CanLeaveForest;},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && BoleroOfFire && CanLeaveForest;}}),
Entrance(SERENADE_OF_WATER_WARP, {[]{return CanPlay(SerenadeOfWater) && CanLeaveForest;},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && SerenadeOfWater && CanLeaveForest;}}),
Entrance(NOCTURNE_OF_SHADOW_WARP, {[]{return CanPlay(NocturneOfShadow) && CanLeaveForest;},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && NocturneOfShadow && CanLeaveForest;}}),
Entrance(REQUIEM_OF_SPIRIT_WARP, {[]{return CanPlay(RequiemOfSpirit) && CanLeaveForest;},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && RequiemOfSpirit && CanLeaveForest;}}),
Entrance(PRELUDE_OF_LIGHT_WARP, {[]{return CanPlay(PreludeOfLight) && CanLeaveForest;},
/*Glitched*/[]{return (((IsChild && (ChildCanAccess(KOKIRI_FOREST) || ChildCanAccess(HYRULE_FIELD) || ChildCanAccess(LAKE_HYLIA))) || (IsAdult && (AdultCanAccess(KOKIRI_FOREST) || AdultCanAccess(HYRULE_FIELD) || AdultCanAccess(LAKE_HYLIA)))) && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (IsAdult || KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) && PreludeOfLight && CanLeaveForest;}}),
Entrance(MINUET_OF_FOREST_WARP, {[]{return CanPlay(MinuetOfForest);}}),
Entrance(BOLERO_OF_FIRE_WARP, {[]{return CanPlay(BoleroOfFire) && CanLeaveForest;}}),
Entrance(SERENADE_OF_WATER_WARP, {[]{return CanPlay(SerenadeOfWater) && CanLeaveForest;}}),
Entrance(NOCTURNE_OF_SHADOW_WARP, {[]{return CanPlay(NocturneOfShadow) && CanLeaveForest;}}),
Entrance(REQUIEM_OF_SPIRIT_WARP, {[]{return CanPlay(RequiemOfSpirit) && CanLeaveForest;}}),
Entrance(PRELUDE_OF_LIGHT_WARP, {[]{return CanPlay(PreludeOfLight) && CanLeaveForest;}}),
});
areaTable[CHILD_SPAWN] = Area("Child Spawn", "", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {

14
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_bottom_of_the_well.cpp
View File

@ -12,10 +12,8 @@ void AreaTable_Init_BottomOfTheWell() {
---------------------------*/
areaTable[BOTTOM_OF_THE_WELL_ENTRYWAY] = Area("Bottom of the Well Entryway", "Bottom of the Well", BOTTOM_OF_THE_WELL, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(BOTTOM_OF_THE_WELL_MAIN_AREA, {[]{return Dungeon::BottomOfTheWell.IsVanilla() && IsChild && (CanChildAttack || Nuts);},
/*Glitched*/[]{return Dungeon::BottomOfTheWell.IsVanilla() && IsChild && CanUse(MEGATON_HAMMER);}}),
Entrance(BOTTOM_OF_THE_WELL_MQ_PERIMETER, {[]{return Dungeon::BottomOfTheWell.IsMQ() && IsChild;},
/*Glitched*/[]{return Dungeon::BottomOfTheWell.IsMQ() && CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE) && Longshot;}}),
Entrance(BOTTOM_OF_THE_WELL_MAIN_AREA, {[]{return Dungeon::BottomOfTheWell.IsVanilla() && IsChild && (CanChildAttack || Nuts);}}),
Entrance(BOTTOM_OF_THE_WELL_MQ_PERIMETER, {[]{return Dungeon::BottomOfTheWell.IsMQ() && IsChild;}}),
Entrance(KAKARIKO_VILLAGE, {[]{return true;}}),
});
@ -40,7 +38,7 @@ void AreaTable_Init_BottomOfTheWell() {
LocationAccess(BOTTOM_OF_THE_WELL_INVISIBLE_CHEST, {[]{return CanPlay(ZeldasLullaby) && (LogicLensBotw || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(BOTTOM_OF_THE_WELL_UNDERWATER_FRONT_CHEST, {[]{return CanPlay(ZeldasLullaby);}}),
LocationAccess(BOTTOM_OF_THE_WELL_UNDERWATER_LEFT_CHEST, {[]{return CanPlay(ZeldasLullaby);}}),
LocationAccess(BOTTOM_OF_THE_WELL_MAP_CHEST, {[]{return HasExplosives || (((SmallKeys(BOTTOM_OF_THE_WELL, 3) && (LogicLensBotw || CanUse(LENS_OF_TRUTH))) || CanUse(DINS_FIRE)) && GoronBracelet);}}),
LocationAccess(BOTTOM_OF_THE_WELL_MAP_CHEST, {[]{return HasExplosives || (((SmallKeys(BOTTOM_OF_THE_WELL, 3) && (LogicLensBotw || CanUse(LENS_OF_TRUTH))) || CanUse(DINS_FIRE) || (Sticks && LogicBotwBasement)) && GoronBracelet);}}),
LocationAccess(BOTTOM_OF_THE_WELL_FIRE_KEESE_CHEST, {[]{return SmallKeys(BOTTOM_OF_THE_WELL, 3) && (LogicLensBotw || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(BOTTOM_OF_THE_WELL_LIKE_LIKE_CHEST, {[]{return SmallKeys(BOTTOM_OF_THE_WELL, 3) && (LogicLensBotw || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(BOTTOM_OF_THE_WELL_GS_WEST_INNER_ROOM, {[]{return Boomerang && (LogicLensBotw || CanUse(LENS_OF_TRUTH)) && SmallKeys(BOTTOM_OF_THE_WELL, 3);}}),
@ -62,14 +60,14 @@ void AreaTable_Init_BottomOfTheWell() {
}, {
//Locations
LocationAccess(BOTTOM_OF_THE_WELL_MQ_COMPASS_CHEST, {[]{return KokiriSword || (Sticks && LogicChildDeadhand);}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_DEAD_HAND_FREESTANDING_KEY, {[]{return HasExplosives;}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_DEAD_HAND_FREESTANDING_KEY, {[]{return HasExplosives || (LogicBotwMQDeadHandKey && Boomerang);}}),
//Trick: HasExplosives || (LogicBotWMQDeadHandKey && Boomerang)
LocationAccess(BOTTOM_OF_THE_WELL_MQ_GS_BASEMENT, {[]{return CanChildAttack;}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_GS_COFFIN_ROOM, {[]{return CanChildAttack && SmallKeys(BOTTOM_OF_THE_WELL, 2);}}),
}, {
//Exits
Entrance(BOTTOM_OF_THE_WELL_ENTRYWAY, {[]{return true;}}),
Entrance(BOTTOM_OF_THE_WELL_MQ_MIDDLE, {[]{return CanPlay(ZeldasLullaby);}}),
Entrance(BOTTOM_OF_THE_WELL_MQ_MIDDLE, {[]{return CanPlay(ZeldasLullaby) || (LogicBotwMQPits && HasExplosives);}}),
//Trick: CanPlay(ZeldasLullaby) || (LogicBotWMQPits && HasExplosives)
});
@ -78,7 +76,7 @@ void AreaTable_Init_BottomOfTheWell() {
LocationAccess(BOTTOM_OF_THE_WELL_MQ_MAP_CHEST, {[]{return true;}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_LENS_OF_TRUTH_CHEST, {[]{return HasExplosives && SmallKeys(BOTTOM_OF_THE_WELL, 2);}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_EAST_INNER_ROOM_FREESTANDING_KEY, {[]{return true;}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_GS_WEST_INNER_ROOM, {[]{return CanChildAttack && HasExplosives;}}),
LocationAccess(BOTTOM_OF_THE_WELL_MQ_GS_WEST_INNER_ROOM, {[]{return CanChildAttack && (LogicBotwMQPits || HasExplosives);}}),
//Trick: CanChildAttack && (LogicBotWMQPits || HasExplosives)
}, {
//Exits

28
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_castle_town.cpp
View File

@ -56,9 +56,7 @@ void AreaTable_Init_CastleTown() {
}, {
//Exits
Entrance(TOT_ENTRANCE, {[]{return true;}}),
Entrance(TOT_BEYOND_DOOR_OF_TIME, {[]{return OpenDoorOfTime.Is(OPENDOOROFTIME_OPEN) || (CanPlay(SongOfTime) && (OpenDoorOfTime.Is(OPENDOOROFTIME_SONGONLY) || (HasAllStones && OcarinaOfTime)));},
/*Glitched*/[]{return SongOfTime && OpenDoorOfTime.Is(OPENDOOROFTIME_SONGONLY) && (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::ADVANCED) ||
((Bugs || Fish) && Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE)));}}),
Entrance(TOT_BEYOND_DOOR_OF_TIME, {[]{return OpenDoorOfTime.Is(OPENDOOROFTIME_OPEN) || (CanPlay(SongOfTime) && (OpenDoorOfTime.Is(OPENDOOROFTIME_SONGONLY) || (HasAllStones && OcarinaOfTime)));}}),
});
areaTable[TOT_BEYOND_DOOR_OF_TIME] = Area("Beyond Door of Time", "Beyond Door of Time", TEMPLE_OF_TIME, NO_DAY_NIGHT_CYCLE, {
@ -94,10 +92,8 @@ void AreaTable_Init_CastleTown() {
//Exits
Entrance(CASTLE_GROUNDS, {[]{return true;}}),
Entrance(HC_GARDEN, {[]{return WeirdEgg || !ShuffleWeirdEgg;}}),
Entrance(HC_GREAT_FAIRY_FOUNTAIN, {[]{return CanBlastOrSmash;},
/*Glitched*/[]{return Sticks && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(HC_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(HC_GREAT_FAIRY_FOUNTAIN, {[]{return CanBlastOrSmash;}}),
Entrance(HC_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
});
areaTable[HC_GARDEN] = Area("HC Garden", "Castle Grounds", HYRULE_CASTLE, NO_DAY_NIGHT_CYCLE, {
@ -113,8 +109,7 @@ void AreaTable_Init_CastleTown() {
areaTable[HC_GREAT_FAIRY_FOUNTAIN] = Area("HC Great Fairy Fountain", "HC Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(HC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(HC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(CASTLE_GROUNDS, {[]{return true;}}),
@ -127,8 +122,7 @@ void AreaTable_Init_CastleTown() {
EventAccess(&WanderingBugs, {[]{return WanderingBugs || CanBlastOrSmash;}}),
}, {
//Locations
LocationAccess(HC_GS_STORMS_GROTTO, {[]{return CanBlastOrSmash && HookshotOrBoomerang;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(HC_GS_STORMS_GROTTO, {[]{return (CanBlastOrSmash && HookshotOrBoomerang) || (Boomerang && LogicCastleStormsGS);}}),
LocationAccess(HC_STORMS_GROTTO_GOSSIP_STONE, {[]{return CanBlastOrSmash;}}),
}, {
//Exits
@ -145,14 +139,12 @@ void AreaTable_Init_CastleTown() {
//Exits
Entrance(CASTLE_GROUNDS, {[]{return AtNight;}}),
Entrance(OGC_GREAT_FAIRY_FOUNTAIN, {[]{return CanUse(GOLDEN_GAUNTLETS) && AtNight;}}),
Entrance(GANONS_CASTLE_LEDGE, {[]{return BuiltRainbowBridge;},
/*Glitched*/[]{return (HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::ADVANCED) || (HoverBoots && CanShield && Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::EXPERT)) || (HoverBoots && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::ADVANCED));}}),
Entrance(GANONS_CASTLE_LEDGE, {[]{return BuiltRainbowBridge;}}),
});
areaTable[OGC_GREAT_FAIRY_FOUNTAIN] = Area("OGC Great Fairy Fountain", "OGC Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(OGC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(OGC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(CASTLE_GROUNDS, {[]{return true;}}),
@ -167,8 +159,7 @@ void AreaTable_Init_CastleTown() {
areaTable[GANONS_CASTLE_LEDGE] = Area("Ganon's Castle Ledge", "OGC Ganon's Castle Ledge", NONE, NO_DAY_NIGHT_CYCLE,
{}, {}, {
// Exits
Entrance(GANONS_CASTLE_GROUNDS, {[]{return BuiltRainbowBridge;},
/*Glitched*/[]{return (HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::ADVANCED) || (HoverBoots && CanShield && Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::EXPERT)) || (HoverBoots && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::ADVANCED));}}),
Entrance(GANONS_CASTLE_GROUNDS, {[]{return BuiltRainbowBridge;}}),
Entrance(GANONS_CASTLE_ENTRYWAY, {[]{return IsAdult;}}),
});
@ -240,8 +231,7 @@ void AreaTable_Init_CastleTown() {
areaTable[MARKET_TREASURE_CHEST_GAME] = Area("Market Treasure Chest Game", "Market Treasure Chest Game", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(MARKET_TREASURE_CHEST_GAME_REWARD, {[]{return (CanUse(LENS_OF_TRUTH) && !ShuffleChestMinigame) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_SINGLE_KEYS) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 6)) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_PACK) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1));},
/*Glitched*/[]{return !ShuffleChestMinigame && (CanUse(FARORES_WIND) && (HasBottle || WeirdEgg) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE));}}),
LocationAccess(MARKET_TREASURE_CHEST_GAME_REWARD, {[]{return (CanUse(LENS_OF_TRUTH) && !ShuffleChestMinigame) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_SINGLE_KEYS) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 6)) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_PACK) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1));}}),
LocationAccess(MARKET_TREASURE_CHEST_GAME_ITEM_1, {[]{return (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_SINGLE_KEYS) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1)) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_PACK) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1)) || (CanUse(LENS_OF_TRUTH) && !ShuffleChestMinigame);}}),
LocationAccess(MARKET_TREASURE_CHEST_GAME_ITEM_2, {[]{return (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_SINGLE_KEYS) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 2)) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_PACK) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1)) || (CanUse(LENS_OF_TRUTH) && !ShuffleChestMinigame);}}),
LocationAccess(MARKET_TREASURE_CHEST_GAME_ITEM_3, {[]{return (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_SINGLE_KEYS) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 3)) || (ShuffleChestMinigame.Is(SHUFFLECHESTMINIGAME_PACK) && SmallKeys(MARKET_TREASURE_CHEST_GAME, 1)) || (CanUse(LENS_OF_TRUTH) && !ShuffleChestMinigame);}}),

95
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_death_mountain.cpp
View File

@ -11,23 +11,18 @@ void AreaTable_Init_DeathMountain() {
EventAccess(&BeanPlantFairy, {[]{return BeanPlantFairy || (CanPlantBean(DEATH_MOUNTAIN_TRAIL) && CanPlay(SongOfStorms) && (HasExplosives || GoronBracelet));}}),
}, {
//Locations
LocationAccess(DMT_CHEST, {[]{return CanBlastOrSmash || (LogicDMTBombable && IsChild && GoronBracelet);},
/*Glitched*/[]{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
LocationAccess(DMT_CHEST, {[]{return CanBlastOrSmash || (LogicDMTBombable && IsChild && GoronBracelet);}}),
LocationAccess(DMT_FREESTANDING_POH, {[]{return CanTakeDamage || CanUse(HOVER_BOOTS) || (IsAdult && CanPlantBean(DEATH_MOUNTAIN_TRAIL) && (HasExplosives || GoronBracelet));}}),
LocationAccess(DMT_GS_BEAN_PATCH, {[]{return CanPlantBugs && (HasExplosives || GoronBracelet || (LogicDMTSoilGS && (CanTakeDamage || CanUse(HOVER_BOOTS)) && CanUse(BOOMERANG)));}}),
LocationAccess(DMT_GS_NEAR_KAK, {[]{return CanBlastOrSmash;},
/*Glitched*/[]{return (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}}),
LocationAccess(DMT_GS_ABOVE_DODONGOS_CAVERN, {[]{return IsAdult && AtNight && CanUse(MEGATON_HAMMER) && CanGetNightTimeGS;},
/*Glitched*/[]{return IsAdult && AtNight && CanGetNightTimeGS && CanUse(STICKS) && ((CanTakeDamageTwice && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}}),
LocationAccess(DMT_GS_NEAR_KAK, {[]{return CanBlastOrSmash;}}),
LocationAccess(DMT_GS_ABOVE_DODONGOS_CAVERN, {[]{return IsAdult && AtNight && (CanUse(MEGATON_HAMMER) || (LogicDMTGSLowerHookshot && CanUse(HOOKSHOT)) || (LogicDMTGSLowerBean && CanPlantBean(DEATH_MOUNTAIN_TRAIL)) || (LogicDMTGSLowerHovers && CanUse(HOVER_BOOTS)) || LogicDMTGSLowerJS) && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(KAK_BEHIND_GATE, {[]{return true;}}),
Entrance(GORON_CITY, {[]{return true;}}),
Entrance(DEATH_MOUNTAIN_SUMMIT, {[]{return Here(DEATH_MOUNTAIN_TRAIL, []{return CanBlastOrSmash;}) || (IsAdult && ((CanPlantBean(DEATH_MOUNTAIN_TRAIL) && GoronBracelet) || (HoverBoots && LogicDMTSummitHover)));},
/*Glitched*/[]{return IsAdult && Here(DEATH_MOUNTAIN_TRAIL, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(DEATH_MOUNTAIN_SUMMIT, {[]{return Here(DEATH_MOUNTAIN_TRAIL, []{return CanBlastOrSmash;}) || (IsAdult && ((CanPlantBean(DEATH_MOUNTAIN_TRAIL) && GoronBracelet) || (HoverBoots && LogicDMTClimbHovers)));}}),
Entrance(DODONGOS_CAVERN_ENTRYWAY, {[]{return HasExplosives || GoronBracelet || IsAdult;}}),
Entrance(DMT_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(DMT_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
});
areaTable[DEATH_MOUNTAIN_SUMMIT] = Area("Death Mountain Summit", "Death Mountain", DEATH_MOUNTAIN_TRAIL, DAY_NIGHT_CYCLE, {
@ -40,17 +35,15 @@ void AreaTable_Init_DeathMountain() {
LocationAccess(DMT_TRADE_BROKEN_SWORD, {[]{return IsAdult && BrokenSword;}}),
LocationAccess(DMT_TRADE_EYEDROPS, {[]{return IsAdult && Eyedrops;}}),
LocationAccess(DMT_TRADE_CLAIM_CHECK, {[]{return IsAdult && ClaimCheck;}}),
LocationAccess(DMT_GS_FALLING_ROCKS_PATH, {[]{return IsAdult && AtNight && CanUse(MEGATON_HAMMER) && CanGetNightTimeGS;}}),
LocationAccess(DMT_GS_FALLING_ROCKS_PATH, {[]{return IsAdult && AtNight && (CanUse(MEGATON_HAMMER) || LogicDMTGSUpper) && CanGetNightTimeGS;}}),
LocationAccess(DMT_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
Entrance(DEATH_MOUNTAIN_TRAIL, {[]{return true;}}),
Entrance(DMC_UPPER_LOCAL, {[]{return true;}}),
Entrance(DMT_OWL_FLIGHT, {[]{return IsChild;}}),
Entrance(DMT_COW_GROTTO, {[]{return Here(DEATH_MOUNTAIN_SUMMIT, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(DEATH_MOUNTAIN_SUMMIT, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(DMT_GREAT_FAIRY_FOUNTAIN, {[]{return Here(DEATH_MOUNTAIN_SUMMIT, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return ((KokiriSword || Sticks || IsAdult) && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::ADVANCED)) || (IsChild && CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::EXPERT));}}),
Entrance(DMT_COW_GROTTO, {[]{return Here(DEATH_MOUNTAIN_SUMMIT, []{return CanBlastOrSmash;});}}),
Entrance(DMT_GREAT_FAIRY_FOUNTAIN, {[]{return Here(DEATH_MOUNTAIN_SUMMIT, []{return CanBlastOrSmash;});}}),
});
areaTable[DMT_OWL_FLIGHT] = Area("DMT Owl Flight", "Death Mountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -60,9 +53,7 @@ void AreaTable_Init_DeathMountain() {
areaTable[DMT_COW_GROTTO] = Area("DMT Cow Grotto", "DMT Cow Grotto", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DMT_COW_GROTTO_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && EponasSong;}}),
LocationAccess(DMT_COW_GROTTO_COW, {[]{return CanPlay(EponasSong);}}),
}, {
//Exits
Entrance(DEATH_MOUNTAIN_SUMMIT, {[]{return true;}}),
@ -80,9 +71,7 @@ void AreaTable_Init_DeathMountain() {
areaTable[DMT_GREAT_FAIRY_FOUNTAIN] = Area("DMT Great Fairy Fountain", "DMT Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DMT_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(DMT_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(DEATH_MOUNTAIN_SUMMIT, {[]{return true;}}),
@ -93,18 +82,13 @@ void AreaTable_Init_DeathMountain() {
EventAccess(&GossipStoneFairy, {[]{return GossipStoneFairy || CanSummonGossipFairyWithoutSuns;}}),
EventAccess(&StickPot, {[]{return StickPot || IsChild;}}),
EventAccess(&BugRock, {[]{return BugRock || (CanBlastOrSmash || CanUse(SILVER_GAUNTLETS));}}),
EventAccess(&GoronCityChildFire, {[]{return GoronCityChildFire || (IsChild && CanUse(DINS_FIRE));},
/*Glitched*/[]{return IsChild && CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE);}}),
EventAccess(&GCWoodsWarpOpen, {[]{return GCWoodsWarpOpen || (CanBlastOrSmash || CanUse(DINS_FIRE) || CanUse(BOW) || GoronBracelet || GoronCityChildFire);},
/*Glitched*/[]{return (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}}),
EventAccess(&GCDaruniasDoorOpenChild, {[]{return GCDaruniasDoorOpenChild || (IsChild && CanPlay(ZeldasLullaby));},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && ZeldasLullaby;}}),
EventAccess(&StopGCRollingGoronAsAdult, {[]{return StopGCRollingGoronAsAdult || (IsAdult && (GoronBracelet || HasExplosives || Bow || (LogicLinkGoronDins && CanUse(DINS_FIRE))));}}),
EventAccess(&GoronCityChildFire, {[]{return GoronCityChildFire || (IsChild && CanUse(DINS_FIRE));}}),
EventAccess(&GCWoodsWarpOpen, {[]{return GCWoodsWarpOpen || (CanBlastOrSmash || CanUse(DINS_FIRE) || CanUse(BOW) || GoronBracelet || GoronCityChildFire);}}),
EventAccess(&GCDaruniasDoorOpenChild, {[]{return GCDaruniasDoorOpenChild || (IsChild && CanPlay(ZeldasLullaby));}}),
EventAccess(&StopGCRollingGoronAsAdult, {[]{return StopGCRollingGoronAsAdult || (IsAdult && (GoronBracelet || HasExplosives || Bow || (LogicGoronCityLinkGoronDins && CanUse(DINS_FIRE))));}}),
}, {
//Locations
LocationAccess(GC_MAZE_LEFT_CHEST, {[]{return CanUse(MEGATON_HAMMER) || CanUse(SILVER_GAUNTLETS) || (LogicGoronCityLeftMost && HasExplosives && CanUse(HOVER_BOOTS));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
LocationAccess(GC_MAZE_LEFT_CHEST, {[]{return CanUse(MEGATON_HAMMER) || CanUse(SILVER_GAUNTLETS) || (LogicGoronCityLeftMost && HasExplosives && CanUse(HOVER_BOOTS));}}),
LocationAccess(GC_MAZE_CENTER_CHEST, {[]{return CanBlastOrSmash || CanUse(SILVER_GAUNTLETS);}}),
LocationAccess(GC_MAZE_RIGHT_CHEST, {[]{return CanBlastOrSmash || CanUse(SILVER_GAUNTLETS);}}),
LocationAccess(GC_POT_FREESTANDING_POH, {[]{return IsChild && GoronCityChildFire && (Bombs || (GoronBracelet && LogicGoronCityPotWithStrength) || (HasBombchus && LogicGoronCityPot));}}),
@ -119,11 +103,9 @@ void AreaTable_Init_DeathMountain() {
//Exits
Entrance(DEATH_MOUNTAIN_TRAIL, {[]{return true;}}),
Entrance(GC_WOODS_WARP, {[]{return GCWoodsWarpOpen;}}),
Entrance(GC_SHOP, {[]{return (IsAdult && StopGCRollingGoronAsAdult) || (IsChild && (CanBlastOrSmash || GoronBracelet || GoronCityChildFire || CanUse(BOW)));},
/*Glitched*/[]{return IsChild && Sticks && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(GC_SHOP, {[]{return (IsAdult && StopGCRollingGoronAsAdult) || (IsChild && (CanBlastOrSmash || GoronBracelet || GoronCityChildFire || CanUse(BOW)));}}),
Entrance(GC_DARUNIAS_CHAMBER, {[]{return (IsAdult && StopGCRollingGoronAsAdult) || GCDaruniasDoorOpenChild;}}),
Entrance(GC_GROTTO_PLATFORM, {[]{return IsAdult && ((CanPlay(SongOfTime) && ((EffectiveHealth > 2) || CanUse(GORON_TUNIC) || CanUse(LONGSHOT) || CanUse(NAYRUS_LOVE))) || (EffectiveHealth > 1 && CanUse(GORON_TUNIC) && CanUse(HOOKSHOT)) || (CanUse(NAYRUS_LOVE) && CanUse(HOOKSHOT)));},
/*Glitched*/[]{return (HasBombchus && ((IsChild && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE))) || (IsChild && CanUse(LONGSHOT));}}),
Entrance(GC_GROTTO_PLATFORM, {[]{return IsAdult && ((CanPlay(SongOfTime) && ((EffectiveHealth > 2) || CanUse(GORON_TUNIC) || CanUse(LONGSHOT) || CanUse(NAYRUS_LOVE))) || (EffectiveHealth > 1 && CanUse(GORON_TUNIC) && CanUse(HOOKSHOT)) || (CanUse(NAYRUS_LOVE) && CanUse(HOOKSHOT)) || (EffectiveHealth > 2 && CanUse(HOOKSHOT) && LogicGoronCityGrotto));}}),
});
areaTable[GC_WOODS_WARP] = Area("GC Woods Warp", "Goron City", NONE, NO_DAY_NIGHT_CYCLE, {
@ -140,14 +122,11 @@ void AreaTable_Init_DeathMountain() {
EventAccess(&GoronCityChildFire, {[]{return GoronCityChildFire || (IsChild && CanUse(STICKS));}}),
}, {
//Locations
LocationAccess(GC_DARUNIAS_JOY, {[]{return IsChild && CanPlay(SariasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && ((Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2))) || GCDaruniasDoorOpenChild) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && SariasSong;}}),
LocationAccess(GC_DARUNIAS_JOY, {[]{return IsChild && CanPlay(SariasSong);}}),
}, {
//Exits
Entrance(GORON_CITY, {[]{return true;}}),
Entrance(DMC_LOWER_LOCAL, {[]{return IsAdult;},
/*Glitched*/[]{return IsChild && GCDaruniasDoorOpenChild && (KokiriSword || Sticks) && GlitchOccamsStatue;}}),
Entrance(DMC_LOWER_LOCAL, {[]{return IsAdult;}}),
});
areaTable[GC_GROTTO_PLATFORM] = Area("GC Grotto Platform", "Goron City", GORON_CITY, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -185,8 +164,7 @@ void AreaTable_Init_DeathMountain() {
//Exits
Entrance(DMC_UPPER_LOCAL, {[]{return FireTimer >= 48;}}),
Entrance(DEATH_MOUNTAIN_SUMMIT, {[]{return true;}}),
Entrance(DMC_UPPER_GROTTO, {[]{return Here(DMC_UPPER_NEARBY, []{return CanBlastOrSmash && (FireTimer >= 8 || Hearts >= 3);});},
/*Glitched*/[]{return Here(DMC_UPPER_NEARBY, []{return CanUse(STICKS) && FireTimer >= 48 && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}})
Entrance(DMC_UPPER_GROTTO, {[]{return Here(DMC_UPPER_NEARBY, []{return CanBlastOrSmash && (FireTimer >= 8 || Hearts >= 3);});}})
});
areaTable[DMC_UPPER_LOCAL] = Area("DMC Upper Local", "Death Mountain Crater", DEATH_MOUNTAIN_CRATER, NO_DAY_NIGHT_CYCLE, {
@ -201,10 +179,8 @@ void AreaTable_Init_DeathMountain() {
//Exits
Entrance(DMC_UPPER_NEARBY, {[]{return true;}}),
Entrance(DMC_LADDER_AREA_NEARBY, {[]{return FireTimer >= 16 || Hearts >= 3;}}),
Entrance(DMC_CENTRAL_NEARBY, {[]{return IsAdult && CanUse(GORON_TUNIC) && CanUse(DISTANT_SCARECROW) && ((EffectiveHealth > 2) || (Fairy && ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF)) || CanUse(NAYRUS_LOVE));},
/*Glitched*/[]{return FireTimer >= 24 && CanTakeDamage && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE);}}),
Entrance(DMC_LOWER_NEARBY, {[]{return false;},
/*Glitched*/[]{return FireTimer >= 24 && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE);}}),
Entrance(DMC_CENTRAL_NEARBY, {[]{return IsAdult && CanUse(GORON_TUNIC) && CanUse(DISTANT_SCARECROW) && ((EffectiveHealth > 2) || (Fairy && ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF)) || CanUse(NAYRUS_LOVE));}}),
Entrance(DMC_LOWER_NEARBY, {[]{return false;}}),
});
areaTable[DMC_LADDER_AREA_NEARBY] = Area("DMC Ladder Area Nearby", "Death Mountain Crater", DEATH_MOUNTAIN_CRATER, NO_DAY_NIGHT_CYCLE, {}, {
@ -213,33 +189,28 @@ void AreaTable_Init_DeathMountain() {
}, {
//Exits
Entrance(DMC_UPPER_NEARBY, {[]{return Hearts >= 3;}}),
Entrance(DMC_LOWER_NEARBY, {[]{return Hearts >= 3 && (CanUse(HOVER_BOOTS) || (LogicCraterUpperToLower && IsAdult && CanUse(MEGATON_HAMMER)));}}),
Entrance(DMC_LOWER_NEARBY, {[]{return Hearts >= 3 && (CanUse(HOVER_BOOTS) || (LogicCraterBoulderJS && IsAdult && CanUse(MEGATON_HAMMER)) || (LogicCraterBoulderSkip && IsAdult));}}),
});
areaTable[DMC_LOWER_NEARBY] = Area("DMC Lower Nearby", "Death Mountain Crater", DEATH_MOUNTAIN_CRATER, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DMC_LOWER_LOCAL, {[]{return FireTimer >= 48;}}),
Entrance(GC_DARUNIAS_CHAMBER, {[]{return true;}}),
Entrance(DMC_GREAT_FAIRY_FOUNTAIN, {[]{return CanUse(MEGATON_HAMMER);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::INTERMEDIATE) || (FireTimer >= 48 && CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE) && (CanTakeDamageTwice || CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED))) ||
(Bombs && CanShield && FireTimer >= 48 && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::EXPERT)) || Here(DMC_UPPER_LOCAL, []{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::ADVANCED);});}}),
Entrance(DMC_HAMMER_GROTTO, {[]{return IsAdult && CanUse(MEGATON_HAMMER);},
/*Glitched*/[]{return IsAdult && FireTimer >= 48 && CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE) && (CanTakeDamageTwice || CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}}),
Entrance(DMC_GREAT_FAIRY_FOUNTAIN, {[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DMC_HAMMER_GROTTO, {[]{return IsAdult && CanUse(MEGATON_HAMMER);}}),
});
areaTable[DMC_LOWER_LOCAL] = Area("DMC Lower Local", "Death Mountain Crater", DEATH_MOUNTAIN_CRATER, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DMC_LOWER_NEARBY, {[]{return true;}}),
Entrance(DMC_LADDER_AREA_NEARBY, {[]{return FireTimer >= 8 || Hearts >= 3;}}),
Entrance(DMC_CENTRAL_NEARBY, {[]{return (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT)) && (FireTimer >= 8 || Hearts >= 3);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) && (FireTimer >= 8 || Hearts >= 3);}}),
Entrance(DMC_CENTRAL_LOCAL, {[]{return (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT)) && FireTimer >= 24;}}),
Entrance(DMC_CENTRAL_NEARBY, {[]{return (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT)) && (FireTimer >= 8 || Hearts >= 3);}}),
Entrance(DMC_CENTRAL_LOCAL, {[]{return (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT) || (IsAdult && CanShield && LogicCraterBoleroJump)) && FireTimer >= 24;}}),
});
areaTable[DMC_CENTRAL_NEARBY] = Area("DMC Central Nearby", "Death Mountain Crater", DEATH_MOUNTAIN_CRATER, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DMC_VOLCANO_FREESTANDING_POH, {[]{return IsAdult && Hearts >= 3 && (CanPlantBean(DMC_CENTRAL_LOCAL) || (LogicCraterBeanPoHWithHovers && HoverBoots));},
/*Glitched*/[]{return Here(DMC_LOWER_LOCAL, []{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) && FireTimer >= 24;});}}),
LocationAccess(DMC_VOLCANO_FREESTANDING_POH, {[]{return IsAdult && Hearts >= 3 && (CanPlantBean(DMC_CENTRAL_LOCAL) || (LogicCraterBeanPoHWithHovers && HoverBoots));}}),
LocationAccess(SHEIK_IN_CRATER, {[]{return IsAdult && (FireTimer >= 8 || Hearts >= 3);}}),
}, {
//Exits
@ -255,18 +226,14 @@ void AreaTable_Init_DeathMountain() {
}, {
//Exits
Entrance(DMC_CENTRAL_NEARBY, {[]{return true;}}),
Entrance(DMC_LOWER_NEARBY, {[]{return (IsAdult && CanPlantBean(DMC_CENTRAL_LOCAL)) || CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT);},
/*Glitched*/[]{return IsChild && Hearts >= 3 && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
Entrance(DMC_LOWER_NEARBY, {[]{return (IsAdult && CanPlantBean(DMC_CENTRAL_LOCAL)) || CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT);}}),
Entrance(DMC_UPPER_NEARBY, {[]{return IsAdult && CanPlantBean(DMC_CENTRAL_LOCAL);}}),
Entrance(FIRE_TEMPLE_ENTRYWAY, {[]{return (IsChild && Hearts >= 3 && ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF)) || (IsAdult && FireTimer >= 24);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::INTERMEDIATE) && FireTimer >= 48;}}),
Entrance(FIRE_TEMPLE_ENTRYWAY, {[]{return (IsChild && Hearts >= 3 && ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF)) || (IsAdult && FireTimer >= 24);}}),
});
areaTable[DMC_GREAT_FAIRY_FOUNTAIN] = Area("DMC Great Fairy Fountain", "DMC Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DMC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanTakeDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(DMC_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(DMC_LOWER_LOCAL, {[]{return true;}}),

60
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_deku_tree.cpp
View File

@ -24,8 +24,7 @@ void AreaTable_Init_DekuTree() {
areaTable[DEKU_TREE_LOBBY] = Area("Deku Tree Lobby", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {
//Locations
LocationAccess(DEKU_TREE_MAP_CHEST, {[]{return true;}}),
@ -34,12 +33,9 @@ void AreaTable_Init_DekuTree() {
Entrance(DEKU_TREE_ENTRYWAY, {[]{return true;}}),
Entrance(DEKU_TREE_2F_MIDDLE_ROOM, {[]{return true;}}),
Entrance(DEKU_TREE_COMPASS_ROOM, {[]{return true;}}),
Entrance(DEKU_TREE_BASEMENT_LOWER, {[]{return Here(DEKU_TREE_LOBBY, []{return IsAdult || CanChildAttack || Nuts;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DEKU_TREE_OUTSIDE_BOSS_ROOM, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE);}}),
Entrance(DEKU_TREE_BOSS_ENTRYWAY, {[]{return false;},
/*Glitched*/[]{return IsChild && CanUse(KOKIRI_SWORD) && Nuts && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::EXPERT);}}),
Entrance(DEKU_TREE_BASEMENT_LOWER, {[]{return Here(DEKU_TREE_LOBBY, []{return IsAdult || CanChildAttack || Nuts;});}}),
Entrance(DEKU_TREE_OUTSIDE_BOSS_ROOM, {[]{return false;}}),
Entrance(DEKU_TREE_BOSS_ENTRYWAY, {[]{return false;}}),
});
areaTable[DEKU_TREE_2F_MIDDLE_ROOM] = Area("Deku Tree 2F Middle Room", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -54,26 +50,22 @@ void AreaTable_Init_DekuTree() {
LocationAccess(DEKU_TREE_SLINGSHOT_ROOM_SIDE_CHEST, {[]{return true;}}),
}, {
//Exits
Entrance(DEKU_TREE_2F_MIDDLE_ROOM, {[]{return CanUse(SLINGSHOT) || CanUse(HOVER_BOOTS);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(DEKU_TREE_2F_MIDDLE_ROOM, {[]{return CanUse(SLINGSHOT) || CanUse(HOVER_BOOTS);}}),
});
areaTable[DEKU_TREE_COMPASS_ROOM] = Area("Deku Tree Compass Room", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {
//Locations
LocationAccess(DEKU_TREE_COMPASS_CHEST, {[]{return true;}}),
LocationAccess(DEKU_TREE_COMPASS_ROOM_SIDE_CHEST, {[]{return true;}}),
LocationAccess(DEKU_TREE_GS_COMPASS_ROOM, {[]{return IsAdult || CanChildAttack;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(DEKU_TREE_GS_COMPASS_ROOM, {[]{return IsAdult || CanChildAttack;}}),
}, {
//Exits
Entrance(DEKU_TREE_LOBBY, {[]{return HasFireSourceWithTorch || CanUse(BOW);}}),
Entrance(DEKU_TREE_BOSS_ENTRYWAY, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED);}}),
Entrance(DEKU_TREE_BOSS_ENTRYWAY, {[]{return false;}}),
});
areaTable[DEKU_TREE_BASEMENT_LOWER] = Area("Deku Tree Basement Lower", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {
@ -84,18 +76,14 @@ void AreaTable_Init_DekuTree() {
}, {
//Locations
LocationAccess(DEKU_TREE_BASEMENT_CHEST, {[]{return true;}}),
LocationAccess(DEKU_TREE_GS_BASEMENT_GATE, {[]{return IsAdult || CanChildAttack;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(DEKU_TREE_GS_BASEMENT_VINES, {[]{return CanUseProjectile || CanUse(DINS_FIRE) || (LogicDekuBasementGS && (IsAdult || Sticks || KokiriSword));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE);}}),
LocationAccess(DEKU_TREE_GS_BASEMENT_GATE, {[]{return IsAdult || CanChildAttack;}}),
LocationAccess(DEKU_TREE_GS_BASEMENT_VINES, {[]{return CanUseProjectile || CanUse(DINS_FIRE) || (LogicDekuBasementGS && (IsAdult || Sticks || KokiriSword));}}),
}, {
//Exits
Entrance(DEKU_TREE_LOBBY, {[]{return true;}}),
Entrance(DEKU_TREE_BASEMENT_SCRUB_ROOM, {[]{return Here(DEKU_TREE_BASEMENT_LOWER, []{return HasFireSourceWithTorch || CanUse(BOW);});}}),
Entrance(DEKU_TREE_BASEMENT_UPPER, {[]{return IsAdult || LogicDekuB1Skip || HasAccessTo(DEKU_TREE_BASEMENT_UPPER);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
Entrance(DEKU_TREE_OUTSIDE_BOSS_ROOM, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
Entrance(DEKU_TREE_BASEMENT_UPPER, {[]{return IsAdult || LogicDekuB1Skip || HasAccessTo(DEKU_TREE_BASEMENT_UPPER);}}),
Entrance(DEKU_TREE_OUTSIDE_BOSS_ROOM, {[]{return false;}}),
});
areaTable[DEKU_TREE_BASEMENT_SCRUB_ROOM] = Area("Deku Tree Basement Scrub Room", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -113,8 +101,7 @@ void AreaTable_Init_DekuTree() {
areaTable[DEKU_TREE_BASEMENT_TORCH_ROOM] = Area("Deku Tree Basement Torch Room", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {}, {
//Exits
Entrance(DEKU_TREE_BASEMENT_WATER_ROOM, {[]{return true;}}),
@ -125,22 +112,18 @@ void AreaTable_Init_DekuTree() {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return HasFireSourceWithTorch || CanUse(BOW);}) &&
(IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE)));},
/*Glitched*/[]{return Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return HasFireSourceWithTorch || CanUse(BOW);}) && CanUse(MEGATON_HAMMER);}}),
(IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE)));}}),
}, {}, {
//Exits
Entrance(DEKU_TREE_BASEMENT_TORCH_ROOM, {[]{return true;}}),
Entrance(DEKU_TREE_BASEMENT_BACK_ROOM, {[]{return Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return HasFireSourceWithTorch || CanUse(Bow);}) &&
Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return HasFireSourceWithTorch || CanUse(Bow);}) &&
Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::EXPERT));});}}),
Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return CanBlastOrSmash;});}}),
Entrance(DEKU_TREE_BASEMENT_UPPER, {[]{return Here(DEKU_TREE_BASEMENT_BACK_LOBBY, []{return HasFireSourceWithTorch || CanUse(Bow);}) && IsChild;}}),
});
areaTable[DEKU_TREE_BASEMENT_BACK_ROOM] = Area("Deku Tree Basement Back Room", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DEKU_TREE_GS_BASEMENT_BACK_ROOM, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(DEKU_TREE_GS_BASEMENT_BACK_ROOM, {[]{return HookshotOrBoomerang;}}),
}, {
//Exits
Entrance(DEKU_TREE_BASEMENT_BACK_LOBBY, {[]{return true;}}),
@ -149,8 +132,7 @@ void AreaTable_Init_DekuTree() {
areaTable[DEKU_TREE_BASEMENT_UPPER] = Area("Deku Tree Basement Upper", "Deku Tree", DEKU_TREE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {}, {
//Exits
Entrance(DEKU_TREE_BASEMENT_LOWER, {[]{return true;}}),
@ -196,7 +178,7 @@ void AreaTable_Init_DekuTree() {
LocationAccess(DEKU_TREE_MQ_GS_COMPASS_ROOM, {[]{return HookshotOrBoomerang &&
Here(DEKU_TREE_MQ_COMPASS_ROOM, []{return HasBombchus ||
(Bombs && (CanPlay(SongOfTime) || IsAdult)) ||
(IsAdult && CanUse(MEGATON_HAMMER) && (CanPlay(SongOfTime) /*|| LogicDekuMQCompassGS*/));});}}),
(IsAdult && CanUse(MEGATON_HAMMER) && (CanPlay(SongOfTime) || LogicDekuMQCompassGS));});}}),
}, {
//Exits
Entrance(DEKU_TREE_MQ_LOBBY, {[]{return true;}}),
@ -207,7 +189,7 @@ void AreaTable_Init_DekuTree() {
LocationAccess(DEKU_TREE_MQ_BEFORE_SPINNING_LOG_CHEST, {[]{return true;}}),
}, {
//Exits
Entrance(DEKU_TREE_MQ_BASEMENT_WATER_ROOM_BACK, {[]{return /*LogicDekuMQLog || */ (IsChild && (DekuShield || HylianShield)) ||
Entrance(DEKU_TREE_MQ_BASEMENT_WATER_ROOM_BACK, {[]{return LogicDekuMQLog || (IsChild && (DekuShield || HylianShield)) ||
(IsAdult && (CanUse(LONGSHOT) || (CanUse(HOOKSHOT) && CanUse(IRON_BOOTS))));}}),
Entrance(DEKU_TREE_MQ_LOBBY, {[]{return true;}}),
});
@ -274,9 +256,7 @@ void AreaTable_Init_DekuTree() {
return DekuTreeClear ||
(CanJumpslash && (Nuts || CanUse(SLINGSHOT) || CanUse(BOW) ||
HookshotOrBoomerang));
},
/*Glitched*/
[] { return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE); } }),
}}),
},
{
// Locations

104
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_dodongos_cavern.cpp
View File

@ -24,34 +24,26 @@ void AreaTable_Init_DodongosCavern() {
areaTable[DODONGOS_CAVERN_BEGINNING] = Area("Dodongos Cavern Beginning", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_ENTRYWAY, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return Here(DODONGOS_CAVERN_BEGINNING, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_BEGINNING, []{return GlitchBlueFireWall && BlueFire;});}}),
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return Here(DODONGOS_CAVERN_BEGINNING, []{return CanBlastOrSmash || GoronBracelet;});}}),
});
areaTable[DODONGOS_CAVERN_LOBBY] = Area("Dodongos Cavern Lobby", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&GossipStoneFairy, {[]{return GossipStoneFairy || (CanSummonGossipFairy && Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;}));},
/*Glitched*/[]{return CanSummonGossipFairy && Here(DODONGOS_CAVERN_LOBBY, []{return GlitchBlueFireWall && BlueFire;});}}),
EventAccess(&GossipStoneFairy, {[]{return GossipStoneFairy || (CanSummonGossipFairy && Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;}));}}),
}, {
//Locations
LocationAccess(DODONGOS_CAVERN_MAP_CHEST, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_LOBBY, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}) || CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(DODONGOS_CAVERN_MAP_CHEST, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});}}),
LocationAccess(DODONGOS_CAVERN_DEKU_SCRUB_LOBBY, {[]{return CanStunDeku || GoronBracelet;}}),
LocationAccess(DODONGOS_CAVERN_GOSSIP_STONE, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_LOBBY, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));});}}),
LocationAccess(DODONGOS_CAVERN_GOSSIP_STONE, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_BEGINNING, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_LOBBY_SWITCH, {[]{return IsAdult;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) || (HasExplosives && (CanUse(SLINGSHOT) || CanUse(HOOKSHOT) || CanUse(BOW)) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)) || (CanShield && GoronBracelet && GlitchModernHalfie) || ((KokiriSword || Sticks || CanUse(MEGATON_HAMMER)) && (Bombs || GoronBracelet) && Fairy && GlitchClassicHalfie);}}),
Entrance(DODONGOS_CAVERN_SE_CORRIDOR, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_LOBBY, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));});}}),
Entrance(DODONGOS_CAVERN_LOBBY_SWITCH, {[]{return IsAdult;}}),
Entrance(DODONGOS_CAVERN_SE_CORRIDOR, {[]{return Here(DODONGOS_CAVERN_LOBBY, []{return CanBlastOrSmash || GoronBracelet;});}}),
Entrance(DODONGOS_CAVERN_STAIRS_LOWER, {[]{return HasAccessTo(DODONGOS_CAVERN_LOBBY_SWITCH);}}),
Entrance(DODONGOS_CAVERN_FAR_BRIDGE, {[]{return HasAccessTo(DODONGOS_CAVERN_FAR_BRIDGE);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(DODONGOS_CAVERN_FAR_BRIDGE, {[]{return HasAccessTo(DODONGOS_CAVERN_FAR_BRIDGE);}}),
Entrance(DODONGOS_CAVERN_BOSS_AREA, {[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return HasExplosives;});}}),
Entrance(DODONGOS_CAVERN_BOSS_ENTRYWAY,{[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED);}}),
Entrance(DODONGOS_CAVERN_BOSS_ENTRYWAY,{[]{return false;}}),
});
areaTable[DODONGOS_CAVERN_LOBBY_SWITCH] = Area("Dodongos Cavern Lobby Switch", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -62,20 +54,17 @@ void AreaTable_Init_DodongosCavern() {
areaTable[DODONGOS_CAVERN_SE_CORRIDOR] = Area("Dodongos Cavern SE Corridor", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DODONGOS_CAVERN_GS_SCARECROW, {[]{return CanUse(SCARECROW) || (IsAdult && CanUse(LONGSHOT)) || (LogicDCScarecrowGS && (IsAdult || CanChildAttack));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (CanUse(LONGSHOT) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
LocationAccess(DODONGOS_CAVERN_GS_SCARECROW, {[]{return CanUse(SCARECROW) || (IsAdult && CanUse(LONGSHOT)) || (LogicDCScarecrowGS && (IsAdult || CanChildAttack));}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_SE_ROOM, {[]{return Here(DODONGOS_CAVERN_SE_CORRIDOR, []{return CanBlastOrSmash || IsAdult || CanChildAttack || (CanTakeDamage && CanShield);});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_SE_CORRIDOR, []{return (GlitchBlueFireWall && BlueFire);});}}),
Entrance(DODONGOS_CAVERN_SE_ROOM, {[]{return Here(DODONGOS_CAVERN_SE_CORRIDOR, []{return CanBlastOrSmash || IsAdult || CanChildAttack || (CanTakeDamage && CanShield);});}}),
Entrance(DODONGOS_CAVERN_NEAR_LOWER_LIZALFOS, {[]{return true;}}),
});
areaTable[DODONGOS_CAVERN_SE_ROOM] = Area("Dodongos Cavern SE Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DODONGOS_CAVERN_GS_SIDE_ROOM_NEAR_LOWER_LIZALFOS, {[]{return IsAdult || CanChildAttack;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(DODONGOS_CAVERN_GS_SIDE_ROOM_NEAR_LOWER_LIZALFOS, {[]{return IsAdult || CanChildAttack;}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_SE_CORRIDOR, {[]{return true;}}),
@ -89,18 +78,15 @@ void AreaTable_Init_DodongosCavern() {
areaTable[DODONGOS_CAVERN_LOWER_LIZALFOS] = Area("Dodongos Cavern Lower Lizalfos", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_NEAR_LOWER_LIZALFOS, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DODONGOS_CAVERN_DODONGO_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DODONGOS_CAVERN_NEAR_LOWER_LIZALFOS, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});}}),
Entrance(DODONGOS_CAVERN_DODONGO_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});}}),
});
areaTable[DODONGOS_CAVERN_DODONGO_ROOM] = Area("Dodongos Cavern Dodongo Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_LOBBY_SWITCH, {[]{return HasFireSourceWithTorch;}}),
Entrance(DODONGOS_CAVERN_LOWER_LIZALFOS, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_NEAR_DODONGO_ROOM, {[]{return Here(DODONGOS_CAVERN_DODONGO_ROOM, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_DODONGO_ROOM, []{return GlitchBlueFireWall && BlueFire;});}}),
Entrance(DODONGOS_CAVERN_NEAR_DODONGO_ROOM, {[]{return Here(DODONGOS_CAVERN_DODONGO_ROOM, []{return CanBlastOrSmash || GoronBracelet;});}}),
});
areaTable[DODONGOS_CAVERN_NEAR_DODONGO_ROOM] = Area("Dodongos Cavern Near Dodongo Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
@ -115,15 +101,13 @@ void AreaTable_Init_DodongosCavern() {
//Exits
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_STAIRS_UPPER, {[]{return HasExplosives || GoronBracelet || CanUse(DINS_FIRE) || (LogicDCStaircase && CanUse(BOW));}}),
Entrance(DODONGOS_CAVERN_COMPASS_ROOM, {[]{return Here(DODONGOS_CAVERN_STAIRS_LOWER, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_STAIRS_LOWER, []{return GlitchBlueFireWall && BlueFire;});}}),
Entrance(DODONGOS_CAVERN_COMPASS_ROOM, {[]{return Here(DODONGOS_CAVERN_STAIRS_LOWER, []{return CanBlastOrSmash || GoronBracelet;});}}),
});
areaTable[DODONGOS_CAVERN_STAIRS_UPPER] = Area("Dodongos Cavern Stairs Upper", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DODONGOS_CAVERN_GS_ALCOVE_ABOVE_STAIRS, {[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return HookshotOrBoomerang;}) || CanUse(LONGSHOT);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE) && HookshotOrBoomerang);}}),
LocationAccess(DODONGOS_CAVERN_GS_VINES_ABOVE_STAIRS, {[]{return IsAdult || CanChildAttack;}}),
LocationAccess(DODONGOS_CAVERN_GS_ALCOVE_ABOVE_STAIRS, {[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return HookshotOrBoomerang;}) || CanUse(LONGSHOT);}}),
LocationAccess(DODONGOS_CAVERN_GS_VINES_ABOVE_STAIRS, {[]{return IsAdult || CanChildAttack || (HasAccessTo(DODONGOS_CAVERN_STAIRS_LOWER) && CanUse(LONGSHOT) && LogicDCVinesGS);}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_STAIRS_LOWER, {[]{return true;}}),
@ -135,8 +119,7 @@ void AreaTable_Init_DodongosCavern() {
LocationAccess(DODONGOS_CAVERN_COMPASS_CHEST, {[]{return true;}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_STAIRS_LOWER, {[]{return IsAdult || HasExplosives || GoronBracelet;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DODONGOS_CAVERN_STAIRS_LOWER, {[]{return IsAdult || HasExplosives || GoronBracelet;}}),
});
areaTable[DODONGOS_CAVERN_ARMOS_ROOM] = Area("Dodongos Cavern Armos Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -150,13 +133,9 @@ void AreaTable_Init_DodongosCavern() {
LocationAccess(DODONGOS_CAVERN_BOMB_FLOWER_PLATFORM_CHEST, {[]{return true;}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_2F_SIDE_ROOM, {[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));});}}),
Entrance(DODONGOS_CAVERN_FIRST_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return CanBlastOrSmash || GoronBracelet;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));});}}),
Entrance(DODONGOS_CAVERN_BOMB_ROOM_UPPER, {[]{return (IsAdult && LogicDCJump) || CanUse(HOVER_BOOTS) || (IsAdult && CanUse(LONGSHOT));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE) ||
(IsAdult && (CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(SLINGSHOT)) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED));}}),
Entrance(DODONGOS_CAVERN_2F_SIDE_ROOM, {[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return CanBlastOrSmash || (LogicDCScrubRoom && GoronBracelet);});}}),
Entrance(DODONGOS_CAVERN_FIRST_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_BOMB_ROOM_LOWER, []{return CanBlastOrSmash || GoronBracelet;});}}),
Entrance(DODONGOS_CAVERN_BOMB_ROOM_UPPER, {[]{return (IsAdult && LogicDCJump) || CanUse(HOVER_BOOTS) || (IsAdult && CanUse(LONGSHOT));}}),
});
areaTable[DODONGOS_CAVERN_2F_SIDE_ROOM] = Area("Dodongos Cavern 2F Side Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
@ -171,24 +150,20 @@ void AreaTable_Init_DodongosCavern() {
areaTable[DODONGOS_CAVERN_FIRST_SLINGSHOT_ROOM] = Area("Dodongos Cavern First Slingshot Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_BOMB_ROOM_LOWER, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_UPPER_LIZALFOS, {[]{return CanUse(SLINGSHOT) || CanUse(BOW) || LogicDCSlingshotSkip;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (IsAdult && CanUse(HOOKSHOT) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED));}}),
Entrance(DODONGOS_CAVERN_UPPER_LIZALFOS, {[]{return CanUse(SLINGSHOT) || CanUse(BOW) || LogicDCSlingshotSkip;}}),
});
areaTable[DODONGOS_CAVERN_UPPER_LIZALFOS] = Area("Dodongos Cavern Upper Lizalfos", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_LOWER_LIZALFOS, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_FIRST_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DODONGOS_CAVERN_SECOND_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(DODONGOS_CAVERN_FIRST_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});}}),
Entrance(DODONGOS_CAVERN_SECOND_SLINGSHOT_ROOM, {[]{return Here(DODONGOS_CAVERN_LOWER_LIZALFOS, []{return IsAdult || Slingshot || Sticks || KokiriSword || HasExplosives;});}}),
});
areaTable[DODONGOS_CAVERN_SECOND_SLINGSHOT_ROOM] = Area("Dodongos Cavern Second Slingshot Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_UPPER_LIZALFOS, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_BOMB_ROOM_UPPER, {[]{return CanUse(SLINGSHOT) || CanUse(BOW) || LogicDCSlingshotSkip;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (IsAdult && CanUse(HOOKSHOT) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED));}}),
Entrance(DODONGOS_CAVERN_BOMB_ROOM_UPPER, {[]{return CanUse(SLINGSHOT) || CanUse(BOW) || LogicDCSlingshotSkip;}}),
});
areaTable[DODONGOS_CAVERN_BOMB_ROOM_UPPER] = Area("Dodongos Cavern Bomb Room Upper", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
@ -203,9 +178,7 @@ void AreaTable_Init_DodongosCavern() {
areaTable[DODONGOS_CAVERN_FAR_BRIDGE] = Area("Dodongos Cavern Far Bridge", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DODONGOS_CAVERN_END_OF_BRIDGE_CHEST, {[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));}) ||
CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(DODONGOS_CAVERN_END_OF_BRIDGE_CHEST, {[]{return Here(DODONGOS_CAVERN_FAR_BRIDGE, []{return CanBlastOrSmash;});}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return true;}}),
@ -218,15 +191,13 @@ void AreaTable_Init_DodongosCavern() {
}, {}, {
//Exits
Entrance(DODONGOS_CAVERN_LOBBY, {[]{return true;}}),
Entrance(DODONGOS_CAVERN_BACK_ROOM, {[]{return Here(DODONGOS_CAVERN_BOSS_AREA, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(DODONGOS_CAVERN_BOSS_AREA, []{return (GlitchBlueFireWall && BlueFire) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED));});}}),
Entrance(DODONGOS_CAVERN_BACK_ROOM, {[]{return Here(DODONGOS_CAVERN_BOSS_AREA, []{return CanBlastOrSmash;});}}),
Entrance(DODONGOS_CAVERN_BOSS_ENTRYWAY, {[]{return true;}}),
});
areaTable[DODONGOS_CAVERN_BACK_ROOM] = Area("Dodongos Cavern Back Room", "Dodongos Cavern", DODONGOS_CAVERN, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(DODONGOS_CAVERN_GS_BACK_ROOM, {[]{return IsAdult || CanChildAttack;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(DODONGOS_CAVERN_GS_BACK_ROOM, {[]{return IsAdult || CanChildAttack;}}),
}, {
//Exits
Entrance(DODONGOS_CAVERN_BOSS_AREA, {[]{return true;}}),
@ -263,9 +234,9 @@ void AreaTable_Init_DodongosCavern() {
}, {
//Exits
Entrance(DODONGOS_CAVERN_MQ_LOWER_RIGHT_SIDE, {[]{return Here(DODONGOS_CAVERN_MQ_LOBBY, []{return CanBlastOrSmash || (((IsChild && CanUse(STICKS)) || CanUse(DINS_FIRE)) && CanTakeDamage);});}}),
Entrance(DODONGOS_CAVERN_MQ_BOMB_BAG_AREA, {[]{return IsAdult || (Here(DODONGOS_CAVERN_MQ_LOBBY, []{return IsAdult;}) && HasExplosives);}}),
Entrance(DODONGOS_CAVERN_MQ_BOMB_BAG_AREA, {[]{return IsAdult || (Here(DODONGOS_CAVERN_MQ_LOBBY, []{return IsAdult;}) && HasExplosives) || (LogicDCMQChildBombs && CanJumpslash && CanTakeDamage);}}),
//Trick: IsAdult || HasExplosives || (LogicDCMQChildBombs && (KokiriSword || Sticks) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO))
Entrance(DODONGOS_CAVERN_MQ_BOSS_AREA, {[]{return HasExplosives;}}),
Entrance(DODONGOS_CAVERN_MQ_BOSS_AREA, {[]{return HasExplosives || (GoronBracelet && ((IsAdult && LogicDCMQEyesAdult) || (IsChild && LogicDCMQEyesChild)) && ((IsChild && (CanUse(STICKS))) || CanUse(DINS_FIRE) || (IsAdult && (LogicDCJump || Hammer || HoverBoots || Hookshot))));}}),
//Trick: HasExplosives || (LogicDCMQEyes && GoronBracelet && (IsAdult || LogicDCMQChildBack) && ((IsChild && CanUse(STICKS)) || CanUse(DINS_FIRE) || (IsAdult && (LogicDCJump || Hammer || HoverBoots || Hookshot))))
});
@ -321,18 +292,9 @@ void AreaTable_Init_DodongosCavern() {
{ [] {
return DodongosCavernClear ||
(Here(DODONGOS_CAVERN_BOSS_ROOM,
[] { return HasExplosives || (CanUse(MEGATON_HAMMER) && CanShield); }) &&
(Bombs || GoronBracelet) && CanJumpslash);
},
/*Glitched*/
[] {
return Here(DODONGOS_CAVERN_BOSS_ROOM,
[] {
return HasExplosives || (CanUse(MEGATON_HAMMER) && CanShield) ||
(GlitchBlueFireWall && BlueFire);
}) &&
(HasExplosives || GoronBracelet) && CanJumpslash;
} }),
[] { return HasExplosives || (CanUse(MEGATON_HAMMER) && LogicDCHammerFloor); }) &&
(Bombs || GoronBracelet) && CanJumpslash); /*todo add chu kill to tricks*/
}}),
},
{
// Locations

122
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_fire_temple.cpp
View File

@ -26,9 +26,7 @@ void AreaTable_Init_FireTemple() {
//Exits
Entrance(FIRE_TEMPLE_ENTRYWAY, {[]{return true;}}),
Entrance(FIRE_TEMPLE_NEAR_BOSS_ROOM, {[]{return FireTimer >= 24;}}),
Entrance(FIRE_TEMPLE_LOOP_ENEMIES, {[]{return Here(FIRE_TEMPLE_FIRST_ROOM, []{return CanUse(MEGATON_HAMMER);}) && (SmallKeys(FIRE_TEMPLE, 8) || !IsKeysanity);},
/*Glitched*/[]{return ((IsAdult && CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::EXPERT)) ||
(GlitchFireGrunzClip && Bombs && IsAdult && CanUse(HOVER_BOOTS) && CanSurviveDamage)) && (SmallKeys(FIRE_TEMPLE, 8) || !IsKeysanity);}}),
Entrance(FIRE_TEMPLE_LOOP_ENEMIES, {[]{return Here(FIRE_TEMPLE_FIRST_ROOM, []{return CanUse(MEGATON_HAMMER);}) && (SmallKeys(FIRE_TEMPLE, 8) || !IsKeysanity);}}),
Entrance(FIRE_TEMPLE_LOOP_EXIT, {[]{return true;}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 2) && FireTimer >= 24;}}),
});
@ -42,22 +40,18 @@ void AreaTable_Init_FireTemple() {
}, {
//Exits
Entrance(FIRE_TEMPLE_FIRST_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_BOSS_ENTRYWAY, {[]{return BossKeyFireTemple && ((IsAdult && LogicFireBossDoorJump) || CanUse(HOVER_BOOTS) || Here(FIRE_TEMPLE_FIRE_MAZE_UPPER, []{return CanUse(MEGATON_HAMMER);}));},
/*Glitched*/[]{return BossKeyFireTemple && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) ||
(Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)));}}),
Entrance(FIRE_TEMPLE_BOSS_ENTRYWAY, {[]{return BossKeyFireTemple && ((IsAdult && LogicFireBossDoorJump) || CanUse(HOVER_BOOTS) || Here(FIRE_TEMPLE_FIRE_MAZE_UPPER, []{return CanUse(MEGATON_HAMMER);}));}}),
});
areaTable[FIRE_TEMPLE_LOOP_ENEMIES] = Area("Fire Temple Loop Enemies", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_FIRST_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 8) || !IsKeysanity;}}),
Entrance(FIRE_TEMPLE_LOOP_TILES, {[]{return Here(FIRE_TEMPLE_LOOP_ENEMIES, []{return IsAdult || KokiriSword;});},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FIRE_TEMPLE_LOOP_TILES, {[]{return Here(FIRE_TEMPLE_LOOP_ENEMIES, []{return IsAdult || KokiriSword;});}}),
});
areaTable[FIRE_TEMPLE_LOOP_TILES] = Area("Fire Temple Loop Tiles", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_GS_BOSS_KEY_LOOP, {[]{return IsAdult || CanChildAttack;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(FIRE_TEMPLE_GS_BOSS_KEY_LOOP, {[]{return IsAdult || CanChildAttack;}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_LOOP_ENEMIES, {[]{return true;}}),
@ -66,9 +60,7 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_LOOP_FLARE_DANCER] = Area("Fire Temple Loop Flare Dancer", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_FLARE_DANCER_CHEST, {[]{return (HasExplosives || CanUse(MEGATON_HAMMER)) && IsAdult;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)) ||
(CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED) && HasBombchus && CanShield && (Slingshot || CanUse(BOW) || CanUse(HOOKSHOT)));}}),
LocationAccess(FIRE_TEMPLE_FLARE_DANCER_CHEST, {[]{return (HasExplosives || CanUse(MEGATON_HAMMER)) && IsAdult;}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_LOOP_TILES, {[]{return true;}}),
@ -77,13 +69,11 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_LOOP_HAMMER_SWITCH] = Area("Fire Temple Loop Hammer Switch", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&FireLoopSwitch, {[]{return FireLoopSwitch || CanUse(MEGATON_HAMMER);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE) && Bombs && CanTakeDamage && CanUse(STICKS);}}),
EventAccess(&FireLoopSwitch, {[]{return FireLoopSwitch || CanUse(MEGATON_HAMMER);}}),
}, {}, {
//Exits
Entrance(FIRE_TEMPLE_LOOP_FLARE_DANCER, {[]{return true;}}),
Entrance(FIRE_TEMPLE_LOOP_GORON_ROOM, {[]{return FireLoopSwitch;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_LOOP_GORON_ROOM, {[]{return FireLoopSwitch;}}),
});
areaTable[FIRE_TEMPLE_LOOP_GORON_ROOM] = Area("Fire Temple Loop Goron Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -98,19 +88,15 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_LOOP_EXIT] = Area("Fire Temple Loop Exit", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_FIRST_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_LOOP_GORON_ROOM, {[]{return FireLoopSwitch;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_LOOP_GORON_ROOM, {[]{return FireLoopSwitch;}}),
});
areaTable[FIRE_TEMPLE_BIG_LAVA_ROOM] = Area("Fire Temple Big Lava Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_FIRST_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 2);}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM_NORTH_GORON, {[]{return true;}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM_NORTH_TILES, {[]{return IsAdult && (CanPlay(SongOfTime) || LogicFireSongOfTime);},
/*Glitched*/[]{return FireTimer >= 48 && ((CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)) ||
(IsAdult && (SongOfTime && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) || (CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && (Bugs || Fish) && CanShield)))));}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM_SOUTH_GORON, {[]{return IsAdult && HasExplosives;},
/*Glitched*/[]{return FireTimer >= 48 && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM_NORTH_TILES, {[]{return IsAdult && (CanPlay(SongOfTime) || LogicFireSongOfTime);}}),
Entrance(FIRE_TEMPLE_BIG_LAVA_ROOM_SOUTH_GORON, {[]{return IsAdult && HasExplosives;}}),
Entrance(FIRE_TEMPLE_FIRE_PILLAR_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 3);}}),
});
@ -146,16 +132,12 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_SHORTCUT_ROOM] = Area("Fire Temple Shortcut Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_BOULDER_MAZE_SHORTCUT_CHEST, {[]{return Here(FIRE_TEMPLE_SHORTCUT_CLIMB, []{return true;});},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(FIRE_TEMPLE_BOULDER_MAZE_SHORTCUT_CHEST, {[]{return Here(FIRE_TEMPLE_SHORTCUT_CLIMB, []{return true;});}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_FIRE_PILLAR_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 4);}}),
Entrance(FIRE_TEMPLE_SHORTCUT_CLIMB, {[]{return Here(FIRE_TEMPLE_SHORTCUT_CLIMB, []{return true;});},
/*Glitched*/[]{return (GoronBracelet || LogicFireStrength) && Bombs && CanSurviveDamage && CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_LOWER, {[]{return (GoronBracelet || (IsAdult && LogicFireStrength)) && (HasExplosives || (IsAdult && (CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(SLINGSHOT))));},
/*Glitched*/[]{return (GoronBracelet || (IsAdult && LogicFireStrength)) && (CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE) ||
(CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanUse(STICKS)));}}),
Entrance(FIRE_TEMPLE_SHORTCUT_CLIMB, {[]{return Here(FIRE_TEMPLE_SHORTCUT_CLIMB, []{return true;});}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_LOWER, {[]{return (GoronBracelet || (IsAdult && LogicFireStrength)) && (HasExplosives || (IsAdult && (CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(SLINGSHOT))));}}),
});
areaTable[FIRE_TEMPLE_SHORTCUT_CLIMB] = Area("Fire Temple Shortcut Climb", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -167,16 +149,13 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_BOULDER_MAZE_LOWER] = Area("Fire Temple Boulder Maze Lower", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_BOULDER_MAZE_LOWER_CHEST, {[]{return true;}}),
LocationAccess(FIRE_TEMPLE_GS_BOULDER_MAZE, {[]{return HasExplosives && (IsAdult || Boomerang || CanUse(HOOKSHOT));},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE) && Bombs) ||
Here(FIRE_TEMPLE_BOULDER_MAZE_UPPER, []{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);});}}),
LocationAccess(FIRE_TEMPLE_GS_BOULDER_MAZE, {[]{return HasExplosives && (IsAdult || Boomerang || CanUse(HOOKSHOT));}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_SHORTCUT_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_LOWER_SIDE_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_EAST_CENTRAL_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 5, 7);}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_UPPER, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE) && Bombs;}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_UPPER, {[]{return false;}}),
});
areaTable[FIRE_TEMPLE_BOULDER_MAZE_LOWER_SIDE_ROOM] = Area("Fire Temple Boulder Maze Lower Side Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -199,10 +178,8 @@ void AreaTable_Init_FireTemple() {
//Exits
Entrance(FIRE_TEMPLE_EAST_CENTRAL_ROOM, {[]{return FireTimer >= 24 && SmallKeys(FIRE_TEMPLE, 6, 8);}}),
Entrance(FIRE_TEMPLE_MAP_AREA, {[]{return IsAdult;}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_UPPER, {[]{return FireTimer >= 24 && IsAdult;},
/*Glitched*/[]{return FireTimer >= 32 && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_CORRIDOR, {[]{return FireTimer >= 24 && IsAdult && SmallKeys(FIRE_TEMPLE, 7);},
/*Glitched*/[]{return FireTimer >= 32 && SmallKeys(FIRE_TEMPLE, 7) && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && Bombs && HasBombchus && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_BOULDER_MAZE_UPPER, {[]{return FireTimer >= 24 && IsAdult;}}),
Entrance(FIRE_TEMPLE_CORRIDOR, {[]{return FireTimer >= 24 && IsAdult && SmallKeys(FIRE_TEMPLE, 7);}}),
});
areaTable[FIRE_TEMPLE_MAP_AREA] = Area("Fire Temple Map Area", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -252,20 +229,17 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_FIRE_MAZE_ROOM] = Area("Fire Temple Fire Maze Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_CORRIDOR, {[]{return true;}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_UPPER, {[]{return CanUse(HOVER_BOOTS);},
/*Glitched*/[]{return Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_UPPER, {[]{return CanUse(HOVER_BOOTS);}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_SIDE_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_LOWER, {[]{return SmallKeys(FIRE_TEMPLE, 8);}}),
Entrance(FIRE_TEMPLE_LATE_FIRE_MAZE, {[]{return LogicFireFlameMaze || false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE) || (CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED) && Bombs && CanShield);}}),
Entrance(FIRE_TEMPLE_LATE_FIRE_MAZE, {[]{return LogicFireFlameMaze || false;}}),
});
areaTable[FIRE_TEMPLE_FIRE_MAZE_UPPER] = Area("Fire Temple Fire Maze Upper", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_NEAR_BOSS_ROOM, {[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_ROOM, {[]{return true;}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_UPPER, {[]{return CanUse(MEGATON_HAMMER);},
/*Glitched*/[]{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE);}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_UPPER, {[]{return CanUse(MEGATON_HAMMER);}}),
});
areaTable[FIRE_TEMPLE_FIRE_MAZE_SIDE_ROOM] = Area("Fire Temple Fire Maze Side Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -278,32 +252,24 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_WEST_CENTRAL_LOWER] = Area("Fire Temple West Central Lower", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_HIGHEST_GORON_CHEST, {[]{return Here(FIRE_TEMPLE_WEST_CENTRAL_UPPER, []{return CanPlay(SongOfTime) && CanUse(MEGATON_HAMMER);});},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE) || Here(FIRE_TEMPLE_WEST_CENTRAL_UPPER, []{return (IsAdult || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) ||
(Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE))) &&
(((SongOfTime && (((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::NOVICE))) ||
CanPlay(SongOfTime)) && ((CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE)) || CanUse(MEGATON_HAMMER)));});}}),
LocationAccess(FIRE_TEMPLE_HIGHEST_GORON_CHEST, {[]{return Here(FIRE_TEMPLE_WEST_CENTRAL_UPPER, []{return (CanPlay(SongOfTime) || LogicRustedSwitches) && CanUse(MEGATON_HAMMER);});}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_FIRE_MAZE_ROOM, {[]{return SmallKeys(FIRE_TEMPLE, 8);}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_UPPER, {[]{return IsAdult && CanPlay(SongOfTime);},
/*Glitched*/[]{return (IsAdult && SongOfTime && (((Bugs || Fish) && CanShield && (CanSurviveDamage || (CanTakeDamage && NumBottles >= 2)) && Bombs && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
(CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::NOVICE)))) || (Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_UPPER, {[]{return IsAdult && CanPlay(SongOfTime);}}),
Entrance(FIRE_TEMPLE_LATE_FIRE_MAZE, {[]{return true;}}),
});
areaTable[FIRE_TEMPLE_WEST_CENTRAL_UPPER] = Area("Fire Temple West Central Upper", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_BOSS_ENTRYWAY, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FIRE_TEMPLE_BOSS_ENTRYWAY, {[]{return false;}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_UPPER, {[]{return true;}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_LOWER, {[]{return true;}}),
});
areaTable[FIRE_TEMPLE_LATE_FIRE_MAZE] = Area("Fire Temple Late Fire Maze", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_FIRE_MAZE_ROOM, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || (Bombs && CanShield && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED));}}),
Entrance(FIRE_TEMPLE_FIRE_MAZE_ROOM, {[]{return false;}}),
Entrance(FIRE_TEMPLE_WEST_CENTRAL_LOWER, {[]{return true;}}),
Entrance(FIRE_TEMPLE_UPPER_FLARE_DANCER, {[]{return HasExplosives;}}),
});
@ -317,8 +283,7 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_WEST_CLIMB] = Area("Fire Temple West Climb", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FIRE_TEMPLE_UPPER_FLARE_DANCER, {[]{return true;}}),
Entrance(FIRE_TEMPLE_WEST_PEAK, {[]{return CanUseProjectile;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE);}}),
Entrance(FIRE_TEMPLE_WEST_PEAK, {[]{return CanUseProjectile;}}),
});
areaTable[FIRE_TEMPLE_WEST_PEAK] = Area("Fire Temple West Peak", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -350,13 +315,7 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_MQ_LOWER] = Area("Fire Temple MQ Lower", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_MQ_MAP_ROOM_SIDE_CHEST, {[]{return IsAdult || KokiriSword || Sticks || Slingshot || Bombs || CanUse(DINS_FIRE);}}),
LocationAccess(FIRE_TEMPLE_MQ_NEAR_BOSS_CHEST, {[]{return IsAdult && FireTimer >= 24
&& (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT))
&& (CanUse(FIRE_ARROWS) || (CanUse(DINS_FIRE) &&
((DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_QUADRUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OCTUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_SEXDECUPLE))
|| CanUse(GORON_TUNIC)
|| CanUse(BOW)
|| CanUse(LONGSHOT))));}}),
LocationAccess(FIRE_TEMPLE_MQ_NEAR_BOSS_CHEST, {[]{return IsAdult && (LogicFewerTunicRequirements || CanUse(GORON_TUNIC)) && (((CanUse(HOVER_BOOTS) || (LogicFireMQNearBoss && CanUse(BOW))) && HasFireSource) || (CanUse(HOOKSHOT) && CanUse(FIRE_ARROWS) || (CanUse(DINS_FIRE) && ((DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_QUADRUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OCTUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_SEXDECUPLE)) || CanUse(GORON_TUNIC) || CanUse(BOW) || CanUse(LONGSHOT)))));}}),
//Trick: IsAdult && (LogicFewerTunicRequirements || CanUse(GORON_TUNIC)) && (((CanUse(HOVER_BOOTS) || (LogicFireMQNearBoss && CanUse(BOW))) && HasFireSource) || (CanUse(HOOKSHOT) && CanUse(FIRE_ARROWS) || (CanUse(DINS_FIRE) && ((DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_QUADRUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OCTUPLE) && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_SEXDECUPLE)) || CanUse(GORON_TUNIC) || CanUse(BOW) || CanUse(LONGSHOT)))))
}, {
//Exits
@ -377,29 +336,29 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_MQ_BIG_LAVA_ROOM] = Area("Fire Temple MQ Big Lava Room", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&FairyPot, {[]{return FairyPot || (HasFireSource && Bow && IsAdult && (CanUse(HOOKSHOT) || LogicFireSongOfTime));}}),
EventAccess(&FairyPot, {[]{return FairyPot || (HasFireSource && (Bow || LogicFireMQBKChest) && IsAdult && (CanUse(HOOKSHOT) || LogicFireSongOfTime));}}),
//Trick: HasFireSource && (Bow || LogicFireMQBKChest) && IsAdult && (CanUse(HOOKSHOT) || LogicFireSongOfTime)
}, {
//Locations
LocationAccess(FIRE_TEMPLE_MQ_BOSS_KEY_CHEST, {[]{return HasFireSource && Bow && IsAdult && CanUse(HOOKSHOT);}}),
LocationAccess(FIRE_TEMPLE_MQ_BOSS_KEY_CHEST, {[]{return HasFireSource && (Bow || LogicFireMQBKChest) && IsAdult && CanUse(HOOKSHOT);}}),
//Trick: HasFireSource && (Bow || LogicFireMQBKChest) && IsAdult && CanUse(HOOKSHOT)
LocationAccess(FIRE_TEMPLE_MQ_BIG_LAVA_ROOM_BLOCKED_DOOR_CHEST, {[]{return HasFireSource && HasExplosives && IsAdult && CanUse(HOOKSHOT);}}),
LocationAccess(FIRE_TEMPLE_MQ_BIG_LAVA_ROOM_BLOCKED_DOOR_CHEST, {[]{return HasFireSource && HasExplosives && IsAdult && (CanUse(HOOKSHOT) || LogicFireMQBlockedChest);}}),
//Trick: HasFireSource && HasExplosives && IsAdult && (CanUse(HOOKSHOT) || LogicFireMQBlockedChest)
LocationAccess(FIRE_TEMPLE_MQ_GS_BIG_LAVA_ROOM_OPEN_DOOR, {[]{return true;}}),
}, {
//Exits
Entrance(FIRE_TEMPLE_MQ_LOWER_MAZE, {[]{return IsAdult && CanUse(GORON_TUNIC) && SmallKeys(FIRE_TEMPLE, 2) && HasFireSource;}}),
Entrance(FIRE_TEMPLE_MQ_LOWER_MAZE, {[]{return IsAdult && CanUse(GORON_TUNIC) && SmallKeys(FIRE_TEMPLE, 2) && (HasFireSource || (LogicFireMQClimb && HoverBoots));}}),
//Trick: IsAdult && CanUse(GORON_TUNIC) && SmallKeys(FIRE_TEMPLE, 2) && (HasFireSource || (LogicFireMQClimb && HoverBoots))
});
areaTable[FIRE_TEMPLE_MQ_LOWER_MAZE] = Area("Fire Temple MQ Lower Maze", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_MQ_LIZALFOS_MAZE_LOWER_CHEST, {[]{return true;}}),
LocationAccess(FIRE_TEMPLE_MQ_LIZALFOS_MAZE_SIDE_ROOM_CHEST, {[]{return HasExplosives && HasAccessTo(FIRE_TEMPLE_MQ_UPPER_MAZE);}}),
LocationAccess(FIRE_TEMPLE_MQ_LIZALFOS_MAZE_SIDE_ROOM_CHEST, {[]{return HasExplosives && (LogicFireMQMazeSideRoom || HasAccessTo(FIRE_TEMPLE_MQ_UPPER_MAZE));}}),
//Trick: HasExplosives && (LogicFireMQMazeSideRoom || FIRE_TEMPLE_MQ_UPPER_MAZE.Adult())
}, {
//Exits
Entrance(FIRE_TEMPLE_MQ_UPPER_MAZE, {[]{return HasExplosives && IsAdult && CanUse(HOOKSHOT);}}),
Entrance(FIRE_TEMPLE_MQ_UPPER_MAZE, {[]{return (IsAdult && ((HasExplosives && CanUse(HOOKSHOT)) || (LogicFireMQMazeHovers && CanUse(HOVER_BOOTS)))) || LogicFireMQMazeJump;}}),
//Trick: (IsAdult && ((HasExplosives && CanUse(HOOKSHOT)) || (LogicFireMQMazeHovers && CanUse(HOVER_BOOTS)))) || LogicFireMQMazeJump
});
@ -419,14 +378,14 @@ void AreaTable_Init_FireTemple() {
areaTable[FIRE_TEMPLE_MQ_UPPER] = Area("Fire Temple MQ Upper", "Fire Temple", FIRE_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FIRE_TEMPLE_MQ_FREESTANDING_KEY, {[]{return IsAdult && CanUse(HOOKSHOT);}}),
LocationAccess(FIRE_TEMPLE_MQ_FREESTANDING_KEY, {[]{return (IsAdult && CanUse(HOOKSHOT)) || LogicFireMQFlameMaze;}}),
//Trick: (IsAdult && CanUse(HOOKSHOT)) || LogicFireMQFlameMaze
LocationAccess(FIRE_TEMPLE_MQ_CHEST_ON_FIRE, {[]{return IsAdult && CanUse(HOOKSHOT) && SmallKeys(FIRE_TEMPLE, 4);}}),
LocationAccess(FIRE_TEMPLE_MQ_CHEST_ON_FIRE, {[]{return ((IsAdult && CanUse(HOOKSHOT)) || LogicFireMQFlameMaze) && SmallKeys(FIRE_TEMPLE, 4);}}),
//Trick: ((IsAdult && CanUse(HOOKSHOT)) || LogicFireMQFlameMaze) && SmallKeys(FIRE_TEMPLE, 4)
LocationAccess(FIRE_TEMPLE_MQ_GS_FIRE_WALL_MAZE_SIDE_ROOM, {[]{return CanPlay(SongOfTime) || HoverBoots;}}),
LocationAccess(FIRE_TEMPLE_MQ_GS_FIRE_WALL_MAZE_SIDE_ROOM, {[]{return CanPlay(SongOfTime) || HoverBoots || LogicFireMQFlameMaze;}}),
//Trick: CanPlay(SongOfTime) || HoverBoots || LogicFireMQFlameMaze
LocationAccess(FIRE_TEMPLE_MQ_GS_FIRE_WALL_MAZE_CENTER, {[]{return HasExplosives;}}),
LocationAccess(FIRE_TEMPLE_MQ_GS_ABOVE_FIRE_WALL_MAZE, {[]{return IsAdult && CanUse(HOOKSHOT) && SmallKeys(FIRE_TEMPLE, 5);}}),
LocationAccess(FIRE_TEMPLE_MQ_GS_ABOVE_FIRE_WALL_MAZE, {[]{return (IsAdult && CanUse(HOOKSHOT) && SmallKeys(FIRE_TEMPLE, 5)) || (LogicFireMQAboveMazeGS && IsAdult && CanUse(LONGSHOT));}}),
//Trick: (IsAdult && CanUse(HOOKSHOT) && SmallKeys(FIRE_TEMPLE, 5)) || (LogicFireMQAboveMazeGS && IsAdult && CanUse(LONGSHOT))
}, {});
}
@ -448,14 +407,7 @@ void AreaTable_Init_FireTemple() {
{
// Events
EventAccess(&FireTempleClear,
{ [] { return FireTempleClear || (FireTimer >= 64 && CanUse(MEGATON_HAMMER)); },
/*Glitched*/
[] {
return FireTimer >= 48 &&
((CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE)) ||
CanUse(MEGATON_HAMMER)) &&
Bombs && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);
} }),
{ [] { return FireTempleClear || (FireTimer >= 64 && CanUse(MEGATON_HAMMER)); }}),
},
{
// Locations

106
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_forest_temple.cpp
View File

@ -24,8 +24,7 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_FIRST_ROOM] = Area("Forest Temple First Room", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FOREST_TEMPLE_FIRST_ROOM_CHEST, {[]{return true;}}),
LocationAccess(FOREST_TEMPLE_GS_FIRST_ROOM, {[]{return (IsAdult && Bombs) || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(BOOMERANG) || CanUse(SLINGSHOT) || HasBombchus || CanUse(DINS_FIRE);},
/*Glitched*/[]{return (Bombs && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE);}}),
LocationAccess(FOREST_TEMPLE_GS_FIRST_ROOM, {[]{return (IsAdult && Bombs) || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(BOOMERANG) || CanUse(SLINGSHOT) || HasBombchus || CanUse(DINS_FIRE) || (LogicForestFirstGS && (CanJumpslash || (IsChild && Bombs)));}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_ENTRYWAY, {[]{return true;}}),
@ -35,8 +34,7 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_SOUTH_CORRIDOR] = Area("Forest Temple South Corridor", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FOREST_TEMPLE_FIRST_ROOM, {[]{return true;}}),
Entrance(FOREST_TEMPLE_LOBBY, {[]{return IsAdult || CanChildAttack || Nuts;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_LOBBY, {[]{return IsAdult || CanChildAttack || Nuts;}}),
});
areaTable[FOREST_TEMPLE_LOBBY] = Area("Forest Temple Lobby", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
@ -44,22 +42,17 @@ void AreaTable_Init_ForestTemple() {
EventAccess(&ForestTempleMeg, {[]{return ForestTempleMeg || (ForestTempleJoelle && ForestTempleBeth && ForestTempleAmy && CanUse(BOW));}}),
}, {
//Locations
LocationAccess(FOREST_TEMPLE_GS_LOBBY, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return IsAdult && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
LocationAccess(FOREST_TEMPLE_GS_LOBBY, {[]{return HookshotOrBoomerang;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_SOUTH_CORRIDOR, {[]{return true;}}),
Entrance(FOREST_TEMPLE_NORTH_CORRIDOR, {[]{return true;}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_LOWER, {[]{return CanPlay(SongOfTime) || IsChild;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::NOVICE) || (SongOfTime && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))));}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_LOWER, {[]{return CanPlay(SongOfTime) || IsChild;}}),
Entrance(FOREST_TEMPLE_NE_OUTDOORS_LOWER, {[]{return CanUse(BOW) || CanUse(SLINGSHOT);}}),
Entrance(FOREST_TEMPLE_WEST_CORRIDOR, {[]{return SmallKeys(FOREST_TEMPLE, 1, 5);}}),
Entrance(FOREST_TEMPLE_EAST_CORRIDOR, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
Entrance(FOREST_TEMPLE_EAST_CORRIDOR, {[]{return false;}}),
Entrance(FOREST_TEMPLE_BOSS_REGION, {[]{return ForestTempleMeg;}}),
Entrance(FOREST_TEMPLE_BOSS_ENTRYWAY, {[]{return false;},
/*Glitched*/[]{return IsAdult && (CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(SLINGSHOT)) && GlitchForestBKSkip;}}),
Entrance(FOREST_TEMPLE_BOSS_ENTRYWAY, {[]{return false;}}),
});
areaTable[FOREST_TEMPLE_NORTH_CORRIDOR] = Area("Forest Temple North Corridor", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -73,8 +66,7 @@ void AreaTable_Init_ForestTemple() {
EventAccess(&FairyPot, {[]{return true;}}),
}, {
//Locations
LocationAccess(FOREST_TEMPLE_FIRST_STALFOS_CHEST, {[]{return IsAdult || KokiriSword;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(FOREST_TEMPLE_FIRST_STALFOS_CHEST, {[]{return IsAdult || KokiriSword;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_NORTH_CORRIDOR, {[]{return true;}}),
@ -83,29 +75,23 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_NW_OUTDOORS_LOWER] = Area("Forest Temple NW Outdoors Lower", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {
//Locations
LocationAccess(FOREST_TEMPLE_GS_LEVEL_ISLAND_COURTYARD, {[]{return CanUse(LONGSHOT) || Here(FOREST_TEMPLE_NW_OUTDOORS_UPPER, []{return HookshotOrBoomerang;});}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_LOBBY, {[]{return CanPlay(SongOfTime);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::NOVICE) || (SongOfTime && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))));}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_UPPER, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE) || (IsAdult && CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::NOVICE)) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(FOREST_TEMPLE_LOBBY, {[]{return CanPlay(SongOfTime);}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_UPPER, {[]{return false;}}),
Entrance(FOREST_TEMPLE_MAP_ROOM, {[]{return true;}}),
Entrance(FOREST_TEMPLE_SEWER, {[]{return GoldScale || CanUse(IRON_BOOTS) || HasAccessTo(FOREST_TEMPLE_NE_OUTDOORS_UPPER);}}),
Entrance(FOREST_TEMPLE_BOSS_ENTRYWAY, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FOREST_TEMPLE_BOSS_ENTRYWAY, {[]{return false;}}),
});
areaTable[FOREST_TEMPLE_NW_OUTDOORS_UPPER] = Area("Forest Temple NW Outdoors Upper", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {}, {
//Exits
Entrance(FOREST_TEMPLE_NW_OUTDOORS_LOWER, {[]{return true;}}),
@ -117,32 +103,28 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_NE_OUTDOORS_LOWER] = Area("Forest Temple NE Outdoors Lower", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {
//Locations
LocationAccess(FOREST_TEMPLE_RAISED_ISLAND_COURTYARD_CHEST, {[]{return CanUse(HOOKSHOT) || HasAccessTo(FOREST_TEMPLE_FALLING_ROOM);}}),
LocationAccess(FOREST_TEMPLE_RAISED_ISLAND_COURTYARD_CHEST, {[]{return CanUse(HOOKSHOT) || HasAccessTo(FOREST_TEMPLE_FALLING_ROOM) || (HasAccessTo(FOREST_TEMPLE_NE_OUTDOORS_UPPER) && IsAdult && LogicForestOutdoorsLedge && HoverBoots);}}),
LocationAccess(FOREST_TEMPLE_GS_RAISED_ISLAND_COURTYARD, {[]{return CanUse(HOOKSHOT) || (LogicForestOutdoorEastGS && CanUse(BOOMERANG)) || Here(FOREST_TEMPLE_FALLING_ROOM, []{return CanUse(BOW) || CanUse(SLINGSHOT) || CanUse(DINS_FIRE) || HasExplosives;});}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_LOBBY, {[]{return true;}}),
Entrance(FOREST_TEMPLE_NE_OUTDOORS_UPPER, {[]{return CanUse(LONGSHOT);}}),
Entrance(FOREST_TEMPLE_NE_OUTDOORS_UPPER, {[]{return CanUse(LONGSHOT) || (LogicForestVines && CanUse(HOOKSHOT));}}),
Entrance(FOREST_TEMPLE_SEWER, {[]{return GoldScale || CanUse(IRON_BOOTS) || HasAccessTo(FOREST_TEMPLE_NE_OUTDOORS_UPPER);}}),
Entrance(FOREST_TEMPLE_FALLING_ROOM, {[]{return false;},
/*Glitched*/[]{return Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FOREST_TEMPLE_FALLING_ROOM, {[]{return false;}}),
});
areaTable[FOREST_TEMPLE_NE_OUTDOORS_UPPER] = Area("Forest Temple NE Outdoors Upper", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DekuBabaSticks, {[]{return DekuBabaSticks || (IsAdult || KokiriSword || Boomerang);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
EventAccess(&DekuBabaNuts, {[]{return DekuBabaNuts || (IsAdult || KokiriSword || Slingshot || Sticks || HasExplosives || CanUse(DINS_FIRE));}}),
}, {}, {
//Exits
Entrance(FOREST_TEMPLE_NE_OUTDOORS_LOWER, {[]{return true;}}),
Entrance(FOREST_TEMPLE_MAP_ROOM, {[]{return true;}}),
Entrance(FOREST_TEMPLE_FALLING_ROOM, {[]{return LogicForestDoorFrame && CanUse(HOVER_BOOTS) && CanUse(SCARECROW);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::EXPERT);}}),
Entrance(FOREST_TEMPLE_FALLING_ROOM, {[]{return LogicForestDoorFrame && CanUse(HOVER_BOOTS) && CanUse(SCARECROW);}}),
});
areaTable[FOREST_TEMPLE_MAP_ROOM] = Area("Forest Temple Map Room", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -170,8 +152,7 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_FLOORMASTER_ROOM] = Area("Forest Temple Floormaster Room", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FOREST_TEMPLE_FLOORMASTER_CHEST, {[]{return IsAdult || CanChildDamage;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(FOREST_TEMPLE_FLOORMASTER_CHEST, {[]{return IsAdult || CanChildDamage;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_NW_OUTDOORS_UPPER, {[]{return true;}}),
@ -180,25 +161,18 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_WEST_CORRIDOR] = Area("Forest Temple West Corridor", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FOREST_TEMPLE_LOBBY, {[]{return SmallKeys(FOREST_TEMPLE, 1, 5);}}),
Entrance(FOREST_TEMPLE_BLOCK_PUSH_ROOM, {[]{return IsAdult || CanChildAttack || Nuts;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_BLOCK_PUSH_ROOM, {[]{return IsAdult || CanChildAttack || Nuts;}}),
});
areaTable[FOREST_TEMPLE_BLOCK_PUSH_ROOM] = Area("Forest Temple Block Push Room", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FOREST_TEMPLE_EYE_SWITCH_CHEST, {[]{return GoronBracelet && (CanUse(BOW) || CanUse(SLINGSHOT));},
/*Glitched*/[]{return IsAdult && (CanUse(BOW) || CanUse(SLINGSHOT)) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED);}}),
LocationAccess(FOREST_TEMPLE_EYE_SWITCH_CHEST, {[]{return GoronBracelet && (CanUse(BOW) || CanUse(SLINGSHOT));}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_WEST_CORRIDOR, {[]{return true;}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_UPPER, {[]{return CanUse(HOVER_BOOTS) || (LogicForestOutsideBackdoor && IsAdult && GoronBracelet);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || (Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(FOREST_TEMPLE_NW_CORRIDOR_TWISTED, {[]{return IsAdult && GoronBracelet && SmallKeys(FOREST_TEMPLE, 2);},
/*Glitched*/[]{return ((IsAdult && (Bow || Hookshot || CanUse(SLINGSHOT)) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)) ||
(Bombs && GoronBracelet && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE))) && SmallKeys(FOREST_TEMPLE, 2);}}),
Entrance(FOREST_TEMPLE_NW_CORRIDOR_STRAIGHTENED, {[]{return CanUse(BOW) && GoronBracelet && SmallKeys(FOREST_TEMPLE, 2);},
/*Glitched*/[]{return ((IsAdult && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)) ||
(IsChild && Bombs && GoronBracelet && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE))) && (CanUse(BOW) || CanUse(SLINGSHOT)) && SmallKeys(FOREST_TEMPLE, 2);}}),
Entrance(FOREST_TEMPLE_NW_OUTDOORS_UPPER, {[]{return CanUse(HOVER_BOOTS) || (LogicForestOutsideBackdoor && CanJumpslash && GoronBracelet);}}),
Entrance(FOREST_TEMPLE_NW_CORRIDOR_TWISTED, {[]{return IsAdult && GoronBracelet && SmallKeys(FOREST_TEMPLE, 2);}}),
Entrance(FOREST_TEMPLE_NW_CORRIDOR_STRAIGHTENED, {[]{return CanUse(BOW) && GoronBracelet && SmallKeys(FOREST_TEMPLE, 2);}}),
});
areaTable[FOREST_TEMPLE_NW_CORRIDOR_TWISTED] = Area("Forest Temple NW Corridor Twisted", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -230,14 +204,11 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_UPPER_STALFOS] = Area("Forest Temple Upper Stalfos", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FOREST_TEMPLE_BOW_CHEST, {[]{return IsAdult || KokiriSword;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
LocationAccess(FOREST_TEMPLE_BOW_CHEST, {[]{return IsAdult || KokiriSword;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_RED_POE_ROOM, {[]{return IsAdult || KokiriSword;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_BLUE_POE_ROOM, {[]{return IsAdult || KokiriSword;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_RED_POE_ROOM, {[]{return IsAdult || KokiriSword;}}),
Entrance(FOREST_TEMPLE_BLUE_POE_ROOM, {[]{return IsAdult || KokiriSword;}}),
});
areaTable[FOREST_TEMPLE_BLUE_POE_ROOM] = Area("Forest Temple Blue Poe Room", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {
@ -290,17 +261,14 @@ void AreaTable_Init_ForestTemple() {
areaTable[FOREST_TEMPLE_EAST_CORRIDOR] = Area("Forest Temple East Corridor", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(FOREST_TEMPLE_LOBBY, {[]{return IsAdult || CanChildAttack || Nuts;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_GREEN_POE_ROOM, {[]{return IsAdult || CanChildAttack || Nuts;},
/*Glitched*/[]{return CanUse(MEGATON_HAMMER);}}),
Entrance(FOREST_TEMPLE_LOBBY, {[]{return IsAdult || CanChildAttack || Nuts;}}),
Entrance(FOREST_TEMPLE_GREEN_POE_ROOM, {[]{return IsAdult || CanChildAttack || Nuts;}}),
});
areaTable[FOREST_TEMPLE_BOSS_REGION] = Area("Forest Temple Boss Region", "Forest Temple", FOREST_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(FOREST_TEMPLE_BASEMENT_CHEST, {[]{return true;}}),
LocationAccess(FOREST_TEMPLE_GS_BASEMENT, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(FOREST_TEMPLE_GS_BASEMENT, {[]{return HookshotOrBoomerang;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_LOBBY, {[]{return true;}}),
@ -333,10 +301,10 @@ void AreaTable_Init_ForestTemple() {
//Exits
Entrance(FOREST_TEMPLE_MQ_NW_OUTDOORS, {[]{return (IsAdult && CanUse(BOW)) || (IsChild && CanUse(SLINGSHOT));}}),
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS, {[]{return (IsAdult && CanUse(BOW)) || (IsChild && CanUse(SLINGSHOT));}}), //This is as far as child can get
Entrance(FOREST_TEMPLE_MQ_AFTER_BLOCK_PUZZLE, {[]{return IsAdult && GoronBracelet;}}),
Entrance(FOREST_TEMPLE_MQ_AFTER_BLOCK_PUZZLE, {[]{return IsAdult && (GoronBracelet || (LogicForestMQBlockPuzzle && HasBombchus && IsAdult && CanUse(HOOKSHOT)));}}),
//Trick: IsAdult && (GoronBracelet || (LogicForestMQBlockPuzzle && HasBombchus && IsAdult && CanUse(HOOKSHOT)))
Entrance(FOREST_TEMPLE_MQ_OUTDOOR_LEDGE, {[]{return false;}}),
//Trick: (LogicForestMQHallwaySwitchJumpslash && IsAdult && CanUse(HOVER_BOOTS)) || (LogicForestMQHallwaySwitchHookshot && IsAdult && CanUse(HOOKSHOT))
Entrance(FOREST_TEMPLE_MQ_OUTDOOR_LEDGE, {[]{return (LogicForestMQHallwaySwitchJS && IsAdult && CanUse(HOVER_BOOTS)) || (LogicForestMQHallwaySwitchBoomerang && CanUse(BOOMERANG)) || (LogicForestMQHallwaySwitchHookshot && IsAdult && CanUse(HOOKSHOT));}}),
//Trick (Hookshot trick not added to either n64 or oot3d rando as of yet, to enable in SoH needs uncommenting in randomizer_tricks.cpp): (LogicForestMQHallwaySwitchJS && IsAdult && CanUse(HOVER_BOOTS)) || (LogicForestMQHallwaySwitchHookshot && IsAdult && CanUse(HOOKSHOT))
Entrance(FOREST_TEMPLE_MQ_BOSS_REGION, {[]{return ForestTempleJoAndBeth && ForestTempleAmyAndMeg;}}),
});
@ -346,8 +314,8 @@ void AreaTable_Init_ForestTemple() {
}, {
//Exits
Entrance(FOREST_TEMPLE_MQ_BOW_REGION, {[]{return SmallKeys(FOREST_TEMPLE, 4);}}),
Entrance(FOREST_TEMPLE_MQ_OUTDOOR_LEDGE, {[]{return SmallKeys(FOREST_TEMPLE, 3);}}),
//Trick: SmallKeys(FOREST_TEMPLE, 3) || (LogicForestMQHallwaySwitchJumpslash && ((IsAdult && CanUse(HOOKSHOT)) || LogicForestOutsideBackdoor))
Entrance(FOREST_TEMPLE_MQ_OUTDOOR_LEDGE, {[]{return SmallKeys(FOREST_TEMPLE, 3) || (LogicForestMQHallwaySwitchJS && ((IsAdult && CanUse(HOOKSHOT)) || (LogicForestOutsideBackdoor && (IsAdult || (IsChild && CanUse(STICKS))))));}}),
//Trick (Doing the hallway switch jumpslash as child requires sticks and has been added above): SmallKeys(FOREST_TEMPLE, 3) || (LogicForestMQHallwaySwitchJS && ((IsAdult && CanUse(HOOKSHOT)) || LogicForestOutsideBackdoor))
Entrance(FOREST_TEMPLE_MQ_NW_OUTDOORS, {[]{return SmallKeys(FOREST_TEMPLE, 2);}}),
});
@ -364,7 +332,7 @@ void AreaTable_Init_ForestTemple() {
LocationAccess(FOREST_TEMPLE_MQ_GS_LEVEL_ISLAND_COURTYARD, {[]{return true;}}),
}, {
//Exits
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS, {[]{return (IsAdult && (CanUse(IRON_BOOTS) || CanUse(LONGSHOT))) || ProgressiveScale >= 2;}}),
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS, {[]{return (IsAdult && (CanUse(IRON_BOOTS) || CanUse(LONGSHOT) || (LogicForestMQWellSwim && CanUse(HOOKSHOT)))) || ProgressiveScale >= 2;}}),
//Trick: (IsAdult && (CanUse(IRON_BOOTS) || CanUse(LONGSHOT) || (LogicForestMQWellSwim && CanUse(HOOKSHOT)))) || ProgressiveScale >= 2
Entrance(FOREST_TEMPLE_MQ_OUTDOORS_TOP_LEDGES, {[]{return IsAdult && CanUse(FIRE_ARROWS);}}),
});
@ -390,7 +358,7 @@ void AreaTable_Init_ForestTemple() {
}, {
//Exits
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS, {[]{return true;}}),
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS_LEDGE, {[]{return false;}}),
Entrance(FOREST_TEMPLE_MQ_NE_OUTDOORS_LEDGE, {[]{return LogicForestOutdoorsLedge && IsAdult && CanUse(HOVER_BOOTS);}}),
//Trick: LogicForestOutdoorsLedge && IsAdult && CanUse(HOVER_BOOTS)
});

12
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_ganons_castle.cpp
View File

@ -163,7 +163,7 @@ void AreaTable_Init_GanonsCastle() {
areaTable[GANONS_CASTLE_MQ_FIRE_TRIAL] = Area("Ganon's Castle MQ Fire Trial", "Ganons Castle", GANONS_CASTLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&FireTrialClear, {[]{return CanUse(GORON_TUNIC) && CanUse(GOLDEN_GAUNTLETS) && CanUse(LIGHT_ARROWS) && (CanUse(LONGSHOT) || CanUse(HOVER_BOOTS));}}),
EventAccess(&FireTrialClear, {[]{return CanUse(GORON_TUNIC) && CanUse(GOLDEN_GAUNTLETS) && CanUse(LIGHT_ARROWS) && (CanUse(LONGSHOT) || HoverBoots || (LogicFireTrialMQ && CanUse(HOOKSHOT)));}}),
//Trick: CanUse(GORON_TUNIC) && CanUse(GOLDEN_GAUNTLETS) && CanUse(LIGHT_ARROWS) && (CanUse(LONGSHOT) || HoverBoots || (LogicFireTrialMQ && CanUse(HOOKSHOT)))
}, {}, {});
@ -178,12 +178,12 @@ void AreaTable_Init_GanonsCastle() {
areaTable[GANONS_CASTLE_MQ_SHADOW_TRIAL] = Area("Ganon's Castle MQ Shadow Trial", "Ganons Castle", GANONS_CASTLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&ShadowTrialClear, {[]{return IsAdult && CanUse(LIGHT_ARROWS) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || (CanUse(HOOKSHOT) && HasFireSource));}}),
EventAccess(&ShadowTrialClear, {[]{return IsAdult && CanUse(LIGHT_ARROWS) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (HoverBoots || (Hookshot && (HasFireSource || LogicShadowTrialMQ)));}}),
//Trick: IsAdult && CanUse(LIGHT_ARROWS) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (HoverBoots || (Hookshot && (HasFireSource || LogicShadowTrialMQ)))
}, {
//Locations
LocationAccess(GANONS_CASTLE_MQ_SHADOW_TRIAL_BOMB_FLOWER_CHEST, {[]{return IsAdult && ((Bow && (CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS))) || (CanUse(HOVER_BOOTS) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (HasExplosives || GoronBracelet || CanUse(DINS_FIRE))));}}),
LocationAccess(GANONS_CASTLE_MQ_SHADOW_TRIAL_EYE_SWITCH_CHEST, {[]{return IsAdult && Bow && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || (CanUse(HOOKSHOT) && HasFireSource));}}),
LocationAccess(GANONS_CASTLE_MQ_SHADOW_TRIAL_EYE_SWITCH_CHEST, {[]{return IsAdult && Bow && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (HoverBoots || (Hookshot && (HasFireSource || LogicShadowTrialMQ)));}}),
//Trick: IsAdult && Bow && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (HoverBoots || (Hookshot && (HasFireSource || LogicShadowTrialMQ)))
}, {});
@ -193,8 +193,8 @@ void AreaTable_Init_GanonsCastle() {
EventAccess(&NutPot, {[]{return NutPot || (Hammer && HasBombchus && IsAdult && ((CanUse(FIRE_ARROWS) && MirrorShield) || (SunlightArrows && CanUse(LIGHT_ARROWS))));}}),
}, {
//Locations
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_FIRST_CHEST, {[]{return IsAdult && Bow && Hammer;}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_INVISIBLE_CHEST, {[]{return IsAdult && Bow && Hammer && HasBombchus && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_FIRST_CHEST, {[]{return IsAdult && (Bow || LogicRustedSwitches) && Hammer;}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_INVISIBLE_CHEST, {[]{return IsAdult && (Bow || LogicRustedSwitches) && Hammer && HasBombchus && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_SUN_FRONT_LEFT_CHEST, {[]{return IsAdult && Hammer && HasBombchus && ((CanUse(FIRE_ARROWS) && CanUse(MIRROR_SHIELD)) || (SunlightArrows && CanUse(LIGHT_ARROWS)));}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_SUN_BACK_LEFT_CHEST, {[]{return IsAdult && Hammer && HasBombchus && ((CanUse(FIRE_ARROWS) && CanUse(MIRROR_SHIELD)) || (SunlightArrows && CanUse(LIGHT_ARROWS)));}}),
LocationAccess(GANONS_CASTLE_MQ_SPIRIT_TRIAL_GOLDEN_GAUNTLETS_CHEST, {[]{return IsAdult && Hammer && HasBombchus && ((CanUse(FIRE_ARROWS) && CanUse(MIRROR_SHIELD)) || (SunlightArrows && CanUse(LIGHT_ARROWS)));}}),
@ -203,7 +203,7 @@ void AreaTable_Init_GanonsCastle() {
areaTable[GANONS_CASTLE_MQ_LIGHT_TRIAL] = Area("Ganon's Castle MQ Light Trial", "Ganons Castle", GANONS_CASTLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&LightTrialClear, {[]{return IsAdult && CanUse(LIGHT_ARROWS) && SmallKeys(GANONS_CASTLE, 3) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && CanUse(HOOKSHOT);}}),
EventAccess(&LightTrialClear, {[]{return IsAdult && CanUse(LIGHT_ARROWS) && SmallKeys(GANONS_CASTLE, 3) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (Hookshot || LogicLightTrialMQ);}}),
//Trick: IsAdult && CanUse(LIGHT_ARROWS) && SmallKeys(GANONS_CASTLE, 3) && (LogicLensCastleMQ || CanUse(LENS_OF_TRUTH)) && (Hookshot || LogicLightTrialMQ)
}, {
//Locations

22
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_gerudo_training_grounds.cpp
View File

@ -37,20 +37,14 @@ void AreaTable_Init_GerudoTrainingGrounds() {
areaTable[GERUDO_TRAINING_GROUNDS_CENTRAL_MAZE] = Area("Gerudo Training Grounds Central Maze", "Gerudo Training Grounds", GERUDO_TRAINING_GROUNDS, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(GERUDO_TRAINING_GROUNDS_HIDDEN_CEILING_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 3) && (LogicLensGtg || CanUse(LENS_OF_TRUTH));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE) && (LogicLensGtg || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_FIRST_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 4);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_SECOND_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 6);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_THIRD_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 7);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_FINAL_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 9);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_HIDDEN_CEILING_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 3) && (LogicLensGtg || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_FIRST_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 4);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_SECOND_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 6);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_THIRD_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 7);}}),
LocationAccess(GERUDO_TRAINING_GROUNDS_MAZE_PATH_FINAL_CHEST, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 9);}}),
}, {
//Exits
Entrance(GERUDO_TRAINING_GROUNDS_CENTRAL_MAZE_RIGHT, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 9);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
Entrance(GERUDO_TRAINING_GROUNDS_CENTRAL_MAZE_RIGHT, {[]{return SmallKeys(GERUDO_TRAINING_GROUNDS, 9);}}),
});
areaTable[GERUDO_TRAINING_GROUNDS_CENTRAL_MAZE_RIGHT] = Area("Gerudo Training Grounds Central Maze Right", "Gerudo Training Grounds", GERUDO_TRAINING_GROUNDS, NO_DAY_NIGHT_CYCLE, {}, {
@ -157,7 +151,7 @@ void AreaTable_Init_GerudoTrainingGrounds() {
LocationAccess(GERUDO_TRAINING_GROUNDS_MQ_FIRST_IRON_KNUCKLE_CHEST, {[]{return IsAdult || KokiriSword || HasExplosives;}}),
}, {
//Exits
Entrance(GERUDO_TRAINING_GROUNDS_MQ_STALFOS_ROOM, {[]{return IsAdult && CanUse(LONGSHOT);}}),
Entrance(GERUDO_TRAINING_GROUNDS_MQ_STALFOS_ROOM, {[]{return (IsAdult && CanUse(LONGSHOT)) || LogicGtgMQWithoutHookshot || (LogicGtgMQWithHookshot && IsAdult && CanUse(HOOKSHOT));}}),
//Trick: (IsAdult && CanUse(LONGSHOT)) || LogicGtgMQWithoutHookshot || (LogicGtgMQWithHookshot && IsAdult && CanUse(HOOKSHOT))
});
@ -170,7 +164,7 @@ void AreaTable_Init_GerudoTrainingGrounds() {
LocationAccess(GERUDO_TRAINING_GROUNDS_MQ_HEAVY_BLOCK_CHEST, {[]{return CanUse(SILVER_GAUNTLETS);}}),
}, {
//Exits
Entrance(GERUDO_TRAINING_GROUNDS_MQ_BACK_AREAS, {[]{return IsAdult && (LogicLensGtgMQ || CanUse(LENS_OF_TRUTH)) && BlueFire && CanPlay(SongOfTime);}}),
Entrance(GERUDO_TRAINING_GROUNDS_MQ_BACK_AREAS, {[]{return IsAdult && (LogicLensGtgMQ || CanUse(LENS_OF_TRUTH)) && BlueFire && (CanPlay(SongOfTime) || (LogicGtgFakeWall && IsAdult && CanUse(HOVER_BOOTS)));}}),
//Trick: IsAdult && (LogicLensGtgMQ || CanUse(LENS_OF_TRUTH)) && BlueFire && (CanPlay(SongOfTime) || (LogicGtgFakeWall && IsAdult && CanUse(HOVER_BOOTS)))
});

90
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_gerudo_valley.cpp
View File

@ -11,17 +11,14 @@ void AreaTable_Init_GerudoValley() {
EventAccess(&BugRock, {[]{return BugRock || IsChild;}}),
}, {
//Locations
LocationAccess(GV_GS_SMALL_BRIDGE, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return IsChild && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GV_GS_SMALL_BRIDGE, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(HYRULE_FIELD, {[]{return true;}}),
Entrance(GV_UPPER_STREAM, {[]{return true;}}),
Entrance(GV_CRATE_LEDGE, {[]{return IsChild || CanUse(LONGSHOT);}}),
Entrance(GV_GROTTO_LEDGE, {[]{return true;}}),
Entrance(GV_FORTRESS_SIDE, {[]{return (IsAdult && (CanRideEpona || CanUse(LONGSHOT) || GerudoFortress.Is(GERUDOFORTRESS_OPEN) || CarpenterRescue)) || (IsChild && CanUse(HOOKSHOT));},
/*Glitched*/[]{return (HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || (IsChild && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::HERO)) || (IsAdult && (CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED) ||
(CanUse(HOVER_BOOTS) && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE) || (CanSurviveDamage && (Bombs || HasBombchus) && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::NOVICE)) || (Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED))))));}}),
Entrance(GV_FORTRESS_SIDE, {[]{return (IsAdult && (CanRideEpona || CanUse(LONGSHOT) || GerudoFortress.Is(GERUDOFORTRESS_OPEN) || CarpenterRescue)) || (IsChild && CanUse(HOOKSHOT));}}),
});
areaTable[GV_UPPER_STREAM] = Area("GV Upper Stream", "Gerudo Valley", GERUDO_VALLEY, DAY_NIGHT_CYCLE, {
@ -32,8 +29,7 @@ void AreaTable_Init_GerudoValley() {
//Locations
LocationAccess(GV_WATERFALL_FREESTANDING_POH, {[]{return true;}}),
LocationAccess(GV_GS_BEAN_PATCH, {[]{return CanPlantBugs && CanChildAttack;}}),
LocationAccess(GV_COW, {[]{return IsChild && CanPlay(EponasSong);},
/*Glitched*/[]{return IsChild && EponasSong && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)));}}),
LocationAccess(GV_COW, {[]{return IsChild && CanPlay(EponasSong);}}),
LocationAccess(GV_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
@ -64,24 +60,19 @@ void AreaTable_Init_GerudoValley() {
//Events
EventAccess(&BrokenSwordAccess, {[]{return IsAdult && (PoachersSawAccess || PoachersSaw);}}),
}, {
//Locations
LocationAccess(GV_CHEST, {[]{return IsAdult && (CanUse(MEGATON_HAMMER) || LogicGVHammerChest);},
/*Glitched*/[]{return IsAdult && (CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE) && (CanTakeDamageTwice || CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED))));}}),
//Locations
LocationAccess(GV_CHEST, {[]{return IsAdult && CanUse(MEGATON_HAMMER);}}),
LocationAccess(GV_TRADE_SAW, {[]{return IsAdult && PoachersSaw;}}),
LocationAccess(GV_GS_BEHIND_TENT, {[]{return IsAdult && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && IsAdult && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GV_GS_BEHIND_TENT, {[]{return IsAdult && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GV_GS_PILLAR, {[]{return IsAdult && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(GERUDO_FORTRESS, {[]{return true;}}),
Entrance(GV_UPPER_STREAM, {[]{return true;}}),
Entrance(GERUDO_VALLEY, {[]{return IsChild || CanRideEpona || CanUse(LONGSHOT) || GerudoFortress.Is(GERUDOFORTRESS_OPEN) || CarpenterRescue;},
/*Glitched*/[]{return (HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED) ||
(CanUse(HOVER_BOOTS) && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE) || (CanSurviveDamage && (Bombs || HasBombchus) && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::NOVICE)) || (Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED))));}}),
Entrance(GV_CARPENTER_TENT, {[]{return IsAdult;},
/*Glitched*/[]{return GlitchGVTentAsChild.Value<bool>();}}),
Entrance(GV_STORMS_GROTTO, {[]{return IsAdult && CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsAdult && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(GERUDO_VALLEY, {[]{return IsChild || CanRideEpona || CanUse(LONGSHOT) || GerudoFortress.Is(GERUDOFORTRESS_OPEN) || CarpenterRescue;}}),
Entrance(GV_CARPENTER_TENT, {[]{return IsAdult;}}),
Entrance(GV_STORMS_GROTTO, {[]{return IsAdult && CanOpenStormGrotto;}}),
Entrance(GV_CRATE_LEDGE, {[]{return false;}}),
});
areaTable[GV_CARPENTER_TENT] = Area("GV Carpenter Tent", "GV Carpenter Tent", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -110,33 +101,22 @@ void AreaTable_Init_GerudoValley() {
EventAccess(&GtG_GateOpen, {[]{return GtG_GateOpen || (IsAdult && GerudoToken);}}),
}, {
//Locations
LocationAccess(GF_CHEST, {[]{return CanUse(HOVER_BOOTS) || (IsAdult && CanUse(SCARECROW)) || CanUse(LONGSHOT);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE))) && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen);}}),
LocationAccess(GF_CHEST, {[]{return CanUse(HOVER_BOOTS) || (IsAdult && CanUse(SCARECROW)) || CanUse(LONGSHOT);}}),
LocationAccess(GF_HBA_1000_POINTS, {[]{return GerudoToken && CanRideEpona && Bow && AtDay;}}),
LocationAccess(GF_HBA_1500_POINTS, {[]{return GerudoToken && CanRideEpona && Bow && AtDay;}}),
LocationAccess(GF_NORTH_F1_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE);}}),
LocationAccess(GF_NORTH_F2_CARPENTER, {[]{return (IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD)) && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen);}}),
LocationAccess(GF_SOUTH_F1_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE);}}),
LocationAccess(GF_SOUTH_F2_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE);}}),
LocationAccess(GF_NORTH_F1_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);}}),
LocationAccess(GF_NORTH_F2_CARPENTER, {[]{return (IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD)) && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen);}}),
LocationAccess(GF_SOUTH_F1_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);}}),
LocationAccess(GF_SOUTH_F2_CARPENTER, {[]{return IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD);}}),
LocationAccess(GF_GERUDO_MEMBERSHIP_CARD, {[]{return CanFinishGerudoFortress;}}),
LocationAccess(GF_GS_ARCHERY_RANGE, {[]{return IsAdult && HookshotOrBoomerang && GerudoToken && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return IsAdult && HookshotOrBoomerang && GlitchGFGuardSneak && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GF_GS_TOP_FLOOR, {[]{return IsAdult && AtNight && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen) && CanGetNightTimeGS;}}),
LocationAccess(GF_GS_ARCHERY_RANGE, {[]{return IsAdult && HookshotOrBoomerang && GerudoToken && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GF_GS_TOP_FLOOR, {[]{return IsAdult && AtNight && (GerudoToken || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(HOVER_BOOTS) || LogicGerudoKitchen || LogicGFJump) && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(GV_FORTRESS_SIDE, {[]{return true;}}),
Entrance(GF_OUTSIDE_GATE, {[]{return GF_GateOpen;},
/*Glitched*/[]{return (IsChild && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::ADVANCED)) || ((IsChild || ((CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(BOOMERANG)) && GlitchGFGuardSneak)) && ((CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::NOVICE)) ||
CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::INTERMEDIATE)) && (CanUse(STICKS) || (BiggoronSword && IsAdult) || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE)));}}),
Entrance(GERUDO_TRAINING_GROUNDS_ENTRYWAY, {[]{return GtG_GateOpen && (IsAdult || ShuffleDungeonEntrances);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE) && (HoverBoots || CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::ADVANCED))) || ((IsChild || ((CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(BOOMERANG)) && GlitchGFGuardSneak)) && ((CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) &&
CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::INTERMEDIATE)) && (CanUse(STICKS) || (BiggoronSword && IsAdult) || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE)));}}),
Entrance(GF_STORMS_GROTTO, {[]{return IsAdult && CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsAdult && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(GF_OUTSIDE_GATE, {[]{return GF_GateOpen;}}),
Entrance(GERUDO_TRAINING_GROUNDS_ENTRYWAY, {[]{return GtG_GateOpen && (IsAdult || ShuffleDungeonEntrances);}}),
Entrance(GF_STORMS_GROTTO, {[]{return IsAdult && CanOpenStormGrotto;}}),
});
areaTable[GF_OUTSIDE_GATE] = Area("GF Outside Gate", "Gerudo Fortress", NONE, NO_DAY_NIGHT_CYCLE, {
@ -159,9 +139,7 @@ void AreaTable_Init_GerudoValley() {
areaTable[WASTELAND_NEAR_FORTRESS] = Area("Wasteland Near Fortress", "Haunted Wasteland", HAUNTED_WASTELAND, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(GF_OUTSIDE_GATE, {[]{return true;}}),
Entrance(HAUNTED_WASTELAND, {[]{return CanUse(HOVER_BOOTS) || CanUse(LONGSHOT);},
/*Glitched*/[]{return ((Bombs || HasBombchus) && CanSurviveDamage && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::NOVICE)) || (CanUse(MEGATON_HAMMER) && CanShield && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::INTERMEDIATE)) ||
(Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED)) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)) || GlitchItemlessWasteland;}}),
Entrance(HAUNTED_WASTELAND, {[]{return CanUse(HOVER_BOOTS) || CanUse(LONGSHOT) || LogicWastelandCrossing;}}),
});
areaTable[HAUNTED_WASTELAND] = Area("Haunted Wasteland", "Haunted Wasteland", HAUNTED_WASTELAND, NO_DAY_NIGHT_CYCLE, {
@ -170,18 +148,13 @@ void AreaTable_Init_GerudoValley() {
EventAccess(&NutPot, {[]{return true;}}),
}, {
//Locations
LocationAccess(WASTELAND_CHEST, {[]{return HasFireSource;},
/*Glitched*/[]{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(WASTELAND_BOMBCHU_SALESMAN, {[]{return AdultsWallet && (IsAdult || Sticks || KokiriSword);},
/*Glitched*/[]{return AdultsWallet && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE);}}),
LocationAccess(WASTELAND_GS, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(WASTELAND_CHEST, {[]{return HasFireSource;}}),
LocationAccess(WASTELAND_BOMBCHU_SALESMAN, {[]{return AdultsWallet && (IsAdult || Sticks || KokiriSword);}}),
LocationAccess(WASTELAND_GS, {[]{return HookshotOrBoomerang;}}),
}, {
//Exits
Entrance(WASTELAND_NEAR_COLOSSUS, {[]{return LogicLensWasteland || CanUse(LENS_OF_TRUTH);}}),
Entrance(WASTELAND_NEAR_FORTRESS, {[]{return CanUse(HOVER_BOOTS) || CanUse(LONGSHOT);},
/*Glitched*/[]{return ((Bombs || HasBombchus) && CanSurviveDamage && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::NOVICE)) || (CanUse(MEGATON_HAMMER) && CanShield && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::INTERMEDIATE)) ||
(Bombs && CanDoGlitch(GlitchType::SuperSlide, GlitchDifficulty::ADVANCED)) || (HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE)) || GlitchItemlessWasteland;}}),
Entrance(WASTELAND_NEAR_FORTRESS, {[]{return CanUse(HOVER_BOOTS) || CanUse(LONGSHOT) || LogicWastelandCrossing;}}),
});
areaTable[WASTELAND_NEAR_COLOSSUS] = Area("Wasteland Near Colossus", "Haunted Wasteland", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -192,18 +165,14 @@ void AreaTable_Init_GerudoValley() {
areaTable[DESERT_COLOSSUS] = Area("Desert Colossus", "Desert Colossus", DESERT_COLOSSUS, DAY_NIGHT_CYCLE, {
//Events
EventAccess(&FairyPond, {[]{return FairyPond || CanPlay(SongOfStorms);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && Bombs && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms;}}),
EventAccess(&FairyPond, {[]{return FairyPond || CanPlay(SongOfStorms);}}),
EventAccess(&BugRock, {[]{return true;}}),
}, {
//Locations
LocationAccess(COLOSSUS_FREESTANDING_POH, {[]{return IsAdult && CanPlantBean(DESERT_COLOSSUS);},
/*Glitched*/[]{return (HoverBoots && CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED)) || (((IsChild && (ChildCanAccess(SPIRIT_TEMPLE_OUTDOOR_HANDS) || ChildCanAccess(SPIRIT_TEMPLE_MQ_SILVER_GAUNTLETS_HAND) || ChildCanAccess(SPIRIT_TEMPLE_MQ_MIRROR_SHIELD_HAND))) ||
(IsAdult && (AdultCanAccess(SPIRIT_TEMPLE_OUTDOOR_HANDS) || AdultCanAccess(SPIRIT_TEMPLE_MQ_SILVER_GAUNTLETS_HAND) || AdultCanAccess(SPIRIT_TEMPLE_MQ_MIRROR_SHIELD_HAND)))) && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::ADVANCED) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE)));}}),
LocationAccess(COLOSSUS_FREESTANDING_POH, {[]{return IsAdult && CanPlantBean(DESERT_COLOSSUS);}}),
LocationAccess(COLOSSUS_GS_BEAN_PATCH, {[]{return CanPlantBugs && CanChildAttack;}}),
LocationAccess(COLOSSUS_GS_TREE, {[]{return IsAdult && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(COLOSSUS_GS_HILL, {[]{return IsAdult && AtNight && (CanPlantBean(DESERT_COLOSSUS) || CanUse(LONGSHOT) || (LogicColossusGS && CanUse(HOOKSHOT))) && CanGetNightTimeGS;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::EXPERT) && CanShield && IsAdult && AtNight && CanGetNightTimeGS;}}),
LocationAccess(COLOSSUS_GS_HILL, {[]{return IsAdult && AtNight && (CanPlantBean(DESERT_COLOSSUS) || CanUse(LONGSHOT) || (LogicColossusGS && CanUse(HOOKSHOT))) && CanGetNightTimeGS;}}),
LocationAccess(COLOSSUS_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
@ -223,8 +192,7 @@ void AreaTable_Init_GerudoValley() {
areaTable[COLOSSUS_GREAT_FAIRY_FOUNTAIN] = Area("Colossus Great Fairy Fountain", "Colossus Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(COLOSSUS_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && Bombs && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(COLOSSUS_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(DESERT_COLOSSUS, {[]{return true;}}),

83
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_hyrule_field.cpp
View File

@ -22,21 +22,14 @@ void AreaTable_Init_HyruleField() {
Entrance(KAKARIKO_VILLAGE, {[]{return true;}}),
Entrance(ZR_FRONT, {[]{return true;}}),
Entrance(LON_LON_RANCH, {[]{return true;}}),
Entrance(HF_SOUTHEAST_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(HYRULE_FIELD, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(HF_SOUTHEAST_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});}}),
Entrance(HF_OPEN_GROTTO, {[]{return true;}}),
Entrance(HF_INSIDE_FENCE_GROTTO, {[]{return CanOpenBombGrotto;},
/*Glitched*/[]{return Sticks && IsChild && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(HF_COW_GROTTO, {[]{return (CanUse(MEGATON_HAMMER) || IsChild) && CanOpenBombGrotto;},
/*Glitched*/[]{return (CanUse(STICKS) && (ShardOfAgony || LogicGrottosWithoutAgony) && (IsChild || (CanOpenBombGrotto && (CanTakeDamageTwice || CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)))) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE));}}),
Entrance(HF_NEAR_MARKET_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(HYRULE_FIELD, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(HF_FAIRY_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(HYRULE_FIELD, []{return CanUse(STICKS) && ((IsChild && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::EXPERT)) || (IsAdult && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)));});}}),
Entrance(HF_NEAR_KAK_GROTTO, {[]{return CanOpenBombGrotto;},
/*Glitched*/[]{return Sticks && IsChild && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(HF_TEKTITE_GROTTO, {[]{return CanOpenBombGrotto;},
/*Glitched*/[]{return Sticks && IsChild && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(HF_INSIDE_FENCE_GROTTO, {[]{return CanOpenBombGrotto;}}),
Entrance(HF_COW_GROTTO, {[]{return (CanUse(MEGATON_HAMMER) || IsChild) && CanOpenBombGrotto;}}),
Entrance(HF_NEAR_MARKET_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});}}),
Entrance(HF_FAIRY_GROTTO, {[]{return Here(HYRULE_FIELD, []{return CanBlastOrSmash;});}}),
Entrance(HF_NEAR_KAK_GROTTO, {[]{return CanOpenBombGrotto;}}),
Entrance(HF_TEKTITE_GROTTO, {[]{return CanOpenBombGrotto;}}),
});
areaTable[HF_SOUTHEAST_GROTTO] = Area("HF Southeast Grotto", "HF Southeast Grotto", NONE, NO_DAY_NIGHT_CYCLE, grottoEvents, {
@ -67,13 +60,9 @@ void AreaTable_Init_HyruleField() {
areaTable[HF_COW_GROTTO] = Area("HF Cow Grotto", "HF Cow Grotto", NONE, NO_DAY_NIGHT_CYCLE, grottoEvents, {
//Locations
LocationAccess(HF_GS_COW_GROTTO, {[]{return HasFireSource && HookshotOrBoomerang;},
/*Glitched*/[]{return (CanUse(STICKS) && Bombs && CanSurviveDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE)) && HookshotOrBoomerang;}}),
LocationAccess(HF_COW_GROTTO_COW, {[]{return HasFireSource && CanPlay(EponasSong);},
/*Glitched*/[]{return ((CanUse(STICKS) && Bombs && CanSurviveDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE)) || HasFireSource) &&
(CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && Bombs && (CanSurviveDamage || (NumBottles >= 2 && Fairy)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)) || Ocarina) && EponasSong;}}),
LocationAccess(HF_COW_GROTTO_GOSSIP_STONE, {[]{return HasFireSource;},
/*Glitched*/[]{return CanUse(STICKS) && Bombs && CanSurviveDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE);}}),
LocationAccess(HF_GS_COW_GROTTO, {[]{return HasFireSource && HookshotOrBoomerang;}}),
LocationAccess(HF_COW_GROTTO_COW, {[]{return HasFireSource && CanPlay(EponasSong);}}),
LocationAccess(HF_COW_GROTTO_GOSSIP_STONE, {[]{return HasFireSource;}}),
}, {
//Exits
Entrance(HYRULE_FIELD, {[]{return true;}}),
@ -118,37 +107,28 @@ void AreaTable_Init_HyruleField() {
EventAccess(&BeanPlantFairy, {[]{return BeanPlantFairy || (CanPlantBean(LAKE_HYLIA) && CanPlay(SongOfStorms));}}),
EventAccess(&ButterflyFairy, {[]{return ButterflyFairy || CanUse(STICKS);}}),
EventAccess(&BugShrub, {[]{return BugShrub || (IsChild && CanCutShrubs);}}),
EventAccess(&ChildScarecrow, {[]{return ChildScarecrow || (IsChild && Ocarina);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && (KokiriSword || Sticks || Bombs || HasBombchus || Boomerang || Slingshot || CanUse(MEGATON_HAMMER)) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE))) && IsChild;}}),
EventAccess(&AdultScarecrow, {[]{return AdultScarecrow || (IsAdult && Ocarina);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE))) && IsAdult;}}),
EventAccess(&ChildScarecrow, {[]{return ChildScarecrow || (IsChild && Ocarina);}}),
EventAccess(&AdultScarecrow, {[]{return AdultScarecrow || (IsAdult && Ocarina);}}),
}, {
//Locations
LocationAccess(LH_UNDERWATER_ITEM, {[]{return IsChild && CanDive;}}),
LocationAccess(LH_SUN, {[]{return IsAdult && WaterTempleClear && CanUse(BOW);}}),
LocationAccess(LH_FREESTANDING_POH, {[]{return IsAdult && (CanUse(SCARECROW) || CanPlantBean(LAKE_HYLIA));},
/*Glitched*/[]{return (IsAdult && CanUse(HOOKSHOT) && ScarecrowSong && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(LH_FREESTANDING_POH, {[]{return IsAdult && (CanUse(SCARECROW) || CanPlantBean(LAKE_HYLIA));}}),
LocationAccess(LH_GS_BEAN_PATCH, {[]{return CanPlantBugs && CanChildAttack;}}),
LocationAccess(LH_GS_LAB_WALL, {[]{return IsChild && (HookshotOrBoomerang || (LogicLabWallGS && (Sticks || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD)))) && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LH_GS_SMALL_ISLAND, {[]{return IsChild && CanChildAttack && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LH_GS_TREE, {[]{return IsAdult && CanUse(LONGSHOT) && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::NOVICE)) && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LH_GS_TREE, {[]{return IsAdult && CanUse(LONGSHOT) && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LH_LAB_GOSSIP_STONE, {[]{return true;}}),
LocationAccess(LH_GOSSIP_STONE_SOUTHEAST, {[]{return true;}}),
LocationAccess(LH_GOSSIP_STONE_SOUTHWEST, {[]{return true;}}),
}, {
//Exits
Entrance(HYRULE_FIELD, {[]{return true;}}),
Entrance(ZORAS_DOMAIN, {[]{return IsChild && (CanDive || CanUse(IRON_BOOTS));},
/*Glitched*/[]{return IsChild && (CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::NaviDive_Stick, GlitchDifficulty::INTERMEDIATE) ||
(Bugs && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) || (CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || (IsAdult && (HasBoots || ClaimCheck)) || (IsChild && WeirdEgg)))) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED)))));}}),
Entrance(ZORAS_DOMAIN, {[]{return IsChild && (CanDive || CanUse(IRON_BOOTS));}}),
Entrance(LH_OWL_FLIGHT, {[]{return IsChild;}}),
Entrance(LH_FISHING_ISLAND, {[]{return IsChild || CanUse(SCARECROW) || CanPlantBean(LAKE_HYLIA) || WaterTempleClear;},
/*Glitched*/[]{return (CanUse(HOOKSHOT) && ScarecrowSong && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::NOVICE)))) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
Entrance(LH_FISHING_ISLAND, {[]{return IsChild || CanUse(SCARECROW) || CanPlantBean(LAKE_HYLIA) || WaterTempleClear;}}),
Entrance(LH_LAB, {[]{return true;}}),
Entrance(WATER_TEMPLE_ENTRYWAY, {[]{return CanUse(HOOKSHOT) && (CanUse(IRON_BOOTS) || (IsAdult && CanUse(LONGSHOT) && ProgressiveScale >= 2));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::ADVANCED);}}),
Entrance(WATER_TEMPLE_ENTRYWAY, {[]{return CanUse(HOOKSHOT) && ((CanUse(IRON_BOOTS) || (LogicWaterHookshotEntry && ProgressiveScale >= 2)) || (IsAdult && CanUse(LONGSHOT) && ProgressiveScale >= 2));}}),
Entrance(LH_GROTTO, {[]{return true;}}),
});
@ -168,15 +148,9 @@ void AreaTable_Init_HyruleField() {
EventAccess(&EyedropsAccess, {[]{return EyedropsAccess || (IsAdult && (EyeballFrogAccess || (EyeballFrog && DisableTradeRevert)));}}),
}, {
//Locations
LocationAccess(LH_LAB_DIVE, {[]{return ProgressiveScale >= 2 || (LogicLabDiving && CanUse(IRON_BOOTS) && CanUse(HOOKSHOT));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) ||
(CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || (IsAdult && (HasBoots || ClaimCheck)) || (IsChild && WeirdEgg)))) && CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE));}}),
LocationAccess(LH_LAB_DIVE, {[]{return ProgressiveScale >= 2 || (LogicLabDiving && CanUse(IRON_BOOTS) && CanUse(HOOKSHOT));}}),
LocationAccess(LH_TRADE_FROG, {[]{return IsAdult && EyeballFrog;}}),
LocationAccess(LH_GS_LAB_CRATE, {[]{return CanUse(IRON_BOOTS) && CanUse(HOOKSHOT);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && HasBombchus && (HasBottle || (IsAdult && (HasBoots || ClaimCheck)) || (IsChild && WeirdEgg)) &&
(CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) ||
(CanUse(FARORES_WIND) && CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || ProgressiveScale >= 2 || CanUse(IRON_BOOTS))) ||
(CanUse(IRON_BOOTS) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE));}}),
LocationAccess(LH_GS_LAB_CRATE, {[]{return CanUse(IRON_BOOTS) && CanUse(HOOKSHOT);}}),
}, {
//Exits
Entrance(LAKE_HYLIA, {[]{return true;}}),
@ -207,14 +181,11 @@ void AreaTable_Init_HyruleField() {
EventAccess(&LinksCow, {[]{return LinksCow || (CanPlay(EponasSong) && IsAdult && AtDay);}}),
}, {
//Locations
LocationAccess(SONG_FROM_MALON, {[]{return IsChild && ZeldasLetter && Ocarina && AtDay;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && ZeldasLetter && AtDay;}}),
LocationAccess(SONG_FROM_MALON, {[]{return IsChild && ZeldasLetter && Ocarina && AtDay;}}),
LocationAccess(LLR_GS_TREE, {[]{return IsChild;}}),
LocationAccess(LLR_GS_RAIN_SHED, {[]{return IsChild && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LLR_GS_HOUSE_WINDOW, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LLR_GS_BACK_WALL, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && IsChild && AtNight && CanGetNightTimeGS;}}),
LocationAccess(LLR_GS_BACK_WALL, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(HYRULE_FIELD, {[]{return true;}}),
@ -234,10 +205,8 @@ void AreaTable_Init_HyruleField() {
areaTable[LLR_STABLES] = Area("LLR Stables", "LLR Stables", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(LLR_STABLES_LEFT_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::EXPERT) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE))) && EponasSong;}}),
LocationAccess(LLR_STABLES_RIGHT_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::EXPERT) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE))) && EponasSong;}}),
LocationAccess(LLR_STABLES_LEFT_COW, {[]{return CanPlay(EponasSong);}}),
LocationAccess(LLR_STABLES_RIGHT_COW, {[]{return CanPlay(EponasSong);}}),
}, {
//Exits
Entrance(LON_LON_RANCH, {[]{return true;}}),
@ -246,10 +215,8 @@ void AreaTable_Init_HyruleField() {
areaTable[LLR_TOWER] = Area("LLR Tower", "LLR Tower", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(LLR_FREESTANDING_POH, {[]{return IsChild;}}),
LocationAccess(LLR_TOWER_LEFT_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::EXPERT) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE))) && EponasSong;}}),
LocationAccess(LLR_TOWER_RIGHT_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::EXPERT) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE))) && EponasSong;}}),
LocationAccess(LLR_TOWER_LEFT_COW, {[]{return CanPlay(EponasSong);}}),
LocationAccess(LLR_TOWER_RIGHT_COW, {[]{return CanPlay(EponasSong);}}),
}, {
//Exits
Entrance(LON_LON_RANCH, {[]{return true;}}),

6
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_ice_cavern.cpp
View File

@ -39,7 +39,7 @@ void AreaTable_Init_IceCavern() {
LocationAccess(ICE_CAVERN_FREESTANDING_POH, {[]{return BlueFire;}}),
LocationAccess(ICE_CAVERN_GS_SPINNING_SCYTHE_ROOM, {[]{return HookshotOrBoomerang;}}),
LocationAccess(ICE_CAVERN_GS_HEART_PIECE_ROOM, {[]{return BlueFire && HookshotOrBoomerang;}}),
LocationAccess(ICE_CAVERN_GS_PUSH_BLOCK_ROOM, {[]{return BlueFire && HookshotOrBoomerang;}}),
LocationAccess(ICE_CAVERN_GS_PUSH_BLOCK_ROOM, {[]{return BlueFire && (HookshotOrBoomerang || (LogicIceBlockGS && IsAdult && CanUse(HOVER_BOOTS)));}}),
}, {});
}
@ -71,7 +71,7 @@ void AreaTable_Init_IceCavern() {
LocationAccess(ICE_CAVERN_MQ_IRON_BOOTS_CHEST, {[]{return IsAdult;}}),
LocationAccess(SHEIK_IN_ICE_CAVERN, {[]{return IsAdult;}}),
LocationAccess(ICE_CAVERN_MQ_GS_ICE_BLOCK, {[]{return IsAdult || CanUseProjectile;}}),
LocationAccess(ICE_CAVERN_MQ_GS_SCARECROW, {[]{return IsAdult && (CanUse(SCARECROW) || (CanUse(HOVER_BOOTS) && CanUse(LONGSHOT)));}}),
LocationAccess(ICE_CAVERN_MQ_GS_SCARECROW, {[]{return (CanUse(SCARECROW) || (HoverBoots && CanUse(LONGSHOT)) || LogicIceMQScarecrow) && IsAdult;}}),
//Tricks: (CanUse(SCARECROW) || (HoverBoots && CanUse(LONGSHOT)) || LogicIceMQScarecrow) && IsAdult
}, {});
@ -79,7 +79,7 @@ void AreaTable_Init_IceCavern() {
//Locations
LocationAccess(ICE_CAVERN_MQ_COMPASS_CHEST, {[]{return true;}}),
LocationAccess(ICE_CAVERN_MQ_FREESTANDING_POH, {[]{return HasExplosives;}}),
LocationAccess(ICE_CAVERN_MQ_GS_RED_ICE, {[]{return CanPlay(SongOfTime);}}),
LocationAccess(ICE_CAVERN_MQ_GS_RED_ICE, {[]{return CanPlay(SongOfTime) || LogicIceMQRedIceGS;}}),
//Trick: CanPlay(SongOfTime) || LogicIceMQRedIceGS
}, {});
}

32
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_jabujabus_belly.cpp
View File

@ -24,8 +24,7 @@ void AreaTable_Init_JabuJabusBelly() {
areaTable[JABU_JABUS_BELLY_BEGINNING] = Area("Jabu Jabus Belly Beginning", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(JABU_JABUS_BELLY_ENTRYWAY, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_LIFT_MIDDLE, {[]{return CanUseProjectile;},
/*Glitched*/[]{return CanUse(BOOMERANG) || CanUse(BOW) || CanUse(HOOKSHOT) || (CanUse(STICKS) && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::EXPERT)) || CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE);}}),
Entrance(JABU_JABUS_BELLY_LIFT_MIDDLE, {[]{return CanUseProjectile;}}),
});
areaTable[JABU_JABUS_BELLY_LIFT_MIDDLE] = Area("Jabu Jabus Belly Lift Middle", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -33,9 +32,7 @@ void AreaTable_Init_JabuJabusBelly() {
Entrance(JABU_JABUS_BELLY_BEGINNING, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_MAIN_UPPER, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_LIFT_LOWER, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_NEAR_BOSS_ROOM, {[]{return HasAccessTo(JABU_JABUS_BELLY_LIFT_UPPER) || (LogicJabuBossGSAdult && IsAdult && CanUse(HOVER_BOOTS));},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE)) &&
GlitchJabuSwitch && (Fish || Bugs || CanUse(FARORES_WIND) || (IsAdult && ClaimCheck));}}),
Entrance(JABU_JABUS_BELLY_NEAR_BOSS_ROOM, {[]{return HasAccessTo(JABU_JABUS_BELLY_LIFT_UPPER) || (LogicJabuBossHover && IsAdult && CanUse(HOVER_BOOTS));}}),
});
areaTable[JABU_JABUS_BELLY_MAIN_UPPER] = Area("Jabu Jabus Belly Main Upper", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -48,10 +45,8 @@ void AreaTable_Init_JabuJabusBelly() {
areaTable[JABU_JABUS_BELLY_MAIN_LOWER] = Area("Jabu Jabus Belly Main Lower", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(JABU_JABUS_BELLY_GS_LOBBY_BASEMENT_LOWER, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(JABU_JABUS_BELLY_GS_LOBBY_BASEMENT_UPPER, {[]{return HookshotOrBoomerang;},
/*Glitched*/[]{return Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(JABU_JABUS_BELLY_GS_LOBBY_BASEMENT_LOWER, {[]{return HookshotOrBoomerang;}}),
LocationAccess(JABU_JABUS_BELLY_GS_LOBBY_BASEMENT_UPPER, {[]{return HookshotOrBoomerang;}}),
}, {
//Exits
Entrance(JABU_JABUS_BELLY_MAIN_UPPER, {[]{return true;}}),
@ -68,14 +63,12 @@ void AreaTable_Init_JabuJabusBelly() {
}, {
//Exits
Entrance(JABU_JABUS_BELLY_MAIN_LOWER, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_LIFT_LOWER, {[]{return CanUseProjectile;},
/*Glitched*/[]{return CanUse(BOOMERANG) || CanUse(BOW) || CanUse(HOOKSHOT) || (CanUse(STICKS) && CanTakeDamage && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::EXPERT));}}),
Entrance(JABU_JABUS_BELLY_LIFT_LOWER, {[]{return CanUseProjectile;}}),
});
areaTable[JABU_JABUS_BELLY_LOWER_SIDE_ROOM] = Area("Jabu Jabus Belly Lower Side Room", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&FairyPot, {[]{return FairyPot || (CanUse(BOOMERANG) || CanUse(HOVER_BOOTS));},
/*Glitched*/[]{return (Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE);}}),
EventAccess(&FairyPot, {[]{return FairyPot || (CanUse(BOOMERANG) || CanUse(HOVER_BOOTS));}}),
}, {}, {
//Exits
Entrance(JABU_JABUS_BELLY_MAIN_LOWER, {[]{return true;}}),
@ -83,7 +76,7 @@ void AreaTable_Init_JabuJabusBelly() {
areaTable[JABU_JABUS_BELLY_LIFT_LOWER] = Area("Jabu Jabus Belly Lift Lower", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(JABU_JABUS_BELLY_DEKU_SCRUB, {[]{return (IsChild || CanDive || LogicJabuScrubJumpDive || CanUse(IRON_BOOTS)) && CanStunDeku;}}),
LocationAccess(JABU_JABUS_BELLY_DEKU_SCRUB, {[]{return (IsChild || CanDive || LogicJabuAlcoveJumpDive || CanUse(IRON_BOOTS)) && CanStunDeku;}}),
}, {
//Exits
Entrance(JABU_JABUS_BELLY_SHABOMB_CORRIDOR, {[]{return true;}}),
@ -146,8 +139,7 @@ void AreaTable_Init_JabuJabusBelly() {
EventAccess(&NutPot, {[]{return true;}}),
}, {}, {
//Exits
Entrance(JABU_JABUS_BELLY_LIFT_UPPER, {[]{return CanUse(BOOMERANG);},
/*Glitched*/[]{return HasBombchus && CanShield && IsAdult && (CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(SLINGSHOT)) && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED);}}),
Entrance(JABU_JABUS_BELLY_LIFT_UPPER, {[]{return CanUse(BOOMERANG);}}),
});
areaTable[JABU_JABUS_BELLY_LIFT_UPPER] = Area("Jabu Jabus Belly Lift Upper", "Jabu Jabus Belly", JABU_JABUS_BELLY, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -162,9 +154,7 @@ void AreaTable_Init_JabuJabusBelly() {
}, {
//Exits
Entrance(JABU_JABUS_BELLY_LIFT_MIDDLE, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_BOSS_ENTRYWAY, {[]{return CanUse(BOOMERANG);},
/*Glitched*/[]{return (CanUse(HOVER_BOOTS) && (CanUse(BOW) || CanUse(SLINGSHOT))) || CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE) ||
(CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::NOVICE)) || (Bombs && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE);}}),
Entrance(JABU_JABUS_BELLY_BOSS_ENTRYWAY, {[]{return CanUse(BOOMERANG) || (LogicJabuNearBossRanged && ((IsAdult && (CanUse(HOOKSHOT) || CanUse(BOW))) || (IsChild && CanUse(SLINGSHOT)))) || (LogicJabuNearBossExplosives && (HasBombchus || (IsAdult && CanUse(HOVER_BOOTS) && Bombs)));}}),
});
}
@ -194,7 +184,7 @@ void AreaTable_Init_JabuJabusBelly() {
LocationAccess(JABU_JABUS_BELLY_MQ_BASEMENT_NEAR_SWITCHES_CHEST, {[]{return true;}}),
LocationAccess(JABU_JABUS_BELLY_MQ_BOOMERANG_ROOM_SMALL_CHEST, {[]{return true;}}),
LocationAccess(JABU_JABUS_BELLY_MQ_BOOMERANG_CHEST, {[]{return true;}}),
LocationAccess(JABU_JABUS_BELLY_MQ_GS_BOOMERANG_CHEST_ROOM, {[]{return CanPlay(SongOfTime);}}),
LocationAccess(JABU_JABUS_BELLY_MQ_GS_BOOMERANG_CHEST_ROOM, {[]{return CanPlay(SongOfTime) || (LogicJabuMQSoTGS && IsChild && CanUse(BOOMERANG));}}),
//Trick: CanPlay(SongOfTime) || (LogicJabuMQSoTGS && IsChild && CanUse(BOOMERANG))
}, {
//Exits
@ -243,7 +233,7 @@ void AreaTable_Init_JabuJabusBelly() {
areaTable[JABU_JABUS_BELLY_BOSS_ROOM] =
Area("Jabu Jabus Belly Boss Room", "Jabu Jabus Belly", NONE, NO_DAY_NIGHT_CYCLE,
{
// Events
// Events //todo: add pot kill trick
EventAccess(&JabuJabusBellyClear,
{ [] { return JabuJabusBellyClear || (CanUse(BOOMERANG) && CanJumpslash); } }),
},

72
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_kakariko.cpp
View File

@ -21,8 +21,7 @@ void AreaTable_Init_Kakariko() {
LocationAccess(KAK_GS_SKULLTULA_HOUSE, {[]{return IsChild && AtNight && CanGetNightTimeGS;}}),
LocationAccess(KAK_GS_GUARDS_HOUSE, {[]{return IsChild && AtNight && CanGetNightTimeGS;}}),
LocationAccess(KAK_GS_TREE, {[]{return IsChild && AtNight && CanGetNightTimeGS;}}),
LocationAccess(KAK_GS_WATCHTOWER, {[]{return IsChild && (Slingshot || HasBombchus || CanUse(BOW) || CanUse(LONGSHOT)) && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return IsChild && AtNight && CanGetNightTimeGS && (CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::SuperStab, GlitchDifficulty::NOVICE) || (Sticks && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE)));}}),
LocationAccess(KAK_GS_WATCHTOWER, {[]{return IsChild && (Slingshot || HasBombchus || CanUse(BOW) || CanUse(LONGSHOT) || (LogicKakarikoTowerGS && CanJumpslash)) && AtNight && CanGetNightTimeGS;}}),
}, {
//Exits
Entrance(HYRULE_FIELD, {[]{return true;}}),
@ -30,24 +29,16 @@ void AreaTable_Init_Kakariko() {
Entrance(KAK_HOUSE_OF_SKULLTULA, {[]{return true;}}),
Entrance(KAK_IMPAS_HOUSE, {[]{return true;}}),
Entrance(KAK_WINDMILL, {[]{return true;}}),
Entrance(KAK_BAZAAR, {[]{return IsAdult && AtDay;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE);}}),
Entrance(KAK_BAZAAR, {[]{return IsAdult && AtDay;}}),
Entrance(KAK_SHOOTING_GALLERY, {[]{return IsAdult && AtDay;}}),
Entrance(BOTTOM_OF_THE_WELL_ENTRYWAY, {[]{return DrainWell && (IsChild || ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF));},
/*Glitched*/[]{return (IsChild && (CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE) || (AtNight && (CanDoGlitch(GlitchType::NaviDive_Stick, GlitchDifficulty::NOVICE) || ((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) ||
(CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || WeirdEgg))) && ((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) ||
(CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED)))))))) || (IsAdult && CanUse(LONGSHOT) && AtDay && CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE));}}),
Entrance(BOTTOM_OF_THE_WELL_ENTRYWAY, {[]{return DrainWell && (IsChild || ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF));}}),
Entrance(KAK_POTION_SHOP_FRONT, {[]{return AtDay || IsChild;}}),
Entrance(KAK_REDEAD_GROTTO, {[]{return CanOpenBombGrotto;}}),
Entrance(KAK_IMPAS_LEDGE, {[]{return (IsChild && AtDay) || CanUse(HOOKSHOT);},
/*Glitched*/[]{return IsAdult && ((HoverBoots && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE)) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE)) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(KAK_ROOFTOP, {[]{return CanUse(HOOKSHOT) || (LogicManOnRoof && (IsAdult || AtDay || Slingshot || HasBombchus || CanUse(BOW) || CanUse(LONGSHOT)));},
/*Glitched*/[]{return LogicManOnRoof && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE);}}),
Entrance(KAK_IMPAS_ROOFTOP, {[]{return CanUse(HOOKSHOT);},
/*Glitched*/[]{return (HoverBoots && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE)) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE)) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(KAK_IMPAS_LEDGE, {[]{return (IsChild && AtDay) || CanUse(HOOKSHOT) || (IsAdult && LogicVisibleCollision);}}),
Entrance(KAK_ROOFTOP, {[]{return CanUse(HOOKSHOT) || (LogicManOnRoof && (IsAdult || AtDay || Slingshot || HasBombchus || CanUse(BOW) || CanUse(LONGSHOT)));}}),
Entrance(KAK_IMPAS_ROOFTOP, {[]{return CanUse(HOOKSHOT) || (LogicKakarikoRooftopGS && CanUse(HOVER_BOOTS));}}),
Entrance(THE_GRAVEYARD, {[]{return true;}}),
Entrance(KAK_BEHIND_GATE, {[]{return IsAdult || (KakarikoVillageGateOpen);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(KAK_BEHIND_GATE, {[]{return IsAdult || (KakarikoVillageGateOpen);}}),
});
areaTable[KAK_IMPAS_LEDGE] = Area("Kak Impas Ledge", "Kakariko Village", KAKARIKO_VILLAGE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -78,8 +69,7 @@ void AreaTable_Init_Kakariko() {
Entrance(KAKARIKO_VILLAGE, {[]{return true;}}),
Entrance(KAK_OPEN_GROTTO, {[]{return true;}}),
Entrance(KAK_ODD_POTION_BUILDING, {[]{return IsAdult;}}),
Entrance(KAK_POTION_SHOP_BACK, {[]{return IsAdult && AtDay;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE);}}),
Entrance(KAK_POTION_SHOP_BACK, {[]{return IsAdult && AtDay;}}),
});
areaTable[KAK_CARPENTER_BOSS_HOUSE] = Area("Kak Carpenter Boss House", "Kak Carpenter Boss House", NONE, NO_DAY_NIGHT_CYCLE, {
@ -120,22 +110,17 @@ void AreaTable_Init_Kakariko() {
areaTable[KAK_IMPAS_HOUSE_NEAR_COW] = Area("Kak Impas House Near Cow", "Kak Impas House", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(KAK_IMPAS_HOUSE_COW, {[]{return CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED))) && EponasSong;}}),
LocationAccess(KAK_IMPAS_HOUSE_COW, {[]{return CanPlay(EponasSong);}}),
}, {});
areaTable[KAK_WINDMILL] = Area("Kak Windmill", "Windmill and Dampes Grave", NONE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&DrainWell, {[]{return DrainWell || (IsChild && CanPlay(SongOfStorms));},
/*Glitched*/[]{return IsChild && SongOfStorms && (CanDoGlitch(GlitchType::WindmillBombOI, GlitchDifficulty::ADVANCED) || ((Fish || Bugs) && CanShield && ((Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2))) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE)) &&
CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Fish || Bugs) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)));}}),
EventAccess(&DrainWell, {[]{return DrainWell || (IsChild && CanPlay(SongOfStorms));}}),
}, {
//Locations
LocationAccess(KAK_WINDMILL_FREESTANDING_POH, {[]{return CanUse(BOOMERANG) || DampesWindmillAccess || (IsAdult && CanUse(HOOKSHOT) && LogicWindmillPoHHookshot);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(SONG_FROM_WINDMILL, {[]{return IsAdult && Ocarina;},
/*Glitched*/[]{return IsAdult && (CanDoGlitch(GlitchType::WindmillBombOI, GlitchDifficulty::EXPERT) || ((Fish || Bugs) && CanShield && ((Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2))) || (DampesWindmillAccess || (IsAdult && CanUse(HOOKSHOT) && LogicWindmillPoHHookshot) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE))) &&
CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Fish || Bugs) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)));}}),
LocationAccess(KAK_WINDMILL_FREESTANDING_POH, {[]{return CanUse(BOOMERANG) || DampesWindmillAccess || (IsAdult && LogicAdultWindmillPoH) || (IsChild && CanJumpslash && LogicChildWindmillPoH);}}),
//PoH as child not added to trick options yet (needs uncommenting in randomizer_tricks.cpp)
LocationAccess(SONG_FROM_WINDMILL, {[]{return IsAdult && Ocarina;}}),
}, {
//Exits
Entrance(KAKARIKO_VILLAGE, {[]{return true;}}),
@ -221,24 +206,19 @@ void AreaTable_Init_Kakariko() {
EventAccess(&BugRock, {[]{return true;}}),
}, {
//Locations
LocationAccess(GRAVEYARD_FREESTANDING_POH, {[]{return (IsAdult && CanPlantBean(THE_GRAVEYARD)) || CanUse(LONGSHOT) || (LogicGraveyardPoH && CanUse(BOOMERANG));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::NOVICE);}}),
LocationAccess(GRAVEYARD_FREESTANDING_POH, {[]{return (IsAdult && CanPlantBean(THE_GRAVEYARD)) || CanUse(LONGSHOT) || (LogicGraveyardPoH && CanUse(BOOMERANG));}}),
LocationAccess(GRAVEYARD_DAMPE_GRAVEDIGGING_TOUR, {[]{return IsChild && AtNight;}}), //TODO: This needs to change
LocationAccess(GRAVEYARD_GS_WALL, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return IsChild && AtNight && CanGetNightTimeGS && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(GRAVEYARD_GS_WALL, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(GRAVEYARD_GS_BEAN_PATCH, {[]{return CanPlantBugs && CanChildAttack;}}),
}, {
//Exits
Entrance(GRAVEYARD_SHIELD_GRAVE, {[]{return IsAdult || AtNight;}}),
Entrance(GRAVEYARD_COMPOSERS_GRAVE, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) || ((Bugs || Fish) && CanShield && (IsChild || AdultCanAccess(GRAVEYARD_WARP_PAD_REGION) || (IsAdult && (CanPlantBean(THE_GRAVEYARD) || CanUse(LONGSHOT))) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || (Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2)))) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
Entrance(GRAVEYARD_COMPOSERS_GRAVE, {[]{return CanPlay(ZeldasLullaby);}}),
Entrance(GRAVEYARD_HEART_PIECE_GRAVE, {[]{return IsAdult || AtNight;}}),
Entrance(GRAVEYARD_DAMPES_GRAVE, {[]{return IsAdult;}}),
Entrance(GRAVEYARD_DAMPES_HOUSE, {[]{return IsAdult || AtDampeTime;}}), //TODO: This needs to be handled
Entrance(KAKARIKO_VILLAGE, {[]{return true;}}),
Entrance(GRAVEYARD_WARP_PAD_REGION, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::NOVICE);}}),
Entrance(GRAVEYARD_WARP_PAD_REGION, {[]{return false;}}),
});
areaTable[GRAVEYARD_SHIELD_GRAVE] = Area("Graveyard Shield Grave", "Graveyard Shield Grave", NONE, NO_DAY_NIGHT_CYCLE, {}, {
@ -252,8 +232,7 @@ void AreaTable_Init_Kakariko() {
areaTable[GRAVEYARD_HEART_PIECE_GRAVE] = Area("Graveyard Heart Piece Grave", "Graveyard Heart Piece Grave", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(GRAVEYARD_HEART_PIECE_GRAVE_CHEST, {[]{return CanPlay(SunsSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::NOVICE) || ((Bugs || Fish) && CanShield && (Bombs && (CanSurviveDamage || (Fairy && NumBottles >= 2))) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SunsSong;}}),
LocationAccess(GRAVEYARD_HEART_PIECE_GRAVE_CHEST, {[]{return CanPlay(SunsSong);}}),
}, {
//Exits
Entrance(THE_GRAVEYARD, {[]{return true;}}),
@ -261,8 +240,7 @@ void AreaTable_Init_Kakariko() {
areaTable[GRAVEYARD_COMPOSERS_GRAVE] = Area("Graveyard Composers Grave", "Graveyard Composers Grave", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(GRAVEYARD_COMPOSERS_GRAVE_CHEST, {[]{return HasFireSource;},
/*Glitched*/[]{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(GRAVEYARD_COMPOSERS_GRAVE_CHEST, {[]{return HasFireSource;}}),
LocationAccess(SONG_FROM_COMPOSERS_GRAVE, {[]{return IsAdult || (Slingshot || Boomerang || Sticks || HasExplosives || KokiriSword || CanUse(MEGATON_HAMMER) || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD) || CanUse(BOW) || CanUse(HOOKSHOT));}}),
}, {
//Exits
@ -272,9 +250,7 @@ void AreaTable_Init_Kakariko() {
areaTable[GRAVEYARD_DAMPES_GRAVE] = Area("Graveyard Dampes Grave", "Windmill and Dampes Grave", NONE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&NutPot, {[]{return true;}}),
EventAccess(&DampesWindmillAccess, {[]{return DampesWindmillAccess || (IsAdult && CanPlay(SongOfTime));},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::WindmillBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsAdult && SongOfTime;}}),
EventAccess(&DampesWindmillAccess, {[]{return DampesWindmillAccess || (IsAdult && CanPlay(SongOfTime));}}),
}, {
//Locations
LocationAccess(GRAVEYARD_HOOKSHOT_CHEST, {[]{return true;}}),
@ -282,9 +258,7 @@ void AreaTable_Init_Kakariko() {
}, {
//Exits
Entrance(THE_GRAVEYARD, {[]{return true;}}),
Entrance(KAK_WINDMILL, {[]{return IsAdult && CanPlay(SongOfTime);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::WindmillBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsAdult && SongOfTime;}}),
Entrance(KAK_WINDMILL, {[]{return IsAdult && CanPlay(SongOfTime);}}),
});
areaTable[GRAVEYARD_DAMPES_HOUSE] = Area("Graveyard Dampes House", "Graveyard Dampes House", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -301,9 +275,7 @@ void AreaTable_Init_Kakariko() {
}, {
//Exits
Entrance(THE_GRAVEYARD, {[]{return true;}}),
Entrance(SHADOW_TEMPLE_ENTRYWAY, {[]{return CanUse(DINS_FIRE) || (LogicShadowFireArrowEntry && IsAdult && CanUse(FIRE_ARROWS));},
/*Glitched*/[]{return (CanUse(STICKS) && (CanDoGlitch(GlitchType::QPA, GlitchDifficulty::INTERMEDIATE) || CanUse(FIRE_ARROWS))) || (CanTakeDamage && (
CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::NOVICE)));}}),
Entrance(SHADOW_TEMPLE_ENTRYWAY, {[]{return CanUse(DINS_FIRE) || (LogicShadowFireArrowEntry && IsAdult && CanUse(FIRE_ARROWS));}}),
});
areaTable[KAK_BEHIND_GATE] = Area("Kak Behind Gate", "Kakariko Village", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {

65
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_lost_woods.cpp
View File

@ -16,8 +16,7 @@ void AreaTable_Init_LostWoods() {
LocationAccess(KF_KOKIRI_SWORD_CHEST, {[]{return IsChild;}}),
LocationAccess(KF_GS_KNOW_IT_ALL_HOUSE, {[]{return IsChild && CanChildAttack && AtNight && (HasNightStart || CanLeaveForest || CanPlay(SunsSong)) && CanGetNightTimeGS;}}),
LocationAccess(KF_GS_BEAN_PATCH, {[]{return CanPlantBugs && CanChildAttack;}}),
LocationAccess(KF_GS_HOUSE_OF_TWINS, {[]{return IsAdult && AtNight && HookshotOrBoomerang && CanGetNightTimeGS;},
/*Glitched*/[]{return IsAdult && AtNight && CanGetNightTimeGS && (CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE));}}),
LocationAccess(KF_GS_HOUSE_OF_TWINS, {[]{return IsAdult && AtNight && (HookshotOrBoomerang || (LogicAdultKokiriGS && CanUse(HOVER_BOOTS))) && CanGetNightTimeGS;}}),
LocationAccess(KF_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
@ -27,13 +26,10 @@ void AreaTable_Init_LostWoods() {
Entrance(KF_HOUSE_OF_TWINS, {[]{return true;}}),
Entrance(KF_KNOW_IT_ALL_HOUSE, {[]{return true;}}),
Entrance(KF_KOKIRI_SHOP, {[]{return true;}}),
Entrance(KF_OUTSIDE_DEKU_TREE, {[]{return IsAdult || OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(KF_OUTSIDE_DEKU_TREE, {[]{return IsAdult || OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield;}}),
Entrance(THE_LOST_WOODS, {[]{return true;}}),
Entrance(LW_BRIDGE_FROM_FOREST, {[]{return IsAdult || OpenForest.IsNot(OPENFOREST_CLOSED) || DekuTreeClear;},
/*Glitched*/[]{return CanLeaveForest && (CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || GlitchWWTEscape);}}),
Entrance(KF_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(LW_BRIDGE_FROM_FOREST, {[]{return IsAdult || OpenForest.IsNot(OPENFOREST_CLOSED) || DekuTreeClear;}}),
Entrance(KF_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
});
areaTable[KF_OUTSIDE_DEKU_TREE] = Area("KF Outside Deku Tree", "Kokiri Forest", KOKIRI_FOREST, NO_DAY_NIGHT_CYCLE, {
@ -47,16 +43,13 @@ void AreaTable_Init_LostWoods() {
LocationAccess(KF_DEKU_TREE_GOSSIP_STONE_RIGHT, {[]{return true;}}),
}, {
//Exits
Entrance(DEKU_TREE_ENTRYWAY, {[]{return IsChild || (ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF) && (OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(KOKIRI_FOREST, {[]{return IsAdult || OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(DEKU_TREE_ENTRYWAY, {[]{return IsChild || (ShuffleDungeonEntrances.IsNot(SHUFFLEDUNGEONS_OFF) && (OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield));}}),
Entrance(KOKIRI_FOREST, {[]{return IsAdult || OpenForest.Is(OPENFOREST_OPEN) || ShowedMidoSwordAndShield;}}),
});
areaTable[KF_LINKS_HOUSE] = Area("KF Link's House", "KF Link's House", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(KF_LINKS_HOUSE_COW, {[]{return IsAdult && CanPlay(EponasSong) && LinksCow;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::IndoorBombOI, GlitchDifficulty::EXPERT) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (NumBottles >= 2 && Fairy)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::EXPERT))) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && Bombs && IsAdult && EponasSong && LinksCow;}}),
LocationAccess(KF_LINKS_HOUSE_COW, {[]{return IsAdult && CanPlay(EponasSong) && LinksCow;}}),
}, {
//Exits
Entrance(KOKIRI_FOREST, {[]{return true;}})
@ -123,16 +116,13 @@ void AreaTable_Init_LostWoods() {
EventAccess(&PoachersSawAccess, {[]{return PoachersSawAccess || (IsAdult && OddPoulticeAccess);}}),
EventAccess(&GossipStoneFairy, {[]{return GossipStoneFairy || CanSummonGossipFairyWithoutSuns;}}),
EventAccess(&BeanPlantFairy, {[]{return BeanPlantFairy || CanPlay(SongOfStorms);}}),
EventAccess(&BugShrub, {[]{return IsChild && CanCutShrubs;},
/*Glitched*/[]{return IsChild && Sticks && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
EventAccess(&BugShrub, {[]{return IsChild && CanCutShrubs;}}),
}, {
//Locations
LocationAccess(LW_SKULL_KID, {[]{return IsChild && CanPlay(SariasSong);},
/*Glitched*/[]{return IsChild && (Fish || Bugs) && SariasSong && CanShield && (CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) || (HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)));}}),
LocationAccess(LW_SKULL_KID, {[]{return IsChild && CanPlay(SariasSong);}}),
LocationAccess(LW_TRADE_COJIRO, {[]{return IsAdult && Cojiro;}}),
LocationAccess(LW_TRADE_ODD_POTION, {[]{return IsAdult && OddPoultice && Cojiro;}}),
LocationAccess(LW_OCARINA_MEMORY_GAME, {[]{return IsChild && Ocarina;},
/*Glitched*/[]{return IsChild && (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Fish || Bugs) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)));}}),
LocationAccess(LW_OCARINA_MEMORY_GAME, {[]{return IsChild && Ocarina;}}),
LocationAccess(LW_TARGET_IN_WOODS, {[]{return IsChild && CanUse(SLINGSHOT);}}),
LocationAccess(LW_DEKU_SCRUB_NEAR_BRIDGE, {[]{return IsChild && CanStunDeku;}}),
LocationAccess(LW_GS_BEAN_PATCH_NEAR_BRIDGE, {[]{return CanPlantBugs && CanChildAttack;}}),
@ -141,18 +131,10 @@ void AreaTable_Init_LostWoods() {
//Exits
Entrance(LW_FOREST_EXIT, {[]{return true;}}),
Entrance(GC_WOODS_WARP, {[]{return true;}}),
Entrance(LW_BRIDGE, {[]{return CanLeaveForest && ((IsAdult && CanPlantBean(THE_LOST_WOODS)) || CanUse(HOVER_BOOTS) || CanUse(LONGSHOT));},
/*Glitched*/[]{return CanLeaveForest && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || (CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && HasBombchus) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(ZORAS_RIVER, {[]{return CanLeaveForest && (CanDive || CanUse(IRON_BOOTS));},
/*Glitched*/[]{return CanLeaveForest && (CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::NaviDive_Stick, GlitchDifficulty::ADVANCED) ||
((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) || (CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || (IsAdult && (HasBoots || ClaimCheck)) || (IsChild && WeirdEgg)))) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED)))));}}),
Entrance(LW_BEYOND_MIDO, {[]{return IsChild || CanPlay(SariasSong);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::NOVICE) ||
CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE) || (CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::ADVANCED) && (CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE) || HoverBoots)) ||
((CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SariasSong);}}),
Entrance(LW_NEAR_SHORTCUTS_GROTTO, {[]{return Here(THE_LOST_WOODS, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(THE_LOST_WOODS, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(LW_BRIDGE, {[]{return CanLeaveForest && ((IsAdult && (CanPlantBean(THE_LOST_WOODS) || LogicLostWoodsBridge)) || CanUse(HOVER_BOOTS) || CanUse(LONGSHOT));}}),
Entrance(ZORAS_RIVER, {[]{return CanLeaveForest && (CanDive || CanUse(IRON_BOOTS));}}),
Entrance(LW_BEYOND_MIDO, {[]{return IsChild || CanPlay(SariasSong) || LogicMidoBackflip;}}),
Entrance(LW_NEAR_SHORTCUTS_GROTTO, {[]{return Here(THE_LOST_WOODS, []{return CanBlastOrSmash;});}}),
});
areaTable[LW_BEYOND_MIDO] = Area("LW Beyond Mido", "Lost Woods", THE_LOST_WOODS, NO_DAY_NIGHT_CYCLE, {
@ -162,19 +144,15 @@ void AreaTable_Init_LostWoods() {
//Locations
LocationAccess(LW_DEKU_SCRUB_NEAR_DEKU_THEATER_RIGHT, {[]{return IsChild && CanStunDeku;}}),
LocationAccess(LW_DEKU_SCRUB_NEAR_DEKU_THEATER_LEFT, {[]{return IsChild && CanStunDeku;}}),
LocationAccess(LW_GS_ABOVE_THEATER, {[]{return IsAdult && AtNight && (CanPlantBean(LW_BEYOND_MIDO) || (LogicLostWoodsGSBean && CanUse(HOOKSHOT) && (CanUse(LONGSHOT) || CanUse(BOW) || CanUse(SLINGSHOT) || HasBombchus || CanUse(DINS_FIRE)))) && CanGetNightTimeGS;},
/*Glitched*/[]{return IsAdult && AtNight && CanGetNightTimeGS && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
LocationAccess(LW_GS_ABOVE_THEATER, {[]{return IsAdult && AtNight && (CanPlantBean(LW_BEYOND_MIDO) || (LogicLostWoodsGSBean && CanUse(HOOKSHOT) && (CanUse(LONGSHOT) || CanUse(BOW) || CanUse(SLINGSHOT) || HasBombchus || CanUse(DINS_FIRE)))) && CanGetNightTimeGS;}}),
LocationAccess(LW_GS_BEAN_PATCH_NEAR_THEATER, {[]{return CanPlantBugs && (CanChildAttack || (Scrubsanity.Is(SCRUBSANITY_OFF) && DekuShield));}}),
}, {
//Exits
Entrance(LW_FOREST_EXIT, {[]{return true;}}),
Entrance(THE_LOST_WOODS, {[]{return IsChild || CanPlay(SariasSong);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE) || ((CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) ||
((Bugs || Fish) && CanShield && Bombs && (CanSurviveDamage || (NumBottles >= 2 && Fairy)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SariasSong);}}),
Entrance(THE_LOST_WOODS, {[]{return IsChild || CanPlay(SariasSong);}}),
Entrance(SFM_ENTRYWAY, {[]{return true;}}),
Entrance(DEKU_THEATER, {[]{return true;}}),
Entrance(LW_SCRUBS_GROTTO, {[]{return Here(LW_BEYOND_MIDO, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(LW_BEYOND_MIDO, []{return IsChild && CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(LW_SCRUBS_GROTTO, {[]{return Here(LW_BEYOND_MIDO, []{return CanBlastOrSmash;});}}),
});
areaTable[LW_NEAR_SHORTCUTS_GROTTO] = Area("LW Near Shortcuts Grotto", "LW Near Shortcuts Grotto", NONE, NO_DAY_NIGHT_CYCLE, grottoEvents, {
@ -225,11 +203,9 @@ void AreaTable_Init_LostWoods() {
}, {
//Exits
Entrance(SFM_ENTRYWAY, {[]{return true;}}),
Entrance(FOREST_TEMPLE_ENTRYWAY, {[]{return CanUse(HOOKSHOT);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(FOREST_TEMPLE_ENTRYWAY, {[]{return CanUse(HOOKSHOT);}}),
Entrance(SFM_FAIRY_GROTTO, {[]{return true;}}),
Entrance(SFM_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && HasBombchus && CanShield && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(SFM_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
});
areaTable[SFM_FAIRY_GROTTO] = Area("SFM Fairy Grotto", "SFM Fairy Grotto", NONE, NO_DAY_NIGHT_CYCLE, {
@ -269,7 +245,6 @@ void AreaTable_Init_LostWoods() {
//Exits
Entrance(KOKIRI_FOREST, {[]{return true;}}),
Entrance(HYRULE_FIELD, {[]{return true;}}),
Entrance(THE_LOST_WOODS, {[]{return CanUse(LONGSHOT);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && Bombs && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)) || CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HookshotJump_Bonk, GlitchDifficulty::NOVICE);}}),
Entrance(THE_LOST_WOODS, {[]{return CanUse(LONGSHOT);}}),
});
}

89
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_shadow_temple.cpp
View File

@ -12,10 +12,8 @@ void AreaTable_Init_ShadowTemple() {
---------------------------*/
areaTable[SHADOW_TEMPLE_ENTRYWAY] = Area("Shadow Temple Entryway", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(SHADOW_TEMPLE_BEGINNING, {[]{return Dungeon::ShadowTemple.IsVanilla() && (LogicLensShadow || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT));},
/*Glitched*/[]{return Dungeon::ShadowTemple.IsVanilla() && (LogicLensShadow || CanUse(LENS_OF_TRUTH)) && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(SHADOW_TEMPLE_MQ_BEGINNING, {[]{return Dungeon::ShadowTemple.IsMQ() && (LogicLensShadowMQ || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT));},
/*Glitched*/[]{return Dungeon::ShadowTemple.IsMQ() && (LogicLensShadowMQ || CanUse(LENS_OF_TRUTH)) && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(SHADOW_TEMPLE_BEGINNING, {[]{return Dungeon::ShadowTemple.IsVanilla() && (LogicLensShadow || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT));}}),
Entrance(SHADOW_TEMPLE_MQ_BEGINNING, {[]{return Dungeon::ShadowTemple.IsMQ() && (LogicLensShadowMQ || CanUse(LENS_OF_TRUTH)) && (CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT));}}),
Entrance(GRAVEYARD_WARP_PAD_REGION, {[]{return true;}}),
});
@ -33,8 +31,7 @@ void AreaTable_Init_ShadowTemple() {
}, {
//Exits
Entrance(SHADOW_TEMPLE_ENTRYWAY, {[]{return true;}}),
Entrance(SHADOW_TEMPLE_FIRST_BEAMOS, {[]{return HoverBoots;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::NOVICE);}}),
Entrance(SHADOW_TEMPLE_FIRST_BEAMOS, {[]{return HoverBoots;}}),
});
areaTable[SHADOW_TEMPLE_FIRST_BEAMOS] = Area("Shadow Temple First Beamos", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {
@ -44,13 +41,11 @@ void AreaTable_Init_ShadowTemple() {
//Locations
LocationAccess(SHADOW_TEMPLE_COMPASS_CHEST, {[]{return IsAdult || KokiriSword || Sticks;}}),
LocationAccess(SHADOW_TEMPLE_EARLY_SILVER_RUPEE_CHEST, {[]{return CanUse(HOVER_BOOTS) || CanUse(HOOKSHOT);}}),
LocationAccess(SHADOW_TEMPLE_GS_NEAR_SHIP, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE) && Longshot;}}),
LocationAccess(SHADOW_TEMPLE_GS_NEAR_SHIP, {[]{return false;}}),
}, {
//Exits
Entrance(SHADOW_TEMPLE_HUGE_PIT, {[]{return HasExplosives && IsAdult && SmallKeys(SHADOW_TEMPLE, 1, 2);}}),
Entrance(SHADOW_TEMPLE_BEYOND_BOAT, {[]{return false;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE) && Longshot && CanPlay(ZeldasLullaby);}}),
Entrance(SHADOW_TEMPLE_BEYOND_BOAT, {[]{return false;}}),
});
areaTable[SHADOW_TEMPLE_HUGE_PIT] = Area("Shadow Temple Huge Pit", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -58,16 +53,16 @@ void AreaTable_Init_ShadowTemple() {
LocationAccess(SHADOW_TEMPLE_INVISIBLE_BLADES_VISIBLE_CHEST, {[]{return true;}}),
LocationAccess(SHADOW_TEMPLE_INVISIBLE_BLADES_INVISIBLE_CHEST, {[]{return true;}}),
LocationAccess(SHADOW_TEMPLE_FALLING_SPIKES_LOWER_CHEST, {[]{return true;}}),
LocationAccess(SHADOW_TEMPLE_FALLING_SPIKES_UPPER_CHEST, {[]{return LogicShadowUmbrella || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_FALLING_SPIKES_SWITCH_CHEST, {[]{return LogicShadowUmbrella || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_INVISIBLE_SPIKES_CHEST, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && (LogicLensShadowBack || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_FREESTANDING_KEY, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && (LogicLensShadowBack || CanUse(LENS_OF_TRUTH)) && Hookshot && (Bombs || GoronBracelet || (LogicShadowFreestandingKey && HasBombchus));}}),
LocationAccess(SHADOW_TEMPLE_FALLING_SPIKES_UPPER_CHEST, {[]{return (LogicShadowUmbrella && HoverBoots) || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_FALLING_SPIKES_SWITCH_CHEST, {[]{return (LogicShadowUmbrella && HoverBoots) || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_INVISIBLE_SPIKES_CHEST, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && ((LogicLensShadowPlatform && LogicLensShadow) || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_FREESTANDING_KEY, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && ((LogicLensShadowPlatform && LogicLensShadow) || CanUse(LENS_OF_TRUTH)) && Hookshot && (Bombs || GoronBracelet || (LogicShadowFreestandingKey && HasBombchus));}}),
LocationAccess(SHADOW_TEMPLE_GS_LIKE_LIKE_ROOM, {[]{return true;}}),
LocationAccess(SHADOW_TEMPLE_GS_FALLING_SPIKES_ROOM, {[]{return Hookshot;}}),
LocationAccess(SHADOW_TEMPLE_GS_SINGLE_GIANT_POT, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && (LogicLensShadowBack || CanUse(LENS_OF_TRUTH)) && Hookshot;}}),
LocationAccess(SHADOW_TEMPLE_GS_FALLING_SPIKES_ROOM, {[]{return Hookshot || (LogicShadowUmbrellaGS && HoverBoots);}}),
LocationAccess(SHADOW_TEMPLE_GS_SINGLE_GIANT_POT, {[]{return SmallKeys(SHADOW_TEMPLE, 2, 3) && ((LogicLensShadowPlatform && LogicLensShadow) || CanUse(LENS_OF_TRUTH)) && Hookshot;}}),
}, {
//Exits
Entrance(SHADOW_TEMPLE_WIND_TUNNEL, {[]{return (LogicLensShadowBack || CanUse(LENS_OF_TRUTH)) && Hookshot && SmallKeys(SHADOW_TEMPLE, 3, 4);}}),
Entrance(SHADOW_TEMPLE_WIND_TUNNEL, {[]{return ((LogicLensShadowPlatform && LogicLensShadow) || CanUse(LENS_OF_TRUTH)) && Hookshot && SmallKeys(SHADOW_TEMPLE, 3, 4);}}),
});
areaTable[SHADOW_TEMPLE_WIND_TUNNEL] = Area("Shadow Temple Wind Tunnel", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -100,7 +95,7 @@ void AreaTable_Init_ShadowTemple() {
areaTable[SHADOW_TEMPLE_MQ_BEGINNING] = Area("Shadow Temple MQ Beginning", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(SHADOW_TEMPLE_ENTRYWAY, {[]{return true;}}),
Entrance(SHADOW_TEMPLE_MQ_FIRST_BEAMOS, {[]{return IsAdult && (CanUse(FIRE_ARROWS) || CanUse(HOVER_BOOTS));}}),
Entrance(SHADOW_TEMPLE_MQ_FIRST_BEAMOS, {[]{return IsAdult && (CanUse(FIRE_ARROWS) || HoverBoots || (LogicShadowMQGap && CanUse(LONGSHOT)));}}),
//Trick: IsAdult && (CanUse(FIRE_ARROWS) || HoverBoots || (LogicShadowMQGap && CanUse(LONGSHOT)))
Entrance(SHADOW_TEMPLE_MQ_DEAD_HAND_AREA, {[]{return HasExplosives && SmallKeys(SHADOW_TEMPLE, 6);}}),
});
@ -123,13 +118,13 @@ void AreaTable_Init_ShadowTemple() {
areaTable[SHADOW_TEMPLE_MQ_UPPER_HUGE_PIT] = Area("Shadow Temple MQ Upper Huge Pit", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_BLADES_VISIBLE_CHEST, {[]{return CanPlay(SongOfTime);}}),
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_BLADES_VISIBLE_CHEST, {[]{return CanPlay(SongOfTime) || (LogicShadowMQInvisibleBlades && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO));}}),
//Trick: CanPlay(SongOfTime) || (LogicShadowMQInvisibleBlades && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO))
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_BLADES_INVISIBLE_CHEST, {[]{return CanPlay(SongOfTime);}}),
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_BLADES_INVISIBLE_CHEST, {[]{return CanPlay(SongOfTime) || (LogicShadowMQInvisibleBlades && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO));}}),
//Trick: CanPlay(SongOfTime) || (LogicShadowMQInvisibleBlades && DamageMultiplier.IsNot(DAMAGEMULTIPLIER_OHKO))
}, {
//Exits
Entrance(SHADOW_TEMPLE_MQ_LOWER_HUGE_PIT, {[]{return HasFireSource;}}),
Entrance(SHADOW_TEMPLE_MQ_LOWER_HUGE_PIT, {[]{return HasFireSource || LogicShadowMQHugePit;}}),
//Trick: HasFireSource || LogicShadowMQHugePit
});
@ -139,12 +134,12 @@ void AreaTable_Init_ShadowTemple() {
LocationAccess(SHADOW_TEMPLE_MQ_FALLING_SPIKES_LOWER_CHEST, {[]{return true;}}),
LocationAccess(SHADOW_TEMPLE_MQ_FALLING_SPIKES_UPPER_CHEST, {[]{return (LogicShadowUmbrella && HoverBoots) || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_MQ_FALLING_SPIKES_SWITCH_CHEST, {[]{return (LogicShadowUmbrella && HoverBoots) || GoronBracelet;}}),
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_SPIKES_CHEST, {[]{return HoverBoots && SmallKeys(SHADOW_TEMPLE, 3) && (LogicLensShadowMQBack || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_MQ_STALFOS_ROOM_CHEST, {[]{return HoverBoots && SmallKeys(SHADOW_TEMPLE, 3) && Hookshot && (LogicLensShadowMQBack || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_MQ_GS_FALLING_SPIKES_ROOM, {[]{return Hookshot;}}),
LocationAccess(SHADOW_TEMPLE_MQ_INVISIBLE_SPIKES_CHEST, {[]{return HoverBoots && SmallKeys(SHADOW_TEMPLE, 3) && ((LogicLensShadowMQ && LogicLensShadowMQPlatform) || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_MQ_STALFOS_ROOM_CHEST, {[]{return HoverBoots && SmallKeys(SHADOW_TEMPLE, 3) && Hookshot && ((LogicLensShadowMQ && LogicLensShadowMQInvisibleBlades && LogicLensShadowMQPlatform) || CanUse(LENS_OF_TRUTH));}}),
LocationAccess(SHADOW_TEMPLE_MQ_GS_FALLING_SPIKES_ROOM, {[]{return Hookshot || (LogicShadowUmbrellaGS && HoverBoots);}}),
}, {
//Exits
Entrance(SHADOW_TEMPLE_MQ_WIND_TUNNEL, {[]{return HoverBoots && (LogicLensShadowMQBack || CanUse(LENS_OF_TRUTH)) && Hookshot && SmallKeys(SHADOW_TEMPLE, 4);}}),
Entrance(SHADOW_TEMPLE_MQ_WIND_TUNNEL, {[]{return HoverBoots && ((LogicLensShadowMQ && LogicLensShadowMQPlatform) || CanUse(LENS_OF_TRUTH)) && Hookshot && SmallKeys(SHADOW_TEMPLE, 4);}}),
});
areaTable[SHADOW_TEMPLE_MQ_WIND_TUNNEL] = Area("Shadow Temple MQ Wind Tunnel", "Shadow Temple", SHADOW_TEMPLE, NO_DAY_NIGHT_CYCLE, {
@ -176,7 +171,8 @@ void AreaTable_Init_ShadowTemple() {
//Locations
LocationAccess(SHADOW_TEMPLE_MQ_SPIKE_WALLS_LEFT_CHEST, {[]{return CanUse(DINS_FIRE) && SmallKeys(SHADOW_TEMPLE, 6);}}),
LocationAccess(SHADOW_TEMPLE_MQ_BOSS_KEY_CHEST, {[]{return CanUse(DINS_FIRE) && SmallKeys(SHADOW_TEMPLE, 6);}}),
LocationAccess(SHADOW_TEMPLE_MQ_BOMB_FLOWER_CHEST, {[]{return true;}}),
//below previously returned true
LocationAccess(SHADOW_TEMPLE_MQ_BOMB_FLOWER_CHEST, {[]{return CanUse(LENS_OF_TRUTH) || LogicLensShadowMQDeadHand;}}),
LocationAccess(SHADOW_TEMPLE_MQ_FREESTANDING_KEY, {[]{return true;}}),
}, {});
}
@ -193,25 +189,24 @@ void AreaTable_Init_ShadowTemple() {
Entrance(SHADOW_TEMPLE_BOSS_ROOM, { [] { return true; } }),
});
areaTable[SHADOW_TEMPLE_BOSS_ROOM] = Area(
"Shadow Temple Boss Room", "Shadow Temple", NONE, NO_DAY_NIGHT_CYCLE,
{
// Events
EventAccess(&ShadowTempleClear, { [] {
return ShadowTempleClear ||
((CanUse(LENS_OF_TRUTH) || ((Dungeon::ShadowTemple.IsVanilla() && LogicLensShadowBack) ||
(Dungeon::ShadowTemple.IsMQ() && LogicLensShadowMQBack))) &&
(CanUse(KOKIRI_SWORD) || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD) || LogicShadowBongo) &&
(CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(SLINGSHOT)));
} }),
},
{
// Locations
LocationAccess(SHADOW_TEMPLE_BONGO_BONGO_HEART, { [] { return ShadowTempleClear; } }),
LocationAccess(BONGO_BONGO, { [] { return ShadowTempleClear; } }),
},
{
// Exits
Entrance(SHADOW_TEMPLE_BOSS_ENTRYWAY, { [] { return false; } }),
});
areaTable[SHADOW_TEMPLE_BOSS_ROOM] =
Area("Shadow Temple Boss Room", "Shadow Temple", NONE, NO_DAY_NIGHT_CYCLE,
{
// Events
EventAccess(&ShadowTempleClear, { [] {
return ShadowTempleClear ||
((CanUse(LENS_OF_TRUTH) || LogicLensBongo) &&
(CanUse(KOKIRI_SWORD) || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD)) &&
(CanUse(HOOKSHOT) || CanUse(BOW) || CanUse(SLINGSHOT) || LogicShadowBongo));
} }),
},
{
// Locations
LocationAccess(SHADOW_TEMPLE_BONGO_BONGO_HEART, { [] { return ShadowTempleClear; } }),
LocationAccess(BONGO_BONGO, { [] { return ShadowTempleClear; } }),
},
{
// Exits
Entrance(SHADOW_TEMPLE_BOSS_ENTRYWAY, { [] { return false; } }),
});
}

26
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_spirit_temple.cpp
View File

@ -33,9 +33,9 @@ void AreaTable_Init_SpiritTemple() {
EventAccess(&NutCrate, {[]{return true;}}),
}, {
//Locations
LocationAccess(SPIRIT_TEMPLE_CHILD_BRIDGE_CHEST, {[]{return (Boomerang || Slingshot || (HasExplosives && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot)));}}),
LocationAccess(SPIRIT_TEMPLE_CHILD_EARLY_TORCHES_CHEST, {[]{return (Boomerang || Slingshot || (HasExplosives && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot))) && (Sticks || CanUse(DINS_FIRE));}}),
LocationAccess(SPIRIT_TEMPLE_GS_METAL_FENCE, {[]{return (Boomerang || Slingshot || (HasExplosives && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot)));}}),
LocationAccess(SPIRIT_TEMPLE_CHILD_BRIDGE_CHEST, {[]{return (Boomerang || Slingshot || (HasBombchus && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot)));}}),
LocationAccess(SPIRIT_TEMPLE_CHILD_EARLY_TORCHES_CHEST, {[]{return (Boomerang || Slingshot || (HasBombchus && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot))) && (Sticks || CanUse(DINS_FIRE));}}),
LocationAccess(SPIRIT_TEMPLE_GS_METAL_FENCE, {[]{return (Boomerang || Slingshot || (HasBombchus && LogicSpiritChildBombchu)) && (HasExplosives || ((Nuts || Boomerang) && (Sticks || KokiriSword || Slingshot)));}}),
}, {
//Exits
Entrance(SPIRIT_TEMPLE_CHILD_CLIMB, {[]{return SmallKeys(SPIRIT_TEMPLE, 1);}}),
@ -86,16 +86,16 @@ void AreaTable_Init_SpiritTemple() {
(CanUse(FIRE_ARROWS) || (LogicSpiritSunChest && Bow)) &&
CanUse(SILVER_GAUNTLETS));}}),
LocationAccess(SPIRIT_TEMPLE_STATUE_ROOM_HAND_CHEST, {[]{return SmallKeys(SPIRIT_TEMPLE, 3) && CanUse(SILVER_GAUNTLETS) && CanPlay(ZeldasLullaby);}}),
LocationAccess(SPIRIT_TEMPLE_STATUE_ROOM_NORTHEAST_CHEST, {[]{return SmallKeys(SPIRIT_TEMPLE, 3) && CanUse(SILVER_GAUNTLETS) && CanPlay(ZeldasLullaby) && (Hookshot || HoverBoots);}}),
LocationAccess(SPIRIT_TEMPLE_STATUE_ROOM_NORTHEAST_CHEST, {[]{return SmallKeys(SPIRIT_TEMPLE, 3) && CanUse(SILVER_GAUNTLETS) && CanPlay(ZeldasLullaby) && (Hookshot || HoverBoots || LogicSpiritLobbyJump);}}),
LocationAccess(SPIRIT_TEMPLE_GS_HALL_AFTER_SUN_BLOCK_ROOM, {[]{return (HasExplosives && Boomerang && Hookshot) ||
(CanUse(BOOMERANG) && SmallKeys(SPIRIT_TEMPLE, 5) && HasExplosives) ||
(Hookshot && CanUse(SILVER_GAUNTLETS) &&
(SmallKeys(SPIRIT_TEMPLE, 3) ||
(SmallKeys(SPIRIT_TEMPLE, 2) && Boomerang && BombchusInLogic && ShuffleDungeonEntrances.Is(SHUFFLEDUNGEONS_OFF))));}}),
LocationAccess(SPIRIT_TEMPLE_GS_LOBBY, {[]{return ((HasExplosives || SmallKeys(SPIRIT_TEMPLE, 3) || (SmallKeys(SPIRIT_TEMPLE, 2) && BombchusInLogic && ShuffleDungeonEntrances.Is(SHUFFLEDUNGEONS_OFF))) &&
LogicSpiritLobbyGS && Boomerang && (Hookshot || HoverBoots)) ||
LogicSpiritLobbyGS && Boomerang && (Hookshot || HoverBoots || LogicSpiritLobbyJump)) ||
(LogicSpiritLobbyGS && SmallKeys(SPIRIT_TEMPLE, 5) && HasExplosives && CanUse(BOOMERANG)) ||
(SmallKeys(SPIRIT_TEMPLE, 3) && CanUse(SILVER_GAUNTLETS) && (Hookshot || HoverBoots));}}),
(SmallKeys(SPIRIT_TEMPLE, 3) && CanUse(SILVER_GAUNTLETS) && (Hookshot || HoverBoots || LogicSpiritLobbyJump));}}),
}, {
//Exits
Entrance(SPIRIT_TEMPLE_OUTDOOR_HANDS, {[]{return true;}}),
@ -164,7 +164,7 @@ void AreaTable_Init_SpiritTemple() {
LocationAccess(SPIRIT_TEMPLE_MQ_CHILD_HAMMER_SWITCH_CHEST, {[]{return Here(SPIRIT_TEMPLE_MQ_ADULT, []{return SmallKeys(SPIRIT_TEMPLE, 7) && Hammer;});}}),
LocationAccess(SPIRIT_TEMPLE_MQ_MAP_ROOM_ENEMY_CHEST, {[]{return KokiriSword && HasBombchus && Slingshot && CanUse(DINS_FIRE);}}),
LocationAccess(SPIRIT_TEMPLE_MQ_MAP_CHEST, {[]{return KokiriSword || Bombs;}}),
LocationAccess(SPIRIT_TEMPLE_MQ_SILVER_BLOCK_HALLWAY_CHEST, {[]{return HasBombchus && SmallKeys(SPIRIT_TEMPLE, 7) && Slingshot && (CanUse(DINS_FIRE) || (Here(SPIRIT_TEMPLE_MQ_ADULT, []{return IsAdult && CanUse(FIRE_ARROWS);})));}}),
LocationAccess(SPIRIT_TEMPLE_MQ_SILVER_BLOCK_HALLWAY_CHEST, {[]{return HasBombchus && SmallKeys(SPIRIT_TEMPLE, 7) && Slingshot && (CanUse(DINS_FIRE) || (Here(SPIRIT_TEMPLE_MQ_ADULT, []{return IsAdult && (CanUse(FIRE_ARROWS) || (LogicSpiritMQFrozenEye && CanUse(BOW) && CanPlay(SongOfTime)));})));}}),
//Trick: HasBombchus && SmallKeys(SPIRIT_TEMPLE, 7) && Slingshot && (CanUse(DINS_FIRE) || (SPIRIT_TEMPLE_MQ_ADULT.Adult() && IsAdult && (CanUse(FIRE_ARROWS) || (LogicSpiritMQFrozenEye && CanUse(BOW) && CanPlay(SongOfTime)))))
}, {
//Exits
@ -183,7 +183,7 @@ void AreaTable_Init_SpiritTemple() {
LocationAccess(SPIRIT_TEMPLE_MQ_GS_NINE_THRONES_ROOM_NORTH, {[]{return SmallKeys(SPIRIT_TEMPLE, 7);}}),
}, {
//Exits
Entrance(SPIRIT_TEMPLE_MQ_LOWER_ADULT, {[]{return (MirrorShield || (SunlightArrows && CanUse(LIGHT_ARROWS))) && IsAdult && CanUse(FIRE_ARROWS);}}),
Entrance(SPIRIT_TEMPLE_MQ_LOWER_ADULT, {[]{return MirrorShield && IsAdult && (CanUse(FIRE_ARROWS) || (LogicSpiritMQLowerAdult && CanUse(DINS_FIRE) && Bow));}}),
//Trick: MirrorShield && IsAdult && (CanUse(FIRE_ARROWS) || (LogicSpiritMQLowerAdult && CanUse(DINS_FIRE) && Bow))
Entrance(SPIRIT_TEMPLE_MQ_SHARED, {[]{return true;}}),
Entrance(SPIRIT_TEMPLE_MQ_BOSS_AREA, {[]{return SmallKeys(SPIRIT_TEMPLE, 6) && CanPlay(ZeldasLullaby) && Hammer;}}),
@ -194,15 +194,15 @@ void AreaTable_Init_SpiritTemple() {
//Locations
LocationAccess(SPIRIT_TEMPLE_MQ_CHILD_CLIMB_NORTH_CHEST, {[]{return SmallKeys(SPIRIT_TEMPLE, 6);}}),
LocationAccess(SPIRIT_TEMPLE_MQ_COMPASS_CHEST, {[]{return (IsChild && CanUse(SLINGSHOT) && SmallKeys(SPIRIT_TEMPLE, 7)) || (IsAdult && CanUse(BOW)) || (Bow && Slingshot);}}),
LocationAccess(SPIRIT_TEMPLE_MQ_SUN_BLOCK_ROOM_CHEST, {[]{return CanPlay(SongOfTime) || IsAdult;}}),
LocationAccess(SPIRIT_TEMPLE_MQ_SUN_BLOCK_ROOM_CHEST, {[]{return CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult;}}),
//Trick: CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult
LocationAccess(SPIRIT_TEMPLE_MQ_GS_SUN_BLOCK_ROOM, {[]{return IsAdult;}}),
//Trick: (LogicSpiritMQSunBlockGS && Boomerange && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT)) || IsAdult
LocationAccess(SPIRIT_TEMPLE_MQ_GS_SUN_BLOCK_ROOM, {[]{return (LogicSpiritMQSunBlockGS && Boomerang && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT)) || IsAdult;}}),
//Trick: (LogicSpiritMQSunBlockGS && Boomerang && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT)) || IsAdult
}, {
//Exits
Entrance(SPIRIT_TEMPLE_MQ_SILVER_GAUNTLETS_HAND, {[]{return (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)));}}),
Entrance(SPIRIT_TEMPLE_MQ_SILVER_GAUNTLETS_HAND, {[]{return (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)));}}),
//Trick: (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)))
Entrance(DESERT_COLOSSUS, {[]{return (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)) && IsAdult);}}),
Entrance(DESERT_COLOSSUS, {[]{return (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)) && IsAdult);}}),
//Trick: (SmallKeys(SPIRIT_TEMPLE, 7) && (CanPlay(SongOfTime) || LogicSpiritMQSunBlockSoT || IsAdult)) || (SmallKeys(SPIRIT_TEMPLE, 4) && CanPlay(SongOfTime) && (LogicLensSpiritMQ || CanUse(LENS_OF_TRUTH)) && IsAdult)
});

82
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_water_temple.cpp
View File

@ -25,42 +25,28 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_LOBBY] = Area("Water Temple Lobby", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(WATER_TEMPLE_ENTRYWAY, {[]{return true;}}),
Entrance(WATER_TEMPLE_EAST_LOWER, {[]{return WaterTempleLow || ((LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && (CanUse(IRON_BOOTS) || (CanUse(LONGSHOT) && LogicWaterTempleTorchLongshot)));},
/*Glitched*/[]{return ((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) || (CanUse(FARORES_WIND) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED))));}}),
Entrance(WATER_TEMPLE_EAST_LOWER, {[]{return WaterTempleLow || ((LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && (CanUse(IRON_BOOTS) || (CanUse(LONGSHOT) && LogicWaterTempleTorchLongshot)));}}),
Entrance(WATER_TEMPLE_NORTH_LOWER, {[]{return WaterTempleLow || ((LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && CanUse(IRON_BOOTS));}}),
Entrance(WATER_TEMPLE_SOUTH_LOWER, {[]{return WaterTempleLow && HasExplosives && (CanDive || CanUse(IRON_BOOTS)) && (LogicFewerTunicRequirements || CanUse(ZORA_TUNIC));},
/*Glitched*/[]{return CanUse(IRON_BOOTS) && (WaterTempleMiddle || WaterTempleHigh) && (LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && AdultCanAccess(WATER_TEMPLE_WEST_LOWER) && CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(WATER_TEMPLE_SOUTH_LOWER, {[]{return WaterTempleLow && HasExplosives && (CanDive || CanUse(IRON_BOOTS)) && (LogicFewerTunicRequirements || CanUse(ZORA_TUNIC));}}),
Entrance(WATER_TEMPLE_WEST_LOWER, {[]{return WaterTempleLow && GoronBracelet && (IsChild || CanDive || CanUse(IRON_BOOTS)) && (LogicFewerTunicRequirements || CanUse(ZORA_TUNIC));}}),
Entrance(WATER_TEMPLE_CENTRAL_PILLAR_LOWER, {[]{return WaterTempleLow && SmallKeys(WATER_TEMPLE, 5);}}),
Entrance(WATER_TEMPLE_CENTRAL_PILLAR_UPPER, {[]{return (WaterTempleLow || WaterTempleMiddle) && (HasFireSourceWithTorch || CanUse(BOW));}}),
Entrance(WATER_TEMPLE_EAST_MIDDLE, {[]{return (WaterTempleLow || WaterTempleMiddle || (CanUse(IRON_BOOTS) && WaterTimer >= 16)) && CanUse(HOOKSHOT);}}),
Entrance(WATER_TEMPLE_WEST_MIDDLE, {[]{return WaterTempleMiddle;},
/*Glitched*/[]{return WaterTempleLow && (CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(WATER_TEMPLE_HIGH_WATER, {[]{return IsAdult && (CanUse(HOVER_BOOTS) || (LogicWaterTempleUpperBoost && Bombs && CanTakeDamage));},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE) || (Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(WATER_TEMPLE_BLOCK_CORRIDOR, {[]{return (WaterTempleLow || WaterTempleMiddle) && (CanUse(SLINGSHOT) || CanUse(BOW)) && (CanUse(LONGSHOT) || CanUse(HOVER_BOOTS) || (LogicWaterCentralBow && (IsAdult || WaterTempleMiddle)));},
/*Glitched*/[]{return (WaterTempleLow || WaterTempleMiddle) && IsAdult && CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(WATER_TEMPLE_FALLING_PLATFORM_ROOM, {[]{return WaterTempleHigh && SmallKeys(WATER_TEMPLE, 4);},
/*Glitched*/[]{return SmallKeys(WATER_TEMPLE, 4) && (CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE));}}),
Entrance(WATER_TEMPLE_PRE_BOSS_ROOM, {[]{return WaterTempleHigh && CanUse(LONGSHOT);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::HammerSlide, GlitchDifficulty::NOVICE) ||
(Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(WATER_TEMPLE_WEST_MIDDLE, {[]{return WaterTempleMiddle;}}),
Entrance(WATER_TEMPLE_HIGH_WATER, {[]{return IsAdult && (CanUse(HOVER_BOOTS) || (LogicDamageBoost && Bombs && CanTakeDamage));}}),
Entrance(WATER_TEMPLE_BLOCK_CORRIDOR, {[]{return (WaterTempleLow || WaterTempleMiddle) && (CanUse(SLINGSHOT) || CanUse(BOW)) && (CanUse(LONGSHOT) || CanUse(HOVER_BOOTS) || (LogicWaterCentralBow && (IsAdult || WaterTempleMiddle)));}}),
Entrance(WATER_TEMPLE_FALLING_PLATFORM_ROOM, {[]{return WaterTempleHigh && SmallKeys(WATER_TEMPLE, 4);}}),
Entrance(WATER_TEMPLE_PRE_BOSS_ROOM, {[]{return WaterTempleHigh && CanUse(LONGSHOT);}}),
});
areaTable[WATER_TEMPLE_EAST_LOWER] = Area("Water Temple East Lower", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&WaterTempleLow, {[]{return WaterTempleLow || CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return ZeldasLullaby && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield &&
((Bombs && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || (HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)))));}}),
EventAccess(&WaterTempleLow, {[]{return WaterTempleLow || CanPlay(ZeldasLullaby);}}),
}, {}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return WaterTempleLow || ((LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && CanUse(IRON_BOOTS));},
/*Glitched*/[]{return ((Bugs || Fish) && CanUse(HOVER_BOOTS) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::INTERMEDIATE)) || (CanUse(FARORES_WIND) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED))));}}),
Entrance(WATER_TEMPLE_LOBBY, {[]{return WaterTempleLow || ((LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && CanUse(IRON_BOOTS));}}),
Entrance(WATER_TEMPLE_MAP_ROOM, {[]{return WaterTempleHigh;}}),
Entrance(WATER_TEMPLE_CRACKED_WALL, {[]{return WaterTempleMiddle || (WaterTempleHigh && WaterTempleLow && ((CanUse(HOVER_BOOTS) && LogicWaterCrackedWallHovers) || LogicWaterCrackedWallNothing));},
/*Glitched*/[]{return WaterTempleHigh && WaterTempleLow && CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
Entrance(WATER_TEMPLE_CRACKED_WALL, {[]{return WaterTempleMiddle || (WaterTempleHigh && WaterTempleLow && ((CanUse(HOVER_BOOTS) && LogicWaterCrackedWallHovers) || LogicWaterCrackedWallNothing));}}),
Entrance(WATER_TEMPLE_TORCH_ROOM, {[]{return WaterTempleLow && (HasFireSourceWithTorch || CanUse(BOW));}}),
});
@ -74,8 +60,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_CRACKED_WALL] = Area("Water Temple Cracked Wall", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_CRACKED_WALL_CHEST, {[]{return HasExplosives;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE);}}),
LocationAccess(WATER_TEMPLE_CRACKED_WALL_CHEST, {[]{return HasExplosives;}}),
}, {
//Exits
Entrance(WATER_TEMPLE_EAST_LOWER, {[]{return true;}}),
@ -92,9 +77,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_NORTH_LOWER] = Area("Water Temple North Lower", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return true;}}),
Entrance(WATER_TEMPLE_BOULDERS_LOWER, {[]{return (CanUse(LONGSHOT) || (LogicWaterBossKeyRegion && CanUse(HOVER_BOOTS))) && SmallKeys(WATER_TEMPLE, 4);},
/*Glitched*/[]{return ((Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)) ||
CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE)) && SmallKeys(WATER_TEMPLE, 4);}}),
Entrance(WATER_TEMPLE_BOULDERS_LOWER, {[]{return (CanUse(LONGSHOT) || (LogicWaterBossKeyRegion && CanUse(HOVER_BOOTS))) && SmallKeys(WATER_TEMPLE, 4);}}),
});
areaTable[WATER_TEMPLE_BOULDERS_LOWER] = Area("Water Temple Boulders Lower", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -110,8 +93,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_BLOCK_ROOM] = Area("Water Temple Block Room", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(WATER_TEMPLE_BOULDERS_LOWER, {[]{return (GoronBracelet && HasExplosives) || CanUse(HOOKSHOT);}}),
Entrance(WATER_TEMPLE_JETS_ROOM, {[]{return (GoronBracelet && HasExplosives) || (CanUse(HOOKSHOT) && CanUse(HOVER_BOOTS));},
/*Glitched*/[]{return CanUse(HOOKSHOT) && CanDoGlitch(GlitchType::Megaflip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(WATER_TEMPLE_JETS_ROOM, {[]{return (GoronBracelet && HasExplosives) || (CanUse(HOOKSHOT) && CanUse(HOVER_BOOTS));}}),
});
areaTable[WATER_TEMPLE_JETS_ROOM] = Area("Water Temple Jets Room", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
@ -140,9 +122,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_SOUTH_LOWER] = Area("Water Temple South Lower", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_GS_BEHIND_GATE, {[]{return CanUse(HOOKSHOT) || (IsAdult && CanUse(HOVER_BOOTS));},
/*Glitched*/[]{return (CanUse(BOOMERANG) && CanDoGlitch(GlitchType::HoverBoost, GlitchDifficulty::INTERMEDIATE)) ||
(Bombs && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
LocationAccess(WATER_TEMPLE_GS_BEHIND_GATE, {[]{return CanUse(HOOKSHOT) || (IsAdult && CanUse(HOVER_BOOTS));}}),
}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return CanUse(IRON_BOOTS);}}),
@ -150,16 +130,14 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_WEST_LOWER] = Area("Water Temple West Lower", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return CanUse(HOOKSHOT) && CanUse(IRON_BOOTS) && GoronBracelet;},
/*Glitched*/[]{return CanUse(IRON_BOOTS) && (LogicFewerTunicRequirements || CanUse(ZORA_TUNIC)) && CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(WATER_TEMPLE_LOBBY, {[]{return CanUse(HOOKSHOT) && CanUse(IRON_BOOTS) && GoronBracelet;}}),
Entrance(WATER_TEMPLE_DRAGON_ROOM, {[]{return IsAdult || CanChildAttack;}}),
});
areaTable[WATER_TEMPLE_DRAGON_ROOM] = Area("Water Temple Dragon Room", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_DRAGON_CHEST, {[]{return (CanUse(HOOKSHOT) && CanUse(IRON_BOOTS)) || (IsAdult && LogicWaterDragonAdult && HasBombchus && (CanDive || CanUse(IRON_BOOTS))) ||
Here(WATER_TEMPLE_RIVER, []{return IsAdult && CanUse(BOW) && ((LogicWaterDragonAdult && (CanDive || CanUse(IRON_BOOTS))) || LogicWaterDragonJumpDive);});},
/*Glitched*/[]{return Bombs && ((IsAdult && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::ADVANCED)) || (CanUse(IRON_BOOTS) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE)));}}),
LocationAccess(WATER_TEMPLE_DRAGON_CHEST, {[]{return (CanUse(HOOKSHOT) && CanUse(IRON_BOOTS)) || (((IsAdult && LogicWaterDragonAdult && (CanUse(HOOKSHOT) || CanUse(BOW) || HasBombchus)) || (IsChild && LogicWaterDragonChild && (CanUse(SLINGSHOT) || CanUse(BOOMERANG) || HasBombchus))) && (CanDive || CanUse(IRON_BOOTS))) ||
Here(WATER_TEMPLE_RIVER, []{return IsAdult && CanUse(BOW) && ((LogicWaterDragonAdult && (CanDive || CanUse(IRON_BOOTS))) || LogicWaterDragonJumpDive);});}}),
}, {
//Exits
Entrance(WATER_TEMPLE_WEST_LOWER, {[]{return true;}}),
@ -169,18 +147,15 @@ void AreaTable_Init_WaterTemple() {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return SmallKeys(WATER_TEMPLE, 5);}}),
Entrance(WATER_TEMPLE_CENTRAL_PILLAR_UPPER, {[]{return CanUse(HOOKSHOT);}}),
Entrance(WATER_TEMPLE_CENTRAL_PILLAR_BASEMENT, {[]{return WaterTempleMiddle && CanUse(IRON_BOOTS) && WaterTimer >= 40;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::NOVICE) && CanUse(IRON_BOOTS) && WaterTimer >= 40;}}),
Entrance(WATER_TEMPLE_CENTRAL_PILLAR_BASEMENT, {[]{return WaterTempleMiddle && CanUse(IRON_BOOTS) && WaterTimer >= 40;}}),
});
areaTable[WATER_TEMPLE_CENTRAL_PILLAR_UPPER] = Area("Water Temple Central Pillar Upper", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&WaterTempleMiddle, {[]{return WaterTempleMiddle || CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return ZeldasLullaby && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield &&
(CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) || (HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)))));}}),
EventAccess(&WaterTempleMiddle, {[]{return WaterTempleMiddle || CanPlay(ZeldasLullaby);}}),
}, {
//Locations
LocationAccess(WATER_TEMPLE_GS_CENTRAL_PILLAR, {[]{return CanUse(LONGSHOT) || (LogicWaterCentralGSFW && WaterTempleHigh && CanUse(FARORES_WIND) && HookshotOrBoomerang);}}),
LocationAccess(WATER_TEMPLE_GS_CENTRAL_PILLAR, {[]{return CanUse(LONGSHOT) || (((LogicWaterCentralGSFW && CanUse(FARORES_WIND) && (CanUse(BOW) || CanUse(DINS_FIRE) || SmallKeys(WATER_TEMPLE, 5))) || (LogicWaterCentralGSIrons && CanUse(IRON_BOOTS) && ((CanUse(HOOKSHOT) && CanUse(BOW)) || (CanUse(DINS_FIRE))))) && WaterTempleHigh && HookshotOrBoomerang);}}),
}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return true;}}),
@ -211,9 +186,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_HIGH_WATER] = Area("Water Temple High Water", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {
//Events
EventAccess(&WaterTempleHigh, {[]{return WaterTempleHigh || CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return ZeldasLullaby && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield &&
(CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) || (HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)))));}}),
EventAccess(&WaterTempleHigh, {[]{return WaterTempleHigh || CanPlay(ZeldasLullaby);}}),
}, {}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return true;}}),
@ -221,8 +194,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_BLOCK_CORRIDOR] = Area("Water Temple Block Corridor", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_CENTRAL_BOW_TARGET_CHEST, {[]{return GoronBracelet && (WaterTempleLow || WaterTempleMiddle);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::INTERMEDIATE) && (WaterTempleLow || WaterTempleMiddle);}}),
LocationAccess(WATER_TEMPLE_CENTRAL_BOW_TARGET_CHEST, {[]{return GoronBracelet && (WaterTempleLow || WaterTempleMiddle);}}),
}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return CanUse(HOOKSHOT);}}),
@ -230,7 +202,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_FALLING_PLATFORM_ROOM] = Area("Water Temple Falling Platform Room", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_GS_FALLING_PLATFORM_ROOM, {[]{return CanUse(LONGSHOT) || (LogicWaterFallingPlatformGS && IsAdult && HookshotOrBoomerang);}}),
LocationAccess(WATER_TEMPLE_GS_FALLING_PLATFORM_ROOM, {[]{return CanUse(LONGSHOT) || (LogicWaterFallingPlatformGSBoomerang && IsChild && CanUse(BOOMERANG)) || (LogicWaterFallingPlatformGSHookshot && IsAdult && CanUse(HOOKSHOT));}}),
}, {
//Exits
Entrance(WATER_TEMPLE_LOBBY, {[]{return CanUse(HOOKSHOT) && SmallKeys(WATER_TEMPLE, 4);}}),
@ -255,9 +227,7 @@ void AreaTable_Init_WaterTemple() {
}, {
//Exits
Entrance(WATER_TEMPLE_DARK_LINK_ROOM, {[]{return true;}}),
Entrance(WATER_TEMPLE_RIVER, {[]{return IsChild || CanPlay(SongOfTime);},
/*Glitched*/[]{return SongOfTime && (CanDoGlitch(GlitchType::DungeonBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield &&
(CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED) || (HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED)))));}}),
Entrance(WATER_TEMPLE_RIVER, {[]{return IsChild || CanPlay(SongOfTime);}}),
});
areaTable[WATER_TEMPLE_RIVER] = Area("Water Temple River", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
@ -294,7 +264,7 @@ void AreaTable_Init_WaterTemple() {
areaTable[WATER_TEMPLE_MQ_DIVE] = Area("Water Temple MQ Dive", "Water Temple", WATER_TEMPLE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(WATER_TEMPLE_MQ_MAP_CHEST, {[]{return HasFireSource && IsAdult && CanUse(HOOKSHOT);}}),
LocationAccess(WATER_TEMPLE_MQ_CENTRAL_PILLAR_CHEST, {[]{return IsAdult && CanUse(ZORA_TUNIC) && CanUse(HOOKSHOT) && (CanUse(DINS_FIRE) && CanPlay(SongOfTime));}}),
LocationAccess(WATER_TEMPLE_MQ_CENTRAL_PILLAR_CHEST, {[]{return IsAdult && CanUse(ZORA_TUNIC) && CanUse(HOOKSHOT) && ((LogicWaterMQCentralPillar && CanUse(FIRE_ARROWS)) || (CanUse(DINS_FIRE) && CanPlay(SongOfTime)));}}),
//Trick: IsAdult && CanUse(ZORA_TUNIC) && CanUse(HOOKSHOT) && ((LogicWaterMQCentralPillar && CanUse(FIRE_ARROWS)) || (CanUse(DINS_FIRE) && CanPlay(SongOfTime)))
}, {
//Exits
@ -326,7 +296,7 @@ void AreaTable_Init_WaterTemple() {
//Locations
LocationAccess(WATER_TEMPLE_MQ_FREESTANDING_KEY, {[]{return HoverBoots || CanUse(SCARECROW) || LogicWaterNorthBasementLedgeJump;}}),
LocationAccess(WATER_TEMPLE_MQ_GS_TRIPLE_WALL_TORCH, {[]{return CanUse(FIRE_ARROWS) && (HoverBoots || CanUse(SCARECROW));}}),
LocationAccess(WATER_TEMPLE_MQ_GS_FREESTANDING_KEY_AREA, {[]{return SmallKeys(WATER_TEMPLE, 2) && (HoverBoots || CanUse(SCARECROW) || LogicWaterNorthBasementLedgeJump);}}),
LocationAccess(WATER_TEMPLE_MQ_GS_FREESTANDING_KEY_AREA, {[]{return LogicWaterMQLockedGS || (SmallKeys(WATER_TEMPLE, 2) && (HoverBoots || CanUse(SCARECROW) || LogicWaterNorthBasementLedgeJump));}}),
//Trick: LogicWaterMQLockedGS || (SmallKeys(WATER_TEMPLE, 2) && (HoverBoots || CanUse(SCARECROW) || LogicWaterNorthBasementLedgeJump))
}, {});
}

85
soh/soh/Enhancements/randomizer/3drando/location_access/locacc_zoras_domain.cpp
View File

@ -11,8 +11,7 @@ void AreaTable_Init_ZorasDomain() {
LocationAccess(ZR_GS_TREE, {[]{return IsChild && CanChildAttack;}}),
}, {
//Exits
Entrance(ZORAS_RIVER, {[]{return IsAdult || CanBlastOrSmash;},
/*Glitched*/[]{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);}}),
Entrance(ZORAS_RIVER, {[]{return IsAdult || CanBlastOrSmash;}}),
Entrance(HYRULE_FIELD, {[]{return true;}}),
});
@ -25,27 +24,13 @@ void AreaTable_Init_ZorasDomain() {
}, {
//Locations
LocationAccess(ZR_MAGIC_BEAN_SALESMAN, {[]{return IsChild;}}),
LocationAccess(ZR_FROGS_OCARINA_GAME, {[]{return IsChild && CanPlay(ZeldasLullaby) && CanPlay(SariasSong) && CanPlay(SunsSong) && CanPlay(EponasSong) && CanPlay(SongOfTime) && CanPlay(SongOfStorms);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && ZeldasLullaby && SariasSong && SunsSong && EponasSong && SongOfTime && SongOfStorms;}}),
LocationAccess(ZR_FROGS_IN_THE_RAIN, {[]{return IsChild && CanPlay(SongOfStorms);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && SongOfStorms;}}),
LocationAccess(ZR_FROGS_ZELDAS_LULLABY, {[]{return IsChild && CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && ZeldasLullaby;}}),
LocationAccess(ZR_FROGS_EPONAS_SONG, {[]{return IsChild && CanPlay(EponasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && EponasSong;}}),
LocationAccess(ZR_FROGS_SARIAS_SONG, {[]{return IsChild && CanPlay(SariasSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && SariasSong;}}),
LocationAccess(ZR_FROGS_SUNS_SONG, {[]{return IsChild && CanPlay(SunsSong);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && SunsSong;}}),
LocationAccess(ZR_FROGS_SONG_OF_TIME, {[]{return IsChild && CanPlay(SongOfTime);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::ADVANCED) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && IsChild && SongOfTime;}}),
LocationAccess(ZR_FROGS_OCARINA_GAME, {[]{return IsChild && CanPlay(ZeldasLullaby) && CanPlay(SariasSong) && CanPlay(SunsSong) && CanPlay(EponasSong) && CanPlay(SongOfTime) && CanPlay(SongOfStorms);}}),
LocationAccess(ZR_FROGS_IN_THE_RAIN, {[]{return IsChild && CanPlay(SongOfStorms);}}),
LocationAccess(ZR_FROGS_ZELDAS_LULLABY, {[]{return IsChild && CanPlay(ZeldasLullaby);}}),
LocationAccess(ZR_FROGS_EPONAS_SONG, {[]{return IsChild && CanPlay(EponasSong);}}),
LocationAccess(ZR_FROGS_SARIAS_SONG, {[]{return IsChild && CanPlay(SariasSong);}}),
LocationAccess(ZR_FROGS_SUNS_SONG, {[]{return IsChild && CanPlay(SunsSong);}}),
LocationAccess(ZR_FROGS_SONG_OF_TIME, {[]{return IsChild && CanPlay(SongOfTime);}}),
LocationAccess(ZR_NEAR_OPEN_GROTTO_FREESTANDING_POH, {[]{return IsChild || CanUse(HOVER_BOOTS) || (IsAdult && LogicZoraRiverLower);}}),
LocationAccess(ZR_NEAR_DOMAIN_FREESTANDING_POH, {[]{return IsChild || CanUse(HOVER_BOOTS) || (IsAdult && LogicZoraRiverUpper);}}),
LocationAccess(ZR_GS_LADDER, {[]{return IsChild && AtNight && CanChildAttack && CanGetNightTimeGS;}}),
@ -57,17 +42,10 @@ void AreaTable_Init_ZorasDomain() {
//Exits
Entrance(ZR_FRONT, {[]{return true;}}),
Entrance(ZR_OPEN_GROTTO, {[]{return true;}}),
Entrance(ZR_FAIRY_GROTTO, {[]{return Here(ZORAS_RIVER, []{return CanBlastOrSmash;});},
/*Glitched*/[]{return Here(ZORAS_RIVER, []{return CanUse(STICKS) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED);});}}),
Entrance(THE_LOST_WOODS, {[]{return CanDive || CanUse(IRON_BOOTS);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::INTERMEDIATE) || (CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || (IsAdult && (HasBoots || ClaimCheck)) || (IsChild && WeirdEgg)))) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED))));}}),
Entrance(ZR_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(ZR_BEHIND_WATERFALL, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::HookshotJump_Boots, GlitchDifficulty::ADVANCED) || ((CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) ||
((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) || ((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby);}}),
Entrance(ZR_FAIRY_GROTTO, {[]{return Here(ZORAS_RIVER, []{return CanBlastOrSmash;});}}),
Entrance(THE_LOST_WOODS, {[]{return CanDive || CanUse(IRON_BOOTS);}}),
Entrance(ZR_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
Entrance(ZR_BEHIND_WATERFALL, {[]{return CanPlay(ZeldasLullaby) || (IsChild && LogicZoraWithCucco) || (IsAdult && CanUse(HOVER_BOOTS) && LogicZoraWithHovers);}}),
});
areaTable[ZR_BEHIND_WATERFALL] = Area("ZR Behind Waterfall", "Zora River", NONE, DAY_NIGHT_CYCLE, {}, {}, {
@ -117,28 +95,20 @@ void AreaTable_Init_ZorasDomain() {
LocationAccess(ZD_CHEST, {[]{return IsChild && CanUse(STICKS);}}),
LocationAccess(ZD_KING_ZORA_THAWED, {[]{return KingZoraThawed;}}),
LocationAccess(ZD_TRADE_PRESCRIPTION, {[]{return KingZoraThawed && Prescription;}}),
LocationAccess(ZD_GS_FROZEN_WATERFALL, {[]{return IsAdult && AtNight && (HookshotOrBoomerang || CanUse(SLINGSHOT) || Bow || MagicMeter) && CanGetNightTimeGS;}}),
LocationAccess(ZD_GS_FROZEN_WATERFALL, {[]{return IsAdult && AtNight && (HookshotOrBoomerang || CanUse(SLINGSHOT) || Bow || MagicMeter || LogicDomainGS) && CanGetNightTimeGS;}}),
LocationAccess(ZD_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
Entrance(ZR_BEHIND_WATERFALL, {[]{return true;}}),
Entrance(LAKE_HYLIA, {[]{return IsChild && (CanDive || CanUse(IRON_BOOTS));},
/*Glitched*/[]{return (IsAdult && GlitchZDOoBJumpSlash) || (IsChild && CanUse(FARORES_WIND) && (FaroresWindAnywhere || (CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE) && (HasBottle || WeirdEgg))) &&
((CanUse(NAYRUS_LOVE) && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::NOVICE)) || (CanUseMagicArrow && CanDoGlitch(GlitchType::CutsceneDive, GlitchDifficulty::ADVANCED))));}}),
Entrance(ZD_BEHIND_KING_ZORA, {[]{return DeliverLetter || ZorasFountain.Is(ZORASFOUNTAIN_OPEN) || (ZorasFountain.Is(ZORASFOUNTAIN_ADULT) && IsAdult);},
/*Glitched*/[]{return ((IsChild || CanUse(IRON_BOOTS)) && CanDoGlitch(GlitchType::TripleSlashClip, GlitchDifficulty::NOVICE)) || CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::NOVICE) ||
CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::NOVICE) || CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) || CanDoGlitch(GlitchType::LedgeClip, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(ZD_SHOP, {[]{return IsChild || BlueFire;},
/*Glitched*/[]{return GlitchZDOoBJumpSlash.Value<bool>();}}),
Entrance(ZD_STORMS_GROTTO, {[]{return CanOpenStormGrotto;},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && SongOfStorms && (ShardOfAgony || LogicGrottosWithoutAgony);}}),
Entrance(LAKE_HYLIA, {[]{return IsChild && (CanDive || CanUse(IRON_BOOTS));}}),
Entrance(ZD_BEHIND_KING_ZORA, {[]{return DeliverLetter || ZorasFountain.Is(ZORASFOUNTAIN_OPEN) || (ZorasFountain.Is(ZORASFOUNTAIN_ADULT) && IsAdult) || (LogicKingZoraSkip && IsAdult);}}),
Entrance(ZD_SHOP, {[]{return IsChild || BlueFire;}}),
Entrance(ZD_STORMS_GROTTO, {[]{return CanOpenStormGrotto;}}),
});
areaTable[ZD_BEHIND_KING_ZORA] = Area("ZD Behind King Zora", "Zoras Domain", NONE, NO_DAY_NIGHT_CYCLE, {}, {}, {
//Exits
Entrance(ZORAS_DOMAIN, {[]{return DeliverLetter || ZorasFountain.Is(ZORASFOUNTAIN_OPEN) || (ZorasFountain.Is(ZORASFOUNTAIN_ADULT) && IsAdult);},
/*Glitched*/[]{return CanDoGlitch(GlitchType::ASlide, GlitchDifficulty::NOVICE) || (CanUse(LONGSHOT) && CanDoGlitch(GlitchType::HookshotClip, GlitchDifficulty::NOVICE)) || (Bombs && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE) && CanDoGlitch(GlitchType::ISG, GlitchDifficulty::INTERMEDIATE));}}),
Entrance(ZORAS_DOMAIN, {[]{return DeliverLetter || ZorasFountain.Is(ZORASFOUNTAIN_OPEN) || (ZorasFountain.Is(ZORASFOUNTAIN_ADULT) && IsAdult);}}),
Entrance(ZORAS_FOUNTAIN, {[]{return true;}}),
});
@ -174,28 +144,21 @@ void AreaTable_Init_ZorasDomain() {
LocationAccess(ZF_ICEBERG_FREESTANDING_POH, {[]{return IsAdult;}}),
LocationAccess(ZF_BOTTOM_FREESTANDING_POH, {[]{return IsAdult && IronBoots && WaterTimer >= 24;}}),
LocationAccess(ZF_GS_TREE, {[]{return IsChild;}}),
LocationAccess(ZF_GS_ABOVE_THE_LOG, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return IsChild && AtNight && CanGetNightTimeGS && HasBombchus && CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::NOVICE);}}),
LocationAccess(ZF_GS_HIDDEN_CAVE, {[]{return CanUse(SILVER_GAUNTLETS) && CanBlastOrSmash && HookshotOrBoomerang && IsAdult && AtNight && CanGetNightTimeGS;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::LedgeCancel, GlitchDifficulty::INTERMEDIATE) && IsAdult && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(ZF_GS_ABOVE_THE_LOG, {[]{return IsChild && HookshotOrBoomerang && AtNight && CanGetNightTimeGS;}}),
LocationAccess(ZF_GS_HIDDEN_CAVE, {[]{return CanUse(SILVER_GAUNTLETS) && CanBlastOrSmash && HookshotOrBoomerang && IsAdult && AtNight && CanGetNightTimeGS;}}),
LocationAccess(ZF_FAIRY_GOSSIP_STONE, {[]{return true;}}),
LocationAccess(ZF_JABU_GOSSIP_STONE, {[]{return true;}}),
}, {
//Exits
Entrance(ZD_BEHIND_KING_ZORA, {[]{return true;}}),
Entrance(JABU_JABUS_BELLY_ENTRYWAY, {[]{return (IsChild && Fish);},
/*Glitched*/[]{return (IsChild && CanUse(STICKS) && GlitchJabuStickRecoil) || (IsAdult && GlitchJabuAdult);}}),
Entrance(ICE_CAVERN_ENTRYWAY, {[]{return IsAdult;},
/*Glitched*/[]{return CanDoGlitch(GlitchType::BombHover, GlitchDifficulty::INTERMEDIATE);}}),
Entrance(ZF_GREAT_FAIRY_FOUNTAIN, {[]{return HasExplosives || (CanUse(SILVER_GAUNTLETS) && Hammer && LogicZFGreatFairy);},
/*Glitched*/[]{return IsChild && (KokiriSword || Sticks) && CanShield && (CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::ADVANCED) || (CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) && CanDoGlitch(GlitchType::SeamWalk, GlitchDifficulty::INTERMEDIATE)));}}),
Entrance(JABU_JABUS_BELLY_ENTRYWAY, {[]{return (IsChild && Fish);}}),
Entrance(ICE_CAVERN_ENTRYWAY, {[]{return IsAdult;}}),
Entrance(ZF_GREAT_FAIRY_FOUNTAIN, {[]{return HasExplosives;}}),
});
areaTable[ZF_GREAT_FAIRY_FOUNTAIN] = Area("ZF Great Fairy Fountain", "ZF Great Fairy Fountain", NONE, NO_DAY_NIGHT_CYCLE, {}, {
//Locations
LocationAccess(ZF_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);},
/*Glitched*/[]{return (CanDoGlitch(GlitchType::OutdoorBombOI, GlitchDifficulty::INTERMEDIATE) || ((Bugs || Fish) && CanShield && (CanSurviveDamage || (Fairy && NumBottles >= 2)) && CanDoGlitch(GlitchType::QPA, GlitchDifficulty::ADVANCED)) ||
((Bugs || Fish) && CanShield && HasBombchus && CanDoGlitch(GlitchType::ActionSwap, GlitchDifficulty::ADVANCED))) && ZeldasLullaby;}}),
LocationAccess(ZF_GREAT_FAIRY_REWARD, {[]{return CanPlay(ZeldasLullaby);}}),
}, {
//Exits
Entrance(ZORAS_FOUNTAIN, {[]{return true;}}),

286
soh/soh/Enhancements/randomizer/3drando/logic.cpp
View File

@ -286,11 +286,15 @@ namespace Logic {
bool CanFinishGerudoFortress = false;
bool HasShield = false;
bool CanShield = false;
bool CanJumpslash = false;
bool CanUseProjectile = false;
bool CanUseMagicArrow = false;
bool HasShield = false;
bool CanShield = false;
bool ChildShield = false;
bool AdultReflectShield = false;
bool AdultShield = false;
bool CanShieldFlick = false;
bool CanJumpslash = false;
bool CanUseProjectile = false;
bool CanUseMagicArrow = false;
//Bridge and LACS Requirements
uint8_t StoneCount = 0;
@ -466,202 +470,24 @@ namespace Logic {
return 0;
}
bool CanDoGlitch(GlitchType glitch, GlitchDifficulty difficulty) {
uint8_t setDifficulty;
switch (glitch) {
//Restricted Items
case GlitchType::RestrictedItems:
setDifficulty = GetDifficultyValueFromString(GlitchRestrictedItems);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
//todo rewrite glitch section
bool CanEquipSwap(uint32_t itemName) {
if (!HasItem(itemName))
return false;
if (CanDoGlitch(GlitchType::EquipSwapDins) || CanDoGlitch(GlitchType::EquipSwap))
return true;
//Super Stab
case GlitchType::SuperStab:
setDifficulty = GetDifficultyValueFromString(GlitchSuperStab);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return CanShield && CanUse(STICKS);
return false;
}
//Infinite Sword Glitch
case GlitchType::ISG:
setDifficulty = GetDifficultyValueFromString(GlitchISG);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return CanShield && (IsAdult || KokiriSword || Sticks);
//Bomb Hover
case GlitchType::BombHover:
setDifficulty = GetDifficultyValueFromString(GlitchHover);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return CanDoGlitch(GlitchType::ISG, GlitchDifficulty::NOVICE) && (HasBombchus || (Bombs && setDifficulty >= static_cast<uint8_t>(GlitchDifficulty::ADVANCED)));
//Bomb Ocarina Items
case GlitchType::BombOI:
setDifficulty = GetDifficultyValueFromString(GlitchBombOI);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return Bombs && CanSurviveDamage;
case GlitchType::OutdoorBombOI:
return ((CanUse(FARORES_WIND) && (DinsFire || NayrusLove || LensOfTruth || HasBottle || HasBombchus || Nuts || StartingConsumables ||
(IsChild && (Sticks || ProgressiveBulletBag || (MagicBean || MagicBeanPack) || Boomerang || WeirdEgg || (Hammer && HammerAsChild))) ||
(IsAdult && (ProgressiveBow || Hookshot || HasBoots || Hammer || (Sticks && StickAsAdult) || (Boomerang && BoomerangAsAdult)))) &&
CanDoGlitch(GlitchType::BombOI, (static_cast<uint8_t>(difficulty) >= 3) ? difficulty : GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE)) ||
(((IsAdult && ClaimCheck) || Bugs || Fish || Fairy || (!NeedNayrusLove && (CanUse(NAYRUS_LOVE) || CanUse(DINS_FIRE))) ||
(CanUse(FARORES_WIND) && FaroresWindAnywhere)) && CanDoGlitch(GlitchType::BombOI, difficulty)));
case GlitchType::WindmillBombOI:
return (((CanUse(FARORES_WIND) || (!NeedNayrusLove && (NayrusLove || DinsFire))) && (LensOfTruth || HasBottle || HasBombchus || Nuts || StartingConsumables ||
(IsChild && (Sticks || ProgressiveBulletBag || (MagicBean || MagicBeanPack) || Boomerang || WeirdEgg || (Hammer && HammerAsChild))) ||
(IsAdult && (ProgressiveBow || Hookshot || HasBoots || Hammer || (Sticks && StickAsAdult) || (Boomerang && BoomerangAsAdult)))) &&
CanDoGlitch(GlitchType::BombOI, (static_cast<uint8_t>(difficulty) >= 3) ? difficulty : GlitchDifficulty::ADVANCED) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE)) ||
(((IsAdult && ClaimCheck) || Bugs || Fish || Fairy || (CanUse(FARORES_WIND) && FaroresWindAnywhere)) && CanDoGlitch(GlitchType::BombOI, difficulty)));
case GlitchType::IndoorBombOI:
return (((IsAdult && ClaimCheck) && (HasBottle || HasBoots || (CanUse(FARORES_WIND) && FaroresWindAnywhere))) ||
((Bugs || Fish || Fairy) && (NumBottles >= 2 || (IsAdult && (ClaimCheck || HasBoots)) || (IsChild && WeirdEgg) || (CanUse(FARORES_WIND) && FaroresWindAnywhere))) ||
((CanUse(FARORES_WIND) && FaroresWindAnywhere) && (HasBottle || (IsAdult && (ClaimCheck || HasBoots)) || (IsChild && WeirdEgg))) ||
(((!NeedNayrusLove && (CanUse(NAYRUS_LOVE) || CanUse(DINS_FIRE))) || CanUse(FARORES_WIND)) &&
(NumBottles + ((IsChild) ? ((WeirdEgg) ? 1 : 0) : (((IronBoots) ? 1 : 0) + ((HoverBoots) ? 1 : 0) + ((ClaimCheck) ? 1 : 0))) >= 2))) &&
CanDoGlitch(GlitchType::BombOI, difficulty) && CanDoGlitch(GlitchType::RestrictedItems, GlitchDifficulty::NOVICE);
case GlitchType::DungeonBombOI:
return ((IsAdult && ClaimCheck) || Bugs || Fish || Fairy || (!NeedNayrusLove && (CanUse(NAYRUS_LOVE) || CanUse(DINS_FIRE))) || (CanUse(FARORES_WIND))) && CanDoGlitch(GlitchType::BombOI, difficulty);
//Hover Boost
case GlitchType::HoverBoost:
setDifficulty = GetDifficultyValueFromString(GlitchHoverBoost);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return Bombs && CanUse(HOVER_BOOTS) && CanSurviveDamage;
//Super Slide
case GlitchType::SuperSlide:
setDifficulty = GetDifficultyValueFromString(GlitchSuperSlide);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return true;
//Megaflip
case GlitchType::Megaflip:
setDifficulty = GetDifficultyValueFromString(GlitchMegaflip);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
// Bombchu megaflips should be considered 2 difficulty levels higher
return CanShield && (Bombs || (HasBombchus && setDifficulty >= static_cast<uint8_t>(difficulty) + 2));
//A-Slide
case GlitchType::ASlide:
setDifficulty = GetDifficultyValueFromString(GlitchASlide);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
// Same deal as bombchu megaflips
return IsChild && CanShield && (Bombs || (HasBombchus && setDifficulty >= static_cast<uint8_t>(difficulty) + 2));
//Hammer Slide
case GlitchType::HammerSlide:
setDifficulty = GetDifficultyValueFromString(GlitchHammerSlide);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return CanUse(MEGATON_HAMMER) && CanUse(HOVER_BOOTS) && CanShield;
//Ledge Cancel
case GlitchType::LedgeCancel:
setDifficulty = GetDifficultyValueFromString(GlitchLedgeCancel);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
// Similar to bombchu megaflips / A-slides but doesn't scale beyond advanced
return CanShield && (Bombs || (HasBombchus && setDifficulty >= static_cast<uint8_t>(GlitchDifficulty::ADVANCED)));
//Action Swap
case GlitchType::ActionSwap:
setDifficulty = GetDifficultyValueFromString(GlitchActionSwap);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return true;
//Quick Put Away
case GlitchType::QPA:
setDifficulty = GetDifficultyValueFromString(GlitchQPA);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
// Boot Put Away Delay Method Frame Perfect Method Ledge Grab Method
return (CanTakeDamage && Bombs && ((CanUse(HOVER_BOOTS) || CanUse(IRON_BOOTS)) || setDifficulty >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE))) || setDifficulty >= static_cast<uint8_t>(GlitchDifficulty::ADVANCED);
//Hookshot Clip
case GlitchType::HookshotClip:
setDifficulty = GetDifficultyValueFromString(GlitchHookshotClip);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return CanUse(HOOKSHOT);
//Hookshot Jump: Bonk
case GlitchType::HookshotJump_Bonk:
setDifficulty = GetDifficultyValueFromString(GlitchHookshotJump_Bonk);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return IsAdult && Hookshot; // Child hookshot jumps are tiny so these stay as adult only until I check
//Hookshot Jump: Boots
case GlitchType::HookshotJump_Boots:
setDifficulty = GetDifficultyValueFromString(GlitchHookshotJump_Boots);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return IsAdult && Hookshot && HasBoots; // Child hookshot jumps are tiny so these stay as adult only until I check
//Cutscene Dives
case GlitchType::CutsceneDive:
setDifficulty = GetDifficultyValueFromString(GlitchCutsceneDive);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return true;
//Navi Dives without TSC
case GlitchType::NaviDive_Stick:
setDifficulty = GetDifficultyValueFromString(GlitchNaviDive_Stick);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return IsChild && Sticks;
//Triple Slash Clip
case GlitchType::TripleSlashClip:
setDifficulty = GetDifficultyValueFromString(GlitchTripleSlashClip);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return IsAdult || KokiriSword;
//Ledge Clip
case GlitchType::LedgeClip:
setDifficulty = GetDifficultyValueFromString(GlitchLedgeClip);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return IsAdult;
//Seam Walks
case GlitchType::SeamWalk:
setDifficulty = GetDifficultyValueFromString(GlitchSeamWalk);
if (setDifficulty < static_cast<uint8_t>(difficulty)) {
return false;
}
return true;
bool CanDoGlitch(GlitchType glitch) {
switch(glitch) {
case GlitchType::EquipSwapDins:
return ((IsAdult && HasItem(DINS_FIRE)) || (IsChild && (HasItem(STICKS) || HasItem(DINS_FIRE)))) && GlitchEquipSwapDins;
case GlitchType::EquipSwap: // todo: add bunny hood to adult item equippable list and child trade item to child item equippable list
return ((IsAdult && (HasItem(DINS_FIRE) || HasItem(FARORES_WIND) || HasItem(NAYRUS_LOVE))) || (IsChild && (HasItem(STICKS) || HasItem(SLINGSHOT) || HasItem(BOOMERANG) || HasBottle || Nuts || Ocarina || HasItem(LENS_OF_TRUTH) || HasExplosives || (MagicBean || MagicBeanPack) || HasItem(DINS_FIRE) || HasItem(FARORES_WIND) || HasItem(NAYRUS_LOVE)))) && GlitchEquipSwap;
}
//Shouldn't be reached
@ -767,11 +593,15 @@ namespace Logic {
(GerudoFortress.Is(GERUDOFORTRESS_FAST) && GerudoFortressKeys >= 1 && (IsAdult || KokiriSword || CanUse(MASTER_SWORD) || CanUse(BIGGORON_SWORD))) ||
(GerudoFortress.IsNot(GERUDOFORTRESS_NORMAL) && GerudoFortress.IsNot(GERUDOFORTRESS_FAST));
HasShield = CanUse(HYLIAN_SHIELD) || CanUse(DEKU_SHIELD); //Mirror shield can't reflect attacks
CanShield = CanUse(MIRROR_SHIELD) || HasShield;
CanJumpslash = IsAdult || Sticks || KokiriSword;
CanUseProjectile = HasExplosives || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(SLINGSHOT) || CanUse(BOOMERANG);
CanUseMagicArrow = CanUse(FIRE_ARROWS) || CanUse(ICE_ARROWS) || CanUse(LIGHT_ARROWS);
HasShield = CanUse(HYLIAN_SHIELD) || CanUse(DEKU_SHIELD); //Mirror shield can't reflect attacks
CanShield = CanUse(MIRROR_SHIELD) || HasShield;
ChildShield = IsChild && CanUse(DEKU_SHIELD); //hylian shield is not helpful for child
AdultReflectShield = IsAdult && CanUse(HYLIAN_SHIELD); //Mirror shield can't reflect attacks
AdultShield = IsAdult && (CanUse(HYLIAN_SHIELD) || CanUse(MIRROR_SHIELD));
CanShieldFlick = ChildShield || AdultShield;
CanJumpslash = IsAdult || Sticks || KokiriSword;
CanUseProjectile = HasExplosives || CanUse(BOW) || CanUse(HOOKSHOT) || CanUse(SLINGSHOT) || CanUse(BOOMERANG);
CanUseMagicArrow = CanUse(FIRE_ARROWS) || CanUse(ICE_ARROWS) || CanUse(LIGHT_ARROWS);
//Bridge and LACS Requirements
MedallionCount = (ForestMedallion ? 1:0) + (FireMedallion ? 1:0) + (WaterMedallion ? 1:0) + (SpiritMedallion ? 1:0) + (ShadowMedallion ? 1:0) + (LightMedallion ? 1:0);
@ -806,58 +636,58 @@ namespace Logic {
bool SmallKeys(Key dungeon, uint8_t requiredAmountGlitchless, uint8_t requiredAmountGlitched) {
switch (dungeon) {
case FOREST_TEMPLE:
if (IsGlitched && (GetDifficultyValueFromString(GlitchHookshotJump_Boots) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE) || GetDifficultyValueFromString(GlitchHoverBoost) >= static_cast<uint8_t>(GlitchDifficulty::NOVICE) ||
/*if (IsGlitched && (GetDifficultyValueFromString(GlitchHookshotJump_Boots) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE) || GetDifficultyValueFromString(GlitchHoverBoost) >= static_cast<uint8_t>(GlitchDifficulty::NOVICE) ||
(GetDifficultyValueFromString(GlitchHover) >= static_cast<uint8_t>(GlitchDifficulty::NOVICE) && GetDifficultyValueFromString(GlitchISG) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE)))) {
return ForestTempleKeys >= requiredAmountGlitched;
}
}*/
return ForestTempleKeys >= requiredAmountGlitchless;
case FIRE_TEMPLE:
if (IsGlitched && (GetDifficultyValueFromString(GlitchLedgeClip) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE) || GetDifficultyValueFromString(GlitchHover) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE))) {
/*if (IsGlitched && (GetDifficultyValueFromString(GlitchLedgeClip) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE) || GetDifficultyValueFromString(GlitchHover) >= static_cast<uint8_t>(GlitchDifficulty::INTERMEDIATE))) {
return FireTempleKeys >= requiredAmountGlitched;
}
}*/
return FireTempleKeys >= requiredAmountGlitchless;
case WATER_TEMPLE:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return WaterTempleKeys >= requiredAmountGlitched;
}
}*/
return WaterTempleKeys >= requiredAmountGlitchless;
case SPIRIT_TEMPLE:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return SpiritTempleKeys >= requiredAmountGlitched;
}
}*/
return SpiritTempleKeys >= requiredAmountGlitchless;
case SHADOW_TEMPLE:
if (IsGlitched && (GetDifficultyValueFromString(GlitchHookshotClip) >= static_cast<uint8_t>(GlitchDifficulty::NOVICE))) {
/*if (IsGlitched && (GetDifficultyValueFromString(GlitchHookshotClip) >= static_cast<uint8_t>(GlitchDifficulty::NOVICE))) {
return ShadowTempleKeys >= requiredAmountGlitched;
}
}*/
return ShadowTempleKeys >= requiredAmountGlitchless;
case BOTTOM_OF_THE_WELL:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return BottomOfTheWellKeys >= requiredAmountGlitched;
}
}*/
return BottomOfTheWellKeys >= requiredAmountGlitchless;
case GERUDO_TRAINING_GROUNDS:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return GerudoTrainingGroundsKeys >= requiredAmountGlitched;
}
}*/
return GerudoTrainingGroundsKeys >= requiredAmountGlitchless;
case GANONS_CASTLE:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return GanonsCastleKeys >= requiredAmountGlitched;
}
}*/
return GanonsCastleKeys >= requiredAmountGlitchless;
case MARKET_TREASURE_CHEST_GAME:
if (IsGlitched && (false)) {
/*if (IsGlitched && (false)) {
return TreasureGameKeys >= requiredAmountGlitched;
}
}*/
return TreasureGameKeys >= requiredAmountGlitchless;
default:
@ -1164,11 +994,15 @@ namespace Logic {
CanFinishGerudoFortress = false;
HasShield = false;
CanShield = false;
CanJumpslash = false;
CanUseProjectile = false;
CanUseMagicArrow = false;
HasShield = false;
CanShield = false;
ChildShield = false;
AdultReflectShield = false;
AdultShield = false;
CanShieldFlick = false;
CanJumpslash = false;
CanUseProjectile = false;
CanUseMagicArrow = false;
//Bridge Requirements
HasAllStones = false;

33
soh/soh/Enhancements/randomizer/3drando/logic.hpp
View File

@ -278,6 +278,10 @@ extern bool CanFinishGerudoFortress;
extern bool HasShield;
extern bool CanShield;
extern bool ChildShield;
extern bool AdultReflectShield;
extern bool AdultShield;
extern bool CanShieldFlick;
extern bool CanJumpslash;
extern bool CanUseProjectile;
extern bool CanUseMagicArrow;
@ -343,31 +347,8 @@ enum class HasProjectileAge {
};
enum class GlitchType {
RestrictedItems,
SuperStab,
ISG,
BombHover,
BombOI,
OutdoorBombOI,
WindmillBombOI,
IndoorBombOI,
DungeonBombOI,
HoverBoost,
SuperSlide,
Megaflip,
ASlide,
HammerSlide,
LedgeCancel,
ActionSwap,
QPA,
HookshotClip,
HookshotJump_Bonk,
HookshotJump_Boots,
CutsceneDive,
NaviDive_Stick,
TripleSlashClip,
LedgeClip,
SeamWalk,
EquipSwapDins,
EquipSwap,
};
enum class GlitchDifficulty {
@ -384,7 +365,7 @@ bool CanUse(uint32_t itemName);
bool HasProjectile(HasProjectileAge age);
bool SmallKeys(Key dungeon, uint8_t requiredAmount);
bool SmallKeys(Key dungeon, uint8_t requiredAmountGlitchless, uint8_t requiredAmountGlitched);
bool CanDoGlitch(GlitchType glitch, GlitchDifficulty difficulty);
bool CanDoGlitch(GlitchType glitch);
bool EventsUpdated();
void LogicReset();
} // namespace Logic

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

@ -512,7 +512,7 @@ void PrintOptionDescription() {
printf("\x1b[22;0H%s", description.data());
}
std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations,
std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks,
std::string seedString) {
srand(time(NULL));
@ -528,7 +528,7 @@ std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t>
} catch (std::out_of_range &e) {
count = 1;
}
Playthrough::Playthrough_Repeat(cvarSettings, excludedLocations, count);
Playthrough::Playthrough_Repeat(cvarSettings, excludedLocations, enabledTricks, count);
return "";
}
@ -536,7 +536,7 @@ std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t>
uint32_t seedHash = boost::hash_32<std::string>{}(Settings::seedString);
Settings::seed = seedHash & 0xFFFFFFFF;
int ret = Playthrough::Playthrough_Init(Settings::seed, cvarSettings, excludedLocations);
int ret = Playthrough::Playthrough_Init(Settings::seed, cvarSettings, excludedLocations, enabledTricks);
if (ret < 0) {
if (ret == -1) { // Failed to generate after 5 tries
printf("\n\nFailed to generate after 5 tries.\nPress B to go back to the menu.\nA different seed might be "

2
soh/soh/Enhancements/randomizer/3drando/menu.hpp
View File

@ -46,7 +46,7 @@ void PrintResetToDefaultsMenu();
void PrintGenerateMenu();
void ClearDescription();
void PrintOptionDescription();
std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSetting, std::set<RandomizerCheck> excludedLocations, std::string seedInput);
std::string GenerateRandomizer(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSetting, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks, std::string seedInput);
std::string GetInput(const char* hintText);
extern void MenuInit();

8
soh/soh/Enhancements/randomizer/3drando/playthrough.cpp
View File

@ -11,7 +11,7 @@
namespace Playthrough {
int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations) {
int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks) {
// initialize the RNG with just the seed incase any settings need to be
// resolved to something random
Random_Init(seed);
@ -22,7 +22,7 @@ int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uin
HintReset();
Areas::AccessReset();
Settings::UpdateSettings(cvarSettings, excludedLocations);
Settings::UpdateSettings(cvarSettings, excludedLocations, enabledTricks);
// once the settings have been finalized turn them into a string for hashing
std::string settingsStr;
for (Menu* menu : Settings::GetAllOptionMenus()) {
@ -83,7 +83,7 @@ int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uin
}
// used for generating a lot of seeds at once
int Playthrough_Repeat(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, int count /*= 1*/) {
int Playthrough_Repeat(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks, int count /*= 1*/) {
printf("\x1b[0;0HGENERATING %d SEEDS", count);
uint32_t repeatedSeed = 0;
for (int i = 0; i < count; i++) {
@ -92,7 +92,7 @@ int Playthrough_Repeat(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSet
Settings::seed = repeatedSeed % 0xFFFFFFFF;
CitraPrint("testing seed: " + std::to_string(Settings::seed));
ClearProgress();
Playthrough_Init(Settings::seed, cvarSettings, excludedLocations);
Playthrough_Init(Settings::seed, cvarSettings, excludedLocations, enabledTricks);
printf("\x1b[15;15HSeeds Generated: %d\n", i + 1);
}

4
soh/soh/Enhancements/randomizer/3drando/playthrough.hpp
View File

@ -4,6 +4,6 @@
#include "item_location.hpp"
namespace Playthrough {
int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations);
int Playthrough_Repeat(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, int count = 1);
int Playthrough_Init(uint32_t seed, std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks);
int Playthrough_Repeat(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks, int count = 1);
}

4
soh/soh/Enhancements/randomizer/3drando/rando_main.cpp
View File

@ -11,7 +11,7 @@
#define TICKS_PER_SEC 268123480.0
void RandoMain::GenerateRando(std::unordered_map<RandomizerSettingKey, u8> cvarSettings, std::set<RandomizerCheck> excludedLocations,
void RandoMain::GenerateRando(std::unordered_map<RandomizerSettingKey, u8> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks,
std::string seedString) {
HintTable_Init();
ItemTable_Init();
@ -20,7 +20,7 @@ void RandoMain::GenerateRando(std::unordered_map<RandomizerSettingKey, u8> cvarS
// std::string settingsFileName = "./randomizer/latest_settings.json";
// CVarSetString("gLoadedPreset", settingsFileName.c_str());
std::string fileName = LUS::Context::GetPathRelativeToAppDirectory(GenerateRandomizer(cvarSettings, excludedLocations, seedString).c_str());
std::string fileName = LUS::Context::GetPathRelativeToAppDirectory(GenerateRandomizer(cvarSettings, excludedLocations, enabledTricks, seedString).c_str());
CVarSetString("gSpoilerLog", fileName.c_str());
CVarSave();

2
soh/soh/Enhancements/randomizer/3drando/rando_main.hpp
View File

@ -3,6 +3,6 @@
#include "item.hpp"
namespace RandoMain {
void GenerateRando(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::string seedInput);
void GenerateRando(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks, std::string seedInput);
std::array<Item, KEY_ENUM_MAX>* GetFullItemTable();
}

1
soh/soh/Enhancements/randomizer/3drando/setting_descriptions.cpp
View File

@ -1112,6 +1112,7 @@ string_view ToggleLogicNoneDesc = "Disables all the Detail
string_view ToggleLogicNoviceDesc = "Enables only the easier Detailed Logic tricks"; //
string_view ToggleLogicIntermediateDesc = "Enables all but the harder Detailed Logic tricks.";
string_view ToggleLogicExpertDesc = "Enables all the Detailed Logic tricks."; //
string_view LogicTempDesc = ""; //
//
string_view LogicGrottosWithoutAgonyDesc = "Difficulty: Novice\n" //
"Grottos can be accessed without Stone of Agony,\n"//

1
soh/soh/Enhancements/randomizer/3drando/setting_descriptions.hpp
View File

@ -365,6 +365,7 @@ extern string_view ToggleLogicNoneDesc;
extern string_view ToggleLogicNoviceDesc;
extern string_view ToggleLogicIntermediateDesc;
extern string_view ToggleLogicExpertDesc;
extern string_view LogicTempDesc;
extern string_view LogicGrottosWithoutAgonyDesc;
extern string_view LogicVisibleCollisionDesc;
extern string_view LogicFewerTunicRequirementsDesc;

853
soh/soh/Enhancements/randomizer/3drando/settings.cpp
View File

@ -658,279 +658,539 @@ namespace Settings {
}
//Detailed Logic Tricks ---------------------
Option ToggleAllTricks = Option::U8("All Tricks", {"None", "Novice", "Intermediate", "Expert"}, {ToggleLogicNoneDesc, ToggleLogicNoviceDesc, ToggleLogicIntermediateDesc, ToggleLogicExpertDesc}, OptionCategory::Toggle);
Option LogicGrottosWithoutAgony = LogicTrick(" Grotto Access\n w/o Stone of Agony", LogicGrottosWithoutAgonyDesc);
Option LogicVisibleCollision = LogicTrick(" Go Through Visible\n One-Way Collisions", LogicVisibleCollisionDesc);
Option LogicFewerTunicRequirements = LogicTrick(" Fewer Tunic\n Requirements", LogicFewerTunicRequirementsDesc);
Option LogicLostWoodsGSBean = LogicTrick(" LW Adult Tree GS\n w/o Magic Beans", LogicLostWoodsGSBeanDesc);
Option LogicLabDiving = LogicTrick(" LH Lab Dive\n w/o Gold Scale", LogicLabDivingDesc);
Option LogicLabWallGS = LogicTrick(" LH Lab Wall GS\n w/ Jump Slash", LogicLabWallGSDesc);
Option LogicGraveyardPoH = LogicTrick(" GY Crate PoH\n w/ Boomerang", LogicGraveyardPoHDesc);
Option LogicChildDampeRacePoH = LogicTrick(" GY Second Dampe\n Race as Child", LogicChildDampeRacePoHDesc);
Option LogicGVHammerChest = LogicTrick(" GV Hammer Chest\n w/o Hammer", LogicGVHammerChestDesc);
Option LogicGerudoKitchen = LogicTrick(" GF Through Kitchen\n w/ Nothing", LogicGerudoKitchenDesc);
Option LogicLensWasteland = LogicTrick(" Haunted Wasteland\n w/o Lens of Truth", LogicLensWastelandDesc);
Option LogicReverseWasteland = LogicTrick(" Haunted Wasteland\n in Reverse", LogicReverseWastelandDesc);
Option LogicColossusGS = LogicTrick(" Colossus Hill GS\n w/ Hookshot", LogicColossusGSDesc);
Option LogicOutsideGanonsGS = LogicTrick(" Outside GaC GS\n w/ Jump Slash", LogicOutsideGanonsGSDesc);
Option LogicManOnRoof = LogicTrick(" Kak Roof Guy\n w/o Hookshot", LogicManOnRoofDesc);
Option LogicWindmillPoHHookshot = LogicTrick(" Windmill PoH\n w/ Hookshot", LogicWindmillPoHHookshotDesc);
Option LogicDMTBombable = LogicTrick(" DMT Wall Chest\n w/ Strength", LogicDMTBombableDesc);
Option LogicDMTSoilGS = LogicTrick(" DMT Soil GS\n w/o Opening DC", LogicDMTSoilGSDesc);
Option LogicDMTSummitHover = LogicTrick(" DMT Summit\n w/ Hover Boots", LogicDMTSummitHoverDesc);
Option LogicLinkGoronDins = LogicTrick(" GoC Adult Goron\n w/ Din's Fire", LogicLinkGoronDinsDesc);
Option LogicGoronCityLeftMost = LogicTrick(" GoC Maze Left Chest\n w/ Hover Boots", LogicGoronCityLeftMostDesc);
Option LogicGoronCityPot = LogicTrick(" GoC Goron Vase PoH\n w/ Bombchu", LogicGoronCityPotDesc); //Needs Testing
Option LogicGoronCityPotWithStrength = LogicTrick(" GoC Goron Vase PoH\n w/ Strength", LogicGoronCityPotWithStrengthDesc);
Option LogicChildRollingWithStrength = LogicTrick(" GoC Child Goron\n w/ Strength", LogicChildRollingWithStrengthDesc);
Option LogicCraterUpperToLower = LogicTrick(" DMC Upper to Lower\n w/ Hammer", LogicCraterUpperToLowerDesc); //Needs Testing
Option LogicCraterBeanPoHWithHovers = LogicTrick(" DMC Bean PoH\n w/ Hover Boots", LogicCraterBeanPoHWithHoversDesc);
Option LogicBiggoronBolero = LogicTrick(" DMC Deliver Eyedrops\n w/ Bolero of Fire", LogicBiggoronBoleroDesc);
Option LogicZoraRiverLower = LogicTrick(" ZR Lower PoH\n w/ Nothing", LogicZoraRiverLowerDesc);
Option LogicZoraRiverUpper = LogicTrick(" ZR Upper PoH\n w/ Nothing", LogicZoraRiverUpperDesc);
Option LogicZFGreatFairy = LogicTrick(" ZF Great Fairy\n w/o Explosives", LogicZFGreatFairyDesc);
Option LogicDekuB1WebsWithBow = LogicTrick(" DT B1 Web\n w/ Bow", LogicDekuB1WebsWithBowDesc);
Option LogicDekuB1Skip = LogicTrick(" DT B1 Navigation\n w/o Slingshot", LogicDekuB1SkipDesc);
Option LogicDekuBasementGS = LogicTrick(" DT B1 Vines GS\n w/ Jump Slash", LogicDekuBasementGSDesc);
Option LogicDCStaircase = LogicTrick(" DC Staircase\n w/ Bow", LogicDCStaircaseDesc);
Option LogicDCJump = LogicTrick(" DC Spike Trap Room\n w/o Hover Boots", LogicDCJumpDesc);
Option LogicDCSlingshotSkip = LogicTrick(" DC Eye Switches\n w/o Slingshot", LogicDCSlingshotSkipDesc);
Option LogicDCScarecrowGS = LogicTrick(" DC Scarecrow GS\n w/ Armos Statue", LogicDCScarecrowGSDesc);
Option LogicJabuBossGSAdult = LogicTrick(" JJB Near Boss GS\n as Adult", LogicJabuBossGSAdultDesc); //Needs Testing
Option LogicJabuScrubJumpDive = LogicTrick(" JJB Deku Scrub\n as Adult", LogicJabuScrubJumpDiveDesc); //Needs Testing
Option LogicForestOutsideBackdoor = LogicTrick(" FoT West Backdoor\n w/ Jump Slash", LogicForestOutsideBackdoorDesc); //Needs Testing
Option LogicForestDoorFrame = LogicTrick(" FoT East Scarecrow\n w/ Hover Boots", LogicForestDoorFrameDesc); //Needs Testing
Option LogicForestOutdoorEastGS = LogicTrick(" FoT East Yard GS\n w/ Boomerang", LogicForestOutdoorEastGSDesc);
Option LogicFireBossDoorJump = LogicTrick(" FiT Boss Door\n w/o Hover Boots", LogicFireBossDoorJumpDesc);
Option LogicFireStrength = LogicTrick(" FiT Climb Block\n w/o Strength", LogicFireStrengthDesc);
Option LogicFireScarecrow = LogicTrick(" FiT East Tower\n w/o Scarecrow", LogicFireScarecrowDesc);
Option LogicFireFlameMaze = LogicTrick(" FiT Firewall Maze\n w/ Nothing", LogicFireFlameMazeDesc);
Option LogicFireSongOfTime = LogicTrick(" FiT SoT Room GS\n w/o SoT", LogicFireSongOfTimeDesc);
Option LogicWaterTempleTorchLongshot = LogicTrick(" WaT Torch Longshot\n Shortcut", LogicWaterTempleTorchLongshotDesc);
Option LogicWaterTempleUpperBoost = LogicTrick(" WaT Boss Ledge\n w/ Bombs", LogicWaterTempleUpperBoostDesc);
Option LogicWaterCentralBow = LogicTrick(" WaT Bow Target\n w/o Longshot/Hover", LogicWaterCentralBowDesc);
Option LogicWaterCentralGSFW = LogicTrick(" WaT Center Room GS\n w/ Farore's Wind", LogicWaterCentralGSFWDesc);
Option LogicWaterCrackedWallNothing = LogicTrick(" WaT Cracked Wall\n w/ Nothing", LogicWaterCrackedWallNothingDesc);
Option LogicWaterCrackedWallHovers = LogicTrick(" WaT Cracked Wall\n w/ Hover Boots", LogicWaterCrackedWallHoversDesc);
Option LogicWaterBossKeyRegion = LogicTrick(" WaT B1 North Area\n w/ Hover Boots", LogicWaterBossKeyRegionDesc);
Option LogicWaterBKJumpDive = LogicTrick(" WaT Boss Key Room\n w/o Iron Boots", LogicWaterBKJumpDiveDesc);
Option LogicWaterNorthBasementLedgeJump = LogicTrick(" WaT Boss Key Rooms\n w/ Precise Jump", LogicWaterNorthBasementLedgeJumpDesc);
Option LogicWaterDragonAdult = LogicTrick(" WaT Whirlpool\n w/o Iron Boots", LogicWaterDragonAdultDesc);
Option LogicWaterDragonJumpDive = LogicTrick(" WaT Whirlpool Up\n w/o Iron Boots", LogicWaterDragonJumpDiveDesc);
Option LogicWaterRiverGS = LogicTrick(" WaT River GS\n w/o Iron Boots", LogicWaterRiverGSDesc);
Option LogicWaterFallingPlatformGS = LogicTrick(" WaT Waterfall GS\n w/ Hookshot", LogicWaterFallingPlatformGSDesc);
Option LogicSpiritLowerAdultSwitch = LogicTrick(" SpT Ceiling Switch\n w/ Bombs", LogicSpiritLowerAdultSwitchDesc);
Option LogicSpiritChildBombchu = LogicTrick(" SpT Child Bridge\n w/ Bombchu", LogicSpiritChildBombchuDesc);
Option LogicSpiritWall = LogicTrick(" SpT Shifting Wall\n w/ Nothing", LogicSpiritWallDesc);
Option LogicSpiritLobbyGS = LogicTrick(" SpT Main Room GS\n w/ Boomerang", LogicSpiritLobbyGSDesc);
Option LogicSpiritMapChest = LogicTrick(" SpT Map Chest\n w/ Bow", LogicSpiritMapChestDesc);
Option LogicSpiritSunChest = LogicTrick(" SpT Sun Block Room\n w/ Bow", LogicSpiritSunChestDesc);
Option LogicShadowFireArrowEntry = LogicTrick(" ShT Entry\n w/ Fire Arrows", LogicShadowFireArrowEntryDesc); //Needs Testing
Option LogicShadowUmbrella = LogicTrick(" ShT Stone Umbrella\n w/ Hover Boots", LogicShadowUmbrellaDesc);
Option LogicShadowFreestandingKey = LogicTrick(" ShT Skull Vase Key\n w/ Bombchu", LogicShadowFreestandingKeyDesc);
Option LogicShadowStatue = LogicTrick(" ShT River Statue\n w/ Bombchu", LogicShadowStatueDesc);
Option LogicShadowBongo = LogicTrick("ShT Bongo\n w/o Projectiles", LogicShadowBongoDesc);
Option LogicChildDeadhand = LogicTrick(" BotW Deadhand\n w/o Sword", LogicChildDeadhandDesc);
Option LogicGtgWithoutHookshot = LogicTrick(" GTG West Silver Rupee\n w/o Hookshot", LogicGtgWithoutHookshotDesc);
Option LogicGtgFakeWall = LogicTrick(" GTG Invisible Wall\n w/ Hover Boots", LogicGtgFakeWallDesc);
Option LogicLensSpirit = LogicTrick(" SpT Navigate\n w/o Lens of Truth", LogicLensSpiritDesc);
Option LogicLensShadow = LogicTrick(" ShT Early Rooms\n w/o Lens of Truth", LogicLensShadowDesc);
Option LogicLensShadowBack = LogicTrick(" ShT Later Rooms\n w/o Lens of Truth", LogicLensShadowBackDesc);
Option LogicLensBotw = LogicTrick(" BotW Navigate\n w/o Lens of Truth", LogicLensBotwDesc);
Option LogicLensGtg = LogicTrick(" GTG Navigate\n w/o Lens of Truth", LogicLensGtgDesc);
Option LogicLensCastle = LogicTrick(" GaC Navigate\n w/o Lens of Truth", LogicLensCastleDesc);
Option LogicLensJabuMQ = LogicTrick(" JJB MQ Navigate\n w/o Lens of Truth", LogicLensJabuMQDesc);
Option LogicLensSpiritMQ = LogicTrick(" SpT MQ Navigate\n w/o Lens of Truth", LogicLensSpiritMQDesc);
Option LogicLensShadowMQ = LogicTrick(" ShT MQ Early Rooms\n w/o Lens of Truth", LogicLensShadowMQDesc);
Option LogicLensShadowMQBack = LogicTrick(" ShT MQ Later Rooms\n w/o Lens of Truth", LogicLensShadowMQBackDesc);
Option LogicLensBotwMQ = LogicTrick(" BotW MQ Nagivate\n w/o Lens of Truth", LogicLensBotwMQDesc);
Option LogicLensGtgMQ = LogicTrick(" GTG MQ Navigate\n w/o Lens of Truth", LogicLensGtgMQDesc);
Option LogicLensCastleMQ = LogicTrick(" GaC MQ Navigate\n w/o Lens of Truth", LogicLensCastleMQDesc);
Option LogicSpiritTrialHookshot = LogicTrick(" Spirit Trial\n w/o Hookshot", LogicSpiritTrialHookshotDesc);
Option LogicFlamingChests = LogicTrick(" Open chests through\n flame circles", LogicFlamingChestsDesc);
Option LogicVisibleCollision = LogicTrick(std::to_string(RT_VISIBLE_COLLISION), LogicTempDesc);
Option LogicGrottosWithoutAgony = LogicTrick(std::to_string(RT_GROTTOS_WITHOUT_AGONY), LogicTempDesc);
Option LogicFewerTunicRequirements = LogicTrick(std::to_string(RT_FEWER_TUNIC_REQUIREMENTS), LogicTempDesc);
Option LogicRustedSwitches = LogicTrick(std::to_string(RT_RUSTED_SWITCHES), LogicTempDesc);
Option LogicFlamingChests = LogicTrick(std::to_string(RT_FLAMING_CHESTS), LogicTempDesc);
Option LogicBunnyHoodJump = LogicTrick(std::to_string(RT_BUNNY_HOOD_JUMPS), LogicTempDesc);
Option LogicDamageBoost = LogicTrick(std::to_string(RT_DAMAGE_BOOST_SIMPLE), LogicTempDesc);
Option LogicHoverBoost = LogicTrick(std::to_string(RT_HOVER_BOOST_SIMPLE), LogicTempDesc);
Option LogicAdultKokiriGS = LogicTrick(std::to_string(RT_KF_ADULT_GS), LogicTempDesc);
Option LogicLostWoodsBridge = LogicTrick(std::to_string(RT_LW_BRIDGE), LogicTempDesc);
Option LogicMidoBackflip = LogicTrick(std::to_string(RT_LW_MIDO_BACKFLIP), LogicTempDesc);
Option LogicLostWoodsGSBean = LogicTrick(std::to_string(RT_LW_GS_BEAN), LogicTempDesc);
Option LogicCastleStormsGS = LogicTrick(std::to_string(RT_HC_STORMS_GS), LogicTempDesc);
Option LogicManOnRoof = LogicTrick(std::to_string(RT_KAK_MAN_ON_ROOF), LogicTempDesc);
Option LogicKakarikoTowerGS = LogicTrick(std::to_string(RT_KAK_TOWER_GS), LogicTempDesc);
Option LogicAdultWindmillPoH = LogicTrick(std::to_string(RT_KAK_ADULT_WINDMILL_POH), LogicTempDesc);
Option LogicChildWindmillPoH = LogicTrick(std::to_string(RT_KAK_CHILD_WINDMILL_POH), LogicTempDesc);
Option LogicKakarikoRooftopGS = LogicTrick(std::to_string(RT_KAK_ROOFTOP_GS), LogicTempDesc);
Option LogicGraveyardPoH = LogicTrick(std::to_string(RT_GY_POH), LogicTempDesc);
Option LogicChildDampeRacePoH = LogicTrick(std::to_string(RT_GY_CHILD_DAMPE_RACE_POH), LogicTempDesc);
Option LogicShadowFireArrowEntry = LogicTrick(std::to_string(RT_GY_SHADOW_FIRE_ARROWS), LogicTempDesc);
Option LogicDMTSoilGS = LogicTrick(std::to_string(RT_DMT_SOIL_GS), LogicTempDesc);
Option LogicDMTBombable = LogicTrick(std::to_string(RT_DMT_BOMBABLE), LogicTempDesc);
Option LogicDMTGSLowerHookshot = LogicTrick(std::to_string(RT_DMT_HOOKSHOT_LOWER_GS), LogicTempDesc);
Option LogicDMTGSLowerHovers = LogicTrick(std::to_string(RT_DMT_HOVERS_LOWER_GS), LogicTempDesc);
Option LogicDMTGSLowerBean = LogicTrick(std::to_string(RT_DMT_BEAN_LOWER_GS), LogicTempDesc);
Option LogicDMTGSLowerJS = LogicTrick(std::to_string(RT_DMT_JS_LOWER_GS), LogicTempDesc);
Option LogicDMTClimbHovers = LogicTrick(std::to_string(RT_DMT_CLIMB_HOVERS), LogicTempDesc);
Option LogicDMTGSUpper = LogicTrick(std::to_string(RT_DMT_UPPER_GS), LogicTempDesc);
Option LogicBiggoronBolero = LogicTrick(std::to_string(RT_DMT_BOLERO_BIGGORON), LogicTempDesc);
Option LogicGoronCityPot = LogicTrick(std::to_string(RT_GC_POT), LogicTempDesc);
Option LogicGoronCityPotWithStrength = LogicTrick(std::to_string(RT_GC_POT_STRENGTH), LogicTempDesc);
Option LogicChildRollingWithStrength = LogicTrick(std::to_string(RT_GC_ROLLING_STRENGTH), LogicTempDesc);
Option LogicGoronCityLeftMost = LogicTrick(std::to_string(RT_GC_LEFTMOST), LogicTempDesc);
Option LogicGoronCityGrotto = LogicTrick(std::to_string(RT_GC_GROTTO), LogicTempDesc);
Option LogicGoronCityLinkGoronDins = LogicTrick(std::to_string(RT_GC_LINK_GORON_DINS), LogicTempDesc);
Option LogicCraterBeanPoHWithHovers = LogicTrick(std::to_string(RT_DMC_HOVER_BEAN_POH), LogicTempDesc);
Option LogicCraterBoleroJump = LogicTrick(std::to_string(RT_DMC_BOLERO_JUMP), LogicTempDesc);
Option LogicCraterBoulderJS = LogicTrick(std::to_string(RT_DMC_BOULDER_JS), LogicTempDesc);
Option LogicCraterBoulderSkip = LogicTrick(std::to_string(RT_DMC_BOULDER_SKIP), LogicTempDesc);
Option LogicZoraRiverLower = LogicTrick(std::to_string(RT_ZR_LOWER), LogicTempDesc);
Option LogicZoraRiverUpper = LogicTrick(std::to_string(RT_ZR_UPPER), LogicTempDesc);
Option LogicZoraWithHovers = LogicTrick(std::to_string(RT_ZR_HOVERS), LogicTempDesc);
Option LogicZoraWithCucco = LogicTrick(std::to_string(RT_ZR_CUCCO), LogicTempDesc);
Option LogicKingZoraSkip = LogicTrick(std::to_string(RT_ZD_KING_ZORA_SKIP), LogicTempDesc);
Option LogicDomainGS = LogicTrick(std::to_string(RT_ZD_GS), LogicTempDesc);
Option LogicLabWallGS = LogicTrick(std::to_string(RT_LH_LAB_WALL_GS), LogicTempDesc);
Option LogicLabDiving = LogicTrick(std::to_string(RT_LH_LAB_DIVING), LogicTempDesc);
Option LogicWaterHookshotEntry = LogicTrick(std::to_string(RT_LH_WATER_HOOKSHOT), LogicTempDesc);
Option LogicValleyCrateHovers = LogicTrick(std::to_string(RT_GV_CRATE_HOVERS), LogicTempDesc);
Option LogicGerudoKitchen = LogicTrick(std::to_string(RT_GF_KITCHEN), LogicTempDesc);
Option LogicGFJump = LogicTrick(std::to_string(RT_GF_JUMP), LogicTempDesc);
Option LogicWastelandBunnyCrossing = LogicTrick(std::to_string(RT_HW_BUNNY_CROSSING), LogicTempDesc);
Option LogicWastelandCrossing = LogicTrick(std::to_string(RT_HW_CROSSING), LogicTempDesc);
Option LogicLensWasteland = LogicTrick(std::to_string(RT_LENS_HW), LogicTempDesc);
Option LogicReverseWasteland = LogicTrick(std::to_string(RT_HW_REVERSE), LogicTempDesc);
Option LogicColossusGS = LogicTrick(std::to_string(RT_COLOSSUS_GS), LogicTempDesc);
Option LogicDekuBasementGS = LogicTrick(std::to_string(RT_DEKU_BASEMENT_GS), LogicTempDesc);
Option LogicDekuB1Skip = LogicTrick(std::to_string(RT_DEKU_B1_SKIP), LogicTempDesc);
Option LogicDekuB1WebsWithBow = LogicTrick(std::to_string(RT_DEKU_B1_BOW_WEBS), LogicTempDesc);
Option LogicDekuMQCompassGS = LogicTrick(std::to_string(RT_DEKU_MQ_COMPASS_GS), LogicTempDesc);
Option LogicDekuMQLog = LogicTrick(std::to_string(RT_DEKU_MQ_LOG), LogicTempDesc);
Option LogicDCScarecrowGS = LogicTrick(std::to_string(RT_DC_SCARECROW_GS), LogicTempDesc);
Option LogicDCVinesGS = LogicTrick(std::to_string(RT_DC_VINES_GS), LogicTempDesc);
Option LogicDCStaircase = LogicTrick(std::to_string(RT_DC_STAIRCASE), LogicTempDesc);
Option LogicDCSlingshotSkip = LogicTrick(std::to_string(RT_DC_SLINGSHOT_SKIP), LogicTempDesc);
Option LogicDCScrubRoom = LogicTrick(std::to_string(RT_DC_SCRUB_ROOM), LogicTempDesc);
Option LogicDCJump = LogicTrick(std::to_string(RT_DC_JUMP), LogicTempDesc);
Option LogicDCHammerFloor = LogicTrick(std::to_string(RT_DC_HAMMER_FLOOR), LogicTempDesc);
Option LogicDCMQChildBombs = LogicTrick(std::to_string(RT_DC_MQ_CHILD_BOMBS), LogicTempDesc);
Option LogicDCMQEyesChild = LogicTrick(std::to_string(RT_DC_MQ_CHILD_EYES), LogicTempDesc);
Option LogicDCMQEyesAdult = LogicTrick(std::to_string(RT_DC_MQ_ADULT_EYES), LogicTempDesc);
Option LogicJabuAlcoveJumpDive = LogicTrick(std::to_string(RT_JABU_ALCOVE_JUMP_DIVE), LogicTempDesc);
Option LogicJabuBossHover = LogicTrick(std::to_string(RT_JABU_BOSS_HOVER), LogicTempDesc);
Option LogicJabuNearBossRanged = LogicTrick(std::to_string(RT_JABU_NEAR_BOSS_RANGED), LogicTempDesc);
Option LogicJabuNearBossExplosives = LogicTrick(std::to_string(RT_JABU_NEAR_BOSS_EXPLOSIVES), LogicTempDesc);
Option LogicLensJabuMQ = LogicTrick(std::to_string(RT_LENS_JABU_MQ), LogicTempDesc);
Option LogicJabuMQRangJump = LogicTrick(std::to_string(RT_JABU_MQ_RANG_JUMP), LogicTempDesc);
Option LogicJabuMQSoTGS = LogicTrick(std::to_string(RT_JABU_MQ_SOT_GS), LogicTempDesc);
Option LogicLensBotw = LogicTrick(std::to_string(RT_LENS_BOTW), LogicTempDesc);
Option LogicChildDeadhand = LogicTrick(std::to_string(RT_BOTW_CHILD_DEADHAND), LogicTempDesc);
Option LogicBotwBasement = LogicTrick(std::to_string(RT_BOTW_BASEMENT), LogicTempDesc);
Option LogicBotwMQPits = LogicTrick(std::to_string(RT_BOTW_MQ_PITS), LogicTempDesc);
Option LogicBotwMQDeadHandKey = LogicTrick(std::to_string(RT_BOTW_MQ_DEADHAND_KEY), LogicTempDesc);
Option LogicForestFirstGS = LogicTrick(std::to_string(RT_FOREST_FIRST_GS), LogicTempDesc);
Option LogicForestOutdoorEastGS = LogicTrick(std::to_string(RT_FOREST_OUTDOORS_EAST_GS), LogicTempDesc);
Option LogicForestVines = LogicTrick(std::to_string(RT_FOREST_VINES), LogicTempDesc);
Option LogicForestOutdoorsLedge = LogicTrick(std::to_string(RT_FOREST_OUTDOORS_LEDGE), LogicTempDesc);
Option LogicForestDoorFrame = LogicTrick(std::to_string(RT_FOREST_DOORFRAME), LogicTempDesc);
Option LogicForestOutsideBackdoor = LogicTrick(std::to_string(RT_FOREST_OUTSIDE_BACKDOOR), LogicTempDesc);
Option LogicForestMQWellSwim = LogicTrick(std::to_string(RT_FOREST_MQ_WELL_SWIM), LogicTempDesc);
Option LogicForestMQBlockPuzzle = LogicTrick(std::to_string(RT_FOREST_MQ_BLOCK_PUZZLE), LogicTempDesc);
Option LogicForestMQHallwaySwitchJS = LogicTrick(std::to_string(RT_FOREST_MQ_JS_HALLWAY_SWITCH), LogicTempDesc);
Option LogicForestMQHallwaySwitchHookshot = LogicTrick(std::to_string(RT_FOREST_MQ_HOOKSHOT_HALLWAY_SWITCH), LogicTempDesc);
Option LogicForestMQHallwaySwitchBoomerang = LogicTrick(std::to_string(RT_FOREST_MQ_RANG_HALLWAY_SWITCH), LogicTempDesc);
Option LogicFireBossDoorJump = LogicTrick(std::to_string(RT_FIRE_BOSS_DOOR_JUMP), LogicTempDesc);
Option LogicFireSongOfTime = LogicTrick(std::to_string(RT_FIRE_SOT), LogicTempDesc);
Option LogicFireStrength = LogicTrick(std::to_string(RT_FIRE_STRENGTH), LogicTempDesc);
Option LogicFireScarecrow = LogicTrick(std::to_string(RT_FIRE_SCARECROW), LogicTempDesc);
Option LogicFireFlameMaze = LogicTrick(std::to_string(RT_FIRE_FLAME_MAZE), LogicTempDesc);
Option LogicFireMQNearBoss = LogicTrick(std::to_string(RT_FIRE_MQ_NEAR_BOSS), LogicTempDesc);
Option LogicFireMQBlockedChest = LogicTrick(std::to_string(RT_FIRE_MQ_BLOCKED_CHEST), LogicTempDesc);
Option LogicFireMQBKChest = LogicTrick(std::to_string(RT_FIRE_MQ_BK_CHEST), LogicTempDesc);
Option LogicFireMQClimb = LogicTrick(std::to_string(RT_FIRE_MQ_CLIMB), LogicTempDesc);
Option LogicFireMQMazeSideRoom = LogicTrick(std::to_string(RT_FIRE_MQ_MAZE_SIDE_ROOM), LogicTempDesc);
Option LogicFireMQMazeHovers = LogicTrick(std::to_string(RT_FIRE_MQ_MAZE_HOVERS), LogicTempDesc);
Option LogicFireMQMazeJump = LogicTrick(std::to_string(RT_FIRE_MQ_MAZE_JUMP), LogicTempDesc);
Option LogicFireMQAboveMazeGS = LogicTrick(std::to_string(RT_FIRE_MQ_ABOVE_MAZE_GS), LogicTempDesc);
Option LogicFireMQFlameMaze = LogicTrick(std::to_string(RT_FIRE_MQ_FLAME_MAZE), LogicTempDesc);
Option LogicWaterTempleTorchLongshot = LogicTrick(std::to_string(RT_WATER_LONGSHOT_TORCH), LogicTempDesc);
Option LogicWaterCrackedWallHovers = LogicTrick(std::to_string(RT_WATER_CRACKED_WALL_HOVERS), LogicTempDesc);
Option LogicWaterCrackedWallNothing = LogicTrick(std::to_string(RT_WATER_CRACKED_WALL), LogicTempDesc);
Option LogicWaterBossKeyRegion = LogicTrick(std::to_string(RT_WATER_BK_REGION), LogicTempDesc);
Option LogicWaterNorthBasementLedgeJump = LogicTrick(std::to_string(RT_WATER_NORTH_BASEMENT_LEDGE_JUMP), LogicTempDesc);
Option LogicWaterBKJumpDive = LogicTrick(std::to_string(RT_WATER_BK_JUMP_DIVE), LogicTempDesc);
Option LogicWaterCentralGSFW = LogicTrick(std::to_string(RT_WATER_FW_CENTRAL_GS), LogicTempDesc);
Option LogicWaterCentralGSIrons = LogicTrick(std::to_string(RT_WATER_IRONS_CENTRAL_GS), LogicTempDesc);
Option LogicWaterCentralBow = LogicTrick(std::to_string(RT_WATER_CENTRAL_BOW), LogicTempDesc);
Option LogicWaterFallingPlatformGSHookshot = LogicTrick(std::to_string(RT_WATER_HOOKSHOT_FALLING_PLATFORM_GS), LogicTempDesc);
Option LogicWaterFallingPlatformGSBoomerang = LogicTrick(std::to_string(RT_WATER_RANG_FALLING_PLATFORM_GS), LogicTempDesc);
Option LogicWaterRiverGS = LogicTrick(std::to_string(RT_WATER_RIVER_GS), LogicTempDesc);
Option LogicWaterDragonJumpDive = LogicTrick(std::to_string(RT_WATER_DRAGON_JUMP_DIVE), LogicTempDesc);
Option LogicWaterDragonAdult = LogicTrick(std::to_string(RT_WATER_ADULT_DRAGON), LogicTempDesc);
Option LogicWaterDragonChild = LogicTrick(std::to_string(RT_WATER_CHILD_DRAGON), LogicTempDesc);
Option LogicWaterMQCentralPillar = LogicTrick(std::to_string(RT_WATER_MQ_CENTRAL_PILLAR), LogicTempDesc);
Option LogicWaterMQLockedGS = LogicTrick(std::to_string(RT_WATER_MQ_LOCKED_GS), LogicTempDesc);
Option LogicLensShadow = LogicTrick(std::to_string(RT_LENS_SHADOW), LogicTempDesc);
Option LogicLensShadowPlatform = LogicTrick(std::to_string(RT_LENS_SHADOW_PLATFORM), LogicTempDesc);
Option LogicLensBongo = LogicTrick(std::to_string(RT_LENS_BONGO), LogicTempDesc);
Option LogicShadowUmbrella = LogicTrick(std::to_string(RT_SHADOW_UMBRELLA), LogicTempDesc);
Option LogicShadowUmbrellaGS = LogicTrick(std::to_string(RT_SHADOW_UMBRELLA_GS), LogicTempDesc);
Option LogicShadowFreestandingKey = LogicTrick(std::to_string(RT_SHADOW_FREESTANDING_KEY), LogicTempDesc);
Option LogicShadowStatue = LogicTrick(std::to_string(RT_SHADOW_STATUE), LogicTempDesc);
Option LogicShadowBongo = LogicTrick(std::to_string(RT_SHADOW_BONGO), LogicTempDesc);
Option LogicLensShadowMQ = LogicTrick(std::to_string(RT_LENS_SHADOW_MQ), LogicTempDesc);
Option LogicLensShadowMQInvisibleBlades = LogicTrick(std::to_string(RT_LENS_SHADOW_MQ_INVISIBLE_BLADES), LogicTempDesc);
Option LogicLensShadowMQPlatform = LogicTrick(std::to_string(RT_LENS_SHADOW_MQ_PLATFORM), LogicTempDesc);
Option LogicLensShadowMQDeadHand = LogicTrick(std::to_string(RT_LENS_SHADOW_MQ_DEADHAND), LogicTempDesc);
Option LogicShadowMQGap = LogicTrick(std::to_string(RT_SHADOW_MQ_GAP), LogicTempDesc);
Option LogicShadowMQInvisibleBlades = LogicTrick(std::to_string(RT_SHADOW_MQ_INVISIBLE_BLADES), LogicTempDesc);
Option LogicShadowMQHugePit = LogicTrick(std::to_string(RT_SHADOW_MQ_HUGE_PIT), LogicTempDesc);
Option LogicShadowMQWindyWalkway = LogicTrick(std::to_string(RT_SHADOW_MQ_WINDY_WALKWAY), LogicTempDesc);
Option LogicLensSpirit = LogicTrick(std::to_string(RT_LENS_SPIRIT), LogicTempDesc);
Option LogicSpiritChildBombchu = LogicTrick(std::to_string(RT_SPIRIT_CHILD_CHU), LogicTempDesc);
Option LogicSpiritLobbyGS = LogicTrick(std::to_string(RT_SPIRIT_LOBBY_GS), LogicTempDesc);
Option LogicSpiritLowerAdultSwitch = LogicTrick(std::to_string(RT_SPIRIT_LOWER_ADULT_SWITCH), LogicTempDesc);
Option LogicSpiritLobbyJump = LogicTrick(std::to_string(RT_SPIRIT_LOBBY_JUMP), LogicTempDesc);
Option LogicSpiritPlatformHookshot = LogicTrick(std::to_string(RT_SPIRIT_PLATFORM_HOOKSHOT), LogicTempDesc);
Option LogicSpiritMapChest = LogicTrick(std::to_string(RT_SPIRIT_MAP_CHEST), LogicTempDesc);
Option LogicSpiritSunChest = LogicTrick(std::to_string(RT_SPIRIT_SUN_CHEST), LogicTempDesc);
Option LogicSpiritWall = LogicTrick(std::to_string(RT_SPIRIT_WALL), LogicTempDesc);
Option LogicLensSpiritMQ = LogicTrick(std::to_string(RT_LENS_SPIRIT_MQ), LogicTempDesc);
Option LogicSpiritMQSunBlockSoT = LogicTrick(std::to_string(RT_SPIRIT_MQ_SUN_BLOCK_SOT), LogicTempDesc);
Option LogicSpiritMQSunBlockGS = LogicTrick(std::to_string(RT_SPIRIT_MQ_SUN_BLOCK_GS), LogicTempDesc);
Option LogicSpiritMQLowerAdult = LogicTrick(std::to_string(RT_SPIRIT_MQ_LOWER_ADULT), LogicTempDesc);
Option LogicSpiritMQFrozenEye = LogicTrick(std::to_string(RT_SPIRIT_MQ_FROZEN_EYE), LogicTempDesc);
Option LogicIceBlockGS = LogicTrick(std::to_string(RT_ICE_BLOCK_GS), LogicTempDesc);
Option LogicIceMQRedIceGS = LogicTrick(std::to_string(RT_ICE_MQ_RED_ICE_GS), LogicTempDesc);
Option LogicIceMQScarecrow = LogicTrick(std::to_string(RT_ICE_MQ_SCARECROW), LogicTempDesc);
Option LogicLensGtg = LogicTrick(std::to_string(RT_LENS_GTG), LogicTempDesc);
Option LogicGtgWithoutHookshot = LogicTrick(std::to_string(RT_GTG_WITHOUT_HOOKSHOT), LogicTempDesc);
Option LogicGtgFakeWall = LogicTrick(std::to_string(RT_GTG_FAKE_WALL), LogicTempDesc);
Option LogicLensGtgMQ = LogicTrick(std::to_string(RT_LENS_GTG_MQ), LogicTempDesc);
Option LogicGtgMQWithHookshot = LogicTrick(std::to_string(RT_GTG_MQ_WITH_HOOKSHOT), LogicTempDesc);
Option LogicGtgMQWithoutHookshot = LogicTrick(std::to_string(RT_GTG_MQ_WIHTOUT_HOOKSHOT), LogicTempDesc);
Option LogicLensCastle = LogicTrick(std::to_string(RT_LENS_GANON), LogicTempDesc);
Option LogicSpiritTrialHookshot = LogicTrick(std::to_string(RT_GANON_SPIRIT_TRIAL_HOOKSHOT), LogicTempDesc);
Option LogicLensCastleMQ = LogicTrick(std::to_string(RT_LENS_GANON_MQ), LogicTempDesc);
Option LogicFireTrialMQ = LogicTrick(std::to_string(RT_GANON_MQ_FIRE_TRIAL), LogicTempDesc);
Option LogicShadowTrialMQ = LogicTrick(std::to_string(RT_GANON_MQ_SHADOW_TRIAL), LogicTempDesc);
Option LogicLightTrialMQ = LogicTrick(std::to_string(RT_GANON_MQ_LIGHT_TRIAL), LogicTempDesc);
std::vector<Option *> trickOptions = {
&ToggleAllTricks,
&LogicGrottosWithoutAgony,
&LogicVisibleCollision,
&LogicGrottosWithoutAgony,
&LogicFewerTunicRequirements,
&LogicRustedSwitches,
&LogicFlamingChests,
&LogicBunnyHoodJump,
&LogicDamageBoost,
&LogicHoverBoost,
&LogicAdultKokiriGS,
&LogicLostWoodsBridge,
&LogicMidoBackflip,
&LogicLostWoodsGSBean,
&LogicLabDiving,
&LogicLabWallGS,
&LogicCastleStormsGS,
&LogicManOnRoof,
&LogicKakarikoTowerGS,
&LogicAdultWindmillPoH,
&LogicChildWindmillPoH,
&LogicKakarikoRooftopGS,
&LogicGraveyardPoH,
&LogicChildDampeRacePoH,
&LogicGVHammerChest,
&LogicGerudoKitchen,
&LogicLensWasteland,
&LogicReverseWasteland,
&LogicColossusGS,
&LogicOutsideGanonsGS,
&LogicManOnRoof,
&LogicWindmillPoHHookshot,
&LogicDMTBombable,
&LogicShadowFireArrowEntry,
&LogicDMTSoilGS,
&LogicDMTSummitHover,
&LogicLinkGoronDins,
&LogicGoronCityLeftMost,
&LogicDMTBombable,
&LogicDMTGSLowerHookshot,
&LogicDMTGSLowerHovers,
&LogicDMTGSLowerBean,
&LogicDMTGSLowerJS,
&LogicDMTClimbHovers,
&LogicDMTGSUpper,
&LogicBiggoronBolero,
&LogicGoronCityPot,
&LogicGoronCityPotWithStrength,
&LogicChildRollingWithStrength,
//&LogicCraterUpperToLower, Needs Testing Possible to break in 1 swing if you hit the right place? Right angle? Seems very inconsistent.
&LogicGoronCityLeftMost,
&LogicGoronCityGrotto,
&LogicGoronCityLinkGoronDins,
&LogicCraterBeanPoHWithHovers,
&LogicBiggoronBolero,
&LogicCraterBoleroJump,
&LogicCraterBoulderJS,
&LogicCraterBoulderSkip,
&LogicZoraRiverLower,
&LogicZoraRiverUpper,
&LogicZFGreatFairy,
&LogicDekuB1WebsWithBow,
&LogicDekuB1Skip,
&LogicZoraWithHovers,
&LogicZoraWithCucco,
&LogicKingZoraSkip,
&LogicDomainGS,
&LogicLabWallGS,
&LogicLabDiving,
&LogicWaterHookshotEntry,
&LogicValleyCrateHovers,
&LogicGerudoKitchen,
&LogicGFJump,
&LogicWastelandBunnyCrossing,
&LogicWastelandCrossing,
&LogicLensWasteland,
&LogicReverseWasteland,
&LogicColossusGS,
&LogicDekuBasementGS,
&LogicDCStaircase,
&LogicDCJump,
&LogicDCSlingshotSkip,
&LogicDekuB1Skip,
&LogicDekuB1WebsWithBow,
&LogicDekuMQCompassGS,
&LogicDekuMQLog,
&LogicDCScarecrowGS,
//&LogicJabuBossGSAdult, Needs Testing Don't know if possible as described, easier method exists as you can just backwalk with the box
&LogicJabuScrubJumpDive,
//&LogicForestOutsideBackdoor, Needs Testing Possible with bombchu damage boost, jumpslash is definitely harder than "intermediate" if at all possible
&LogicForestDoorFrame,
&LogicDCVinesGS,
&LogicDCStaircase,
&LogicDCSlingshotSkip,
&LogicDCScrubRoom,
&LogicDCJump,
&LogicDCHammerFloor,
&LogicDCMQChildBombs,
&LogicDCMQEyesChild,
&LogicDCMQEyesAdult,
&LogicJabuAlcoveJumpDive,
&LogicJabuBossHover,
&LogicJabuNearBossRanged,
&LogicJabuNearBossExplosives,
&LogicLensJabuMQ,
&LogicJabuMQRangJump,
&LogicJabuMQSoTGS,
&LogicLensBotw,
&LogicChildDeadhand,
&LogicBotwBasement,
&LogicBotwMQPits,
&LogicBotwMQDeadHandKey,
&LogicForestFirstGS,
&LogicForestOutdoorEastGS,
&LogicForestVines,
&LogicForestOutdoorsLedge,
&LogicForestDoorFrame,
&LogicForestOutsideBackdoor,
&LogicForestMQWellSwim,
&LogicForestMQBlockPuzzle,
&LogicForestMQHallwaySwitchJS,
//&LogicForestMQHallwaySwitchHookshot,
&LogicForestMQHallwaySwitchBoomerang,
&LogicFireBossDoorJump,
&LogicFireSongOfTime,
&LogicFireStrength,
&LogicFireScarecrow,
&LogicFireFlameMaze,
&LogicFireSongOfTime,
&LogicFireMQNearBoss,
&LogicFireMQBlockedChest,
&LogicFireMQBKChest,
&LogicFireMQClimb,
&LogicFireMQMazeSideRoom,
&LogicFireMQMazeHovers,
&LogicFireMQMazeJump,
&LogicFireMQAboveMazeGS,
&LogicFireMQFlameMaze,
&LogicWaterTempleTorchLongshot,
&LogicWaterTempleUpperBoost,
&LogicWaterCentralBow,
&LogicWaterCentralGSFW,
&LogicWaterCrackedWallNothing,
&LogicWaterCrackedWallHovers,
&LogicWaterCrackedWallNothing,
&LogicWaterBossKeyRegion,
&LogicWaterBKJumpDive,
&LogicWaterNorthBasementLedgeJump,
&LogicWaterBKJumpDive,
&LogicWaterCentralGSFW,
&LogicWaterCentralGSIrons,
&LogicWaterCentralBow,
&LogicWaterFallingPlatformGSHookshot,
&LogicWaterFallingPlatformGSBoomerang,
&LogicWaterRiverGS,
&LogicWaterDragonJumpDive,
&LogicWaterDragonAdult,
&LogicWaterRiverGS,
&LogicWaterFallingPlatformGS,
&LogicSpiritLowerAdultSwitch,
&LogicSpiritChildBombchu,
&LogicSpiritWall,
&LogicSpiritLobbyGS,
&LogicSpiritMapChest,
&LogicSpiritSunChest,
//&LogicShadowFireArrowEntry, Needs Testing
&LogicWaterDragonChild,
&LogicWaterMQCentralPillar,
&LogicWaterMQLockedGS,
&LogicLensShadow,
&LogicLensShadowPlatform,
&LogicLensBongo,
&LogicShadowUmbrella,
&LogicShadowUmbrellaGS,
&LogicShadowFreestandingKey,
&LogicShadowStatue,
&LogicShadowBongo,
&LogicChildDeadhand,
&LogicLensShadowMQ,
&LogicLensShadowMQInvisibleBlades,
&LogicLensShadowMQPlatform,
&LogicLensShadowMQDeadHand,
&LogicShadowMQGap,
&LogicShadowMQInvisibleBlades,
&LogicShadowMQHugePit,
&LogicShadowMQWindyWalkway,
&LogicLensSpirit,
&LogicSpiritChildBombchu,
&LogicSpiritLobbyGS,
&LogicSpiritLowerAdultSwitch,
&LogicSpiritLobbyJump,
&LogicSpiritPlatformHookshot,
&LogicSpiritMapChest,
&LogicSpiritSunChest,
&LogicSpiritWall,
&LogicLensSpiritMQ,
&LogicSpiritMQSunBlockSoT,
&LogicSpiritMQSunBlockGS,
&LogicSpiritMQLowerAdult,
&LogicSpiritMQFrozenEye,
&LogicIceBlockGS,
&LogicIceMQRedIceGS,
&LogicIceMQScarecrow,
&LogicLensGtg,
&LogicGtgWithoutHookshot,
&LogicGtgFakeWall,
&LogicLensSpirit,
&LogicLensShadow,
&LogicLensShadowBack,
&LogicLensBotw,
&LogicLensGtg,
&LogicLensCastle,
&LogicLensJabuMQ,
&LogicLensSpiritMQ,
&LogicLensShadowMQ,
&LogicLensShadowMQBack,
&LogicLensBotwMQ,
&LogicLensGtgMQ,
&LogicLensCastleMQ,
&LogicGtgMQWithHookshot,
&LogicGtgMQWithoutHookshot,
&LogicLensCastle,
&LogicSpiritTrialHookshot,
&LogicFlamingChests,
&LogicLensCastleMQ,
&LogicFireTrialMQ,
&LogicShadowTrialMQ,
&LogicLightTrialMQ,
};
std::unordered_map<RandomizerTrick,Option *> trickOptionMap = {
{RT_VISIBLE_COLLISION,&LogicVisibleCollision},
{RT_GROTTOS_WITHOUT_AGONY,&LogicGrottosWithoutAgony},
{RT_FEWER_TUNIC_REQUIREMENTS,&LogicFewerTunicRequirements},
{RT_RUSTED_SWITCHES,&LogicRustedSwitches},
{RT_FLAMING_CHESTS,&LogicFlamingChests},
{RT_BUNNY_HOOD_JUMPS,&LogicBunnyHoodJump},
{RT_DAMAGE_BOOST_SIMPLE,&LogicDamageBoost},
{RT_HOVER_BOOST_SIMPLE,&LogicHoverBoost},
{RT_KF_ADULT_GS,&LogicAdultKokiriGS},
{RT_LW_BRIDGE,&LogicLostWoodsBridge},
{RT_LW_MIDO_BACKFLIP,&LogicMidoBackflip},
{RT_LW_GS_BEAN,&LogicLostWoodsGSBean},
{RT_HC_STORMS_GS,&LogicCastleStormsGS},
{RT_KAK_MAN_ON_ROOF,&LogicManOnRoof},
{RT_KAK_TOWER_GS,&LogicKakarikoTowerGS},
{RT_KAK_ADULT_WINDMILL_POH,&LogicAdultWindmillPoH},
{RT_KAK_CHILD_WINDMILL_POH,&LogicChildWindmillPoH},
{RT_KAK_ROOFTOP_GS,&LogicKakarikoRooftopGS},
{RT_GY_POH,&LogicGraveyardPoH},
{RT_GY_CHILD_DAMPE_RACE_POH,&LogicChildDampeRacePoH},
{RT_GY_SHADOW_FIRE_ARROWS,&LogicShadowFireArrowEntry},
{RT_DMT_SOIL_GS,&LogicDMTSoilGS},
{RT_DMT_BOMBABLE,&LogicDMTBombable},
{RT_DMT_HOOKSHOT_LOWER_GS,&LogicDMTGSLowerHookshot},
{RT_DMT_HOVERS_LOWER_GS,&LogicDMTGSLowerHovers},
{RT_DMT_BEAN_LOWER_GS,&LogicDMTGSLowerBean},
{RT_DMT_JS_LOWER_GS,&LogicDMTGSLowerJS},
{RT_DMT_CLIMB_HOVERS,&LogicDMTClimbHovers},
{RT_DMT_UPPER_GS,&LogicDMTGSUpper},
{RT_DMT_BOLERO_BIGGORON,&LogicBiggoronBolero},
{RT_GC_POT,&LogicGoronCityPot},
{RT_GC_POT_STRENGTH,&LogicGoronCityPotWithStrength},
{RT_GC_ROLLING_STRENGTH,&LogicChildRollingWithStrength},
{RT_GC_LEFTMOST,&LogicGoronCityLeftMost},
{RT_GC_GROTTO,&LogicGoronCityGrotto},
{RT_GC_LINK_GORON_DINS,&LogicGoronCityLinkGoronDins},
{RT_DMC_HOVER_BEAN_POH,&LogicCraterBeanPoHWithHovers},
{RT_DMC_BOLERO_JUMP,&LogicCraterBoleroJump},
{RT_DMC_BOULDER_JS,&LogicCraterBoulderJS},
{RT_DMC_BOULDER_SKIP,&LogicCraterBoulderSkip},
{RT_ZR_LOWER,&LogicZoraRiverLower},
{RT_ZR_UPPER,&LogicZoraRiverUpper},
{RT_ZR_HOVERS,&LogicZoraWithHovers},
{RT_ZR_CUCCO,&LogicZoraWithCucco},
{RT_ZD_KING_ZORA_SKIP,&LogicKingZoraSkip},
{RT_ZD_GS,&LogicDomainGS},
{RT_LH_LAB_WALL_GS,&LogicLabWallGS},
{RT_LH_LAB_DIVING,&LogicLabDiving},
{RT_LH_WATER_HOOKSHOT,&LogicWaterHookshotEntry},
{RT_GV_CRATE_HOVERS,&LogicValleyCrateHovers},
{RT_GF_KITCHEN,&LogicGerudoKitchen},
{RT_GF_JUMP,&LogicGFJump},
{RT_HW_BUNNY_CROSSING,&LogicWastelandBunnyCrossing},
{RT_HW_CROSSING,&LogicWastelandCrossing},
{RT_LENS_HW,&LogicLensWasteland},
{RT_HW_REVERSE,&LogicReverseWasteland},
{RT_COLOSSUS_GS,&LogicColossusGS},
{RT_DEKU_BASEMENT_GS,&LogicDekuBasementGS},
{RT_DEKU_B1_SKIP,&LogicDekuB1Skip},
{RT_DEKU_B1_BOW_WEBS,&LogicDekuB1WebsWithBow},
{RT_DEKU_MQ_COMPASS_GS,&LogicDekuMQCompassGS},
{RT_DEKU_MQ_LOG,&LogicDekuMQLog},
{RT_DC_SCARECROW_GS,&LogicDCScarecrowGS},
{RT_DC_VINES_GS,&LogicDCVinesGS},
{RT_DC_STAIRCASE,&LogicDCStaircase},
{RT_DC_SLINGSHOT_SKIP,&LogicDCSlingshotSkip},
{RT_DC_SCRUB_ROOM,&LogicDCScrubRoom},
{RT_DC_JUMP,&LogicDCJump},
{RT_DC_HAMMER_FLOOR,&LogicDCHammerFloor},
{RT_DC_MQ_CHILD_BOMBS,&LogicDCMQChildBombs},
{RT_DC_MQ_CHILD_EYES,&LogicDCMQEyesChild},
{RT_DC_MQ_ADULT_EYES,&LogicDCMQEyesAdult},
{RT_JABU_ALCOVE_JUMP_DIVE,&LogicJabuAlcoveJumpDive},
{RT_JABU_BOSS_HOVER,&LogicJabuBossHover},
{RT_JABU_NEAR_BOSS_RANGED,&LogicJabuNearBossRanged},
{RT_JABU_NEAR_BOSS_EXPLOSIVES,&LogicJabuNearBossExplosives},
{RT_LENS_JABU_MQ,&LogicLensJabuMQ},
{RT_JABU_MQ_RANG_JUMP,&LogicJabuMQRangJump},
{RT_JABU_MQ_SOT_GS,&LogicJabuMQSoTGS},
{RT_LENS_BOTW,&LogicLensBotw},
{RT_BOTW_CHILD_DEADHAND,&LogicChildDeadhand},
{RT_BOTW_BASEMENT,&LogicBotwBasement},
{RT_BOTW_MQ_PITS,&LogicBotwMQPits},
{RT_BOTW_MQ_DEADHAND_KEY,&LogicBotwMQDeadHandKey},
{RT_FOREST_FIRST_GS,&LogicForestFirstGS},
{RT_FOREST_OUTDOORS_EAST_GS,&LogicForestOutdoorEastGS},
{RT_FOREST_VINES,&LogicForestVines},
{RT_FOREST_OUTDOORS_LEDGE,&LogicForestOutdoorsLedge},
{RT_FOREST_DOORFRAME,&LogicForestDoorFrame},
{RT_FOREST_OUTSIDE_BACKDOOR,&LogicForestOutsideBackdoor},
{RT_FOREST_MQ_WELL_SWIM,&LogicForestMQWellSwim},
{RT_FOREST_MQ_BLOCK_PUZZLE,&LogicForestMQBlockPuzzle},
{RT_FOREST_MQ_JS_HALLWAY_SWITCH,&LogicForestMQHallwaySwitchJS},
{RT_FOREST_MQ_HOOKSHOT_HALLWAY_SWITCH,&LogicForestMQHallwaySwitchHookshot},
{RT_FOREST_MQ_RANG_HALLWAY_SWITCH,&LogicForestMQHallwaySwitchBoomerang},
{RT_FIRE_BOSS_DOOR_JUMP,&LogicFireBossDoorJump},
{RT_FIRE_SOT,&LogicFireSongOfTime},
{RT_FIRE_STRENGTH,&LogicFireStrength},
{RT_FIRE_SCARECROW,&LogicFireScarecrow},
{RT_FIRE_FLAME_MAZE,&LogicFireFlameMaze},
{RT_FIRE_MQ_NEAR_BOSS,&LogicFireMQNearBoss},
{RT_FIRE_MQ_BLOCKED_CHEST,&LogicFireMQBlockedChest},
{RT_FIRE_MQ_BK_CHEST,&LogicFireMQBKChest},
{RT_FIRE_MQ_CLIMB,&LogicFireMQClimb},
{RT_FIRE_MQ_MAZE_SIDE_ROOM,&LogicFireMQMazeSideRoom},
{RT_FIRE_MQ_MAZE_HOVERS,&LogicFireMQMazeHovers},
{RT_FIRE_MQ_MAZE_JUMP,&LogicFireMQMazeJump},
{RT_FIRE_MQ_ABOVE_MAZE_GS,&LogicFireMQAboveMazeGS},
{RT_FIRE_MQ_FLAME_MAZE,&LogicFireMQFlameMaze},
{RT_WATER_LONGSHOT_TORCH,&LogicWaterTempleTorchLongshot},
{RT_WATER_CRACKED_WALL_HOVERS,&LogicWaterCrackedWallHovers},
{RT_WATER_CRACKED_WALL,&LogicWaterCrackedWallNothing},
{RT_WATER_BK_REGION,&LogicWaterBossKeyRegion},
{RT_WATER_NORTH_BASEMENT_LEDGE_JUMP,&LogicWaterNorthBasementLedgeJump},
{RT_WATER_BK_JUMP_DIVE,&LogicWaterBKJumpDive},
{RT_WATER_FW_CENTRAL_GS,&LogicWaterCentralGSFW},
{RT_WATER_IRONS_CENTRAL_GS,&LogicWaterCentralGSIrons},
{RT_WATER_CENTRAL_BOW,&LogicWaterCentralBow},
{RT_WATER_HOOKSHOT_FALLING_PLATFORM_GS,&LogicWaterFallingPlatformGSHookshot},
{RT_WATER_RANG_FALLING_PLATFORM_GS,&LogicWaterFallingPlatformGSBoomerang},
{RT_WATER_RIVER_GS,&LogicWaterRiverGS},
{RT_WATER_DRAGON_JUMP_DIVE,&LogicWaterDragonJumpDive},
{RT_WATER_ADULT_DRAGON,&LogicWaterDragonAdult},
{RT_WATER_CHILD_DRAGON,&LogicWaterDragonChild},
{RT_WATER_MQ_CENTRAL_PILLAR,&LogicWaterMQCentralPillar},
{RT_WATER_MQ_LOCKED_GS,&LogicWaterMQLockedGS},
{RT_LENS_SHADOW,&LogicLensShadow},
{RT_LENS_SHADOW_PLATFORM,&LogicLensShadowPlatform},
{RT_LENS_BONGO,&LogicLensBongo},
{RT_SHADOW_UMBRELLA,&LogicShadowUmbrella},
{RT_SHADOW_UMBRELLA_GS,&LogicShadowUmbrellaGS},
{RT_SHADOW_FREESTANDING_KEY,&LogicShadowFreestandingKey},
{RT_SHADOW_STATUE,&LogicShadowStatue},
{RT_SHADOW_BONGO,&LogicShadowBongo},
{RT_LENS_SHADOW_MQ,&LogicLensShadowMQ},
{RT_LENS_SHADOW_MQ_INVISIBLE_BLADES,&LogicLensShadowMQInvisibleBlades},
{RT_LENS_SHADOW_MQ_PLATFORM,&LogicLensShadowMQPlatform},
{RT_LENS_SHADOW_MQ_DEADHAND,&LogicLensShadowMQDeadHand},
{RT_SHADOW_MQ_GAP,&LogicShadowMQGap},
{RT_SHADOW_MQ_INVISIBLE_BLADES,&LogicShadowMQInvisibleBlades},
{RT_SHADOW_MQ_HUGE_PIT,&LogicShadowMQHugePit},
{RT_SHADOW_MQ_WINDY_WALKWAY,&LogicShadowMQWindyWalkway},
{RT_LENS_SPIRIT,&LogicLensSpirit},
{RT_SPIRIT_CHILD_CHU,&LogicSpiritChildBombchu},
{RT_SPIRIT_LOBBY_GS,&LogicSpiritLobbyGS},
{RT_SPIRIT_LOWER_ADULT_SWITCH,&LogicSpiritLowerAdultSwitch},
{RT_SPIRIT_LOBBY_JUMP,&LogicSpiritLobbyJump},
{RT_SPIRIT_PLATFORM_HOOKSHOT,&LogicSpiritPlatformHookshot},
{RT_SPIRIT_MAP_CHEST,&LogicSpiritMapChest},
{RT_SPIRIT_SUN_CHEST,&LogicSpiritSunChest},
{RT_SPIRIT_WALL,&LogicSpiritWall},
{RT_LENS_SPIRIT_MQ,&LogicLensSpiritMQ},
{RT_SPIRIT_MQ_SUN_BLOCK_SOT,&LogicSpiritMQSunBlockSoT},
{RT_SPIRIT_MQ_SUN_BLOCK_GS,&LogicSpiritMQSunBlockGS},
{RT_SPIRIT_MQ_LOWER_ADULT,&LogicSpiritMQLowerAdult},
{RT_SPIRIT_MQ_FROZEN_EYE,&LogicSpiritMQFrozenEye},
{RT_ICE_BLOCK_GS,&LogicIceBlockGS},
{RT_ICE_MQ_RED_ICE_GS,&LogicIceMQRedIceGS},
{RT_ICE_MQ_SCARECROW,&LogicIceMQScarecrow},
{RT_LENS_GTG,&LogicLensGtg},
{RT_GTG_WITHOUT_HOOKSHOT,&LogicGtgWithoutHookshot},
{RT_GTG_FAKE_WALL,&LogicGtgFakeWall},
{RT_LENS_GTG_MQ,&LogicLensGtgMQ},
{RT_GTG_MQ_WITH_HOOKSHOT,&LogicGtgMQWithHookshot},
{RT_GTG_MQ_WIHTOUT_HOOKSHOT,&LogicGtgMQWithoutHookshot},
{RT_LENS_GANON,&LogicLensCastle},
{RT_GANON_SPIRIT_TRIAL_HOOKSHOT,&LogicSpiritTrialHookshot},
{RT_LENS_GANON_MQ,&LogicLensCastleMQ},
{RT_GANON_MQ_FIRE_TRIAL,&LogicFireTrialMQ},
{RT_GANON_MQ_SHADOW_TRIAL,&LogicShadowTrialMQ},
{RT_GANON_MQ_LIGHT_TRIAL,&LogicLightTrialMQ},
};
//Function to avoid accidentally naming the options wrong, as logic.cpp requires these exact names
std::vector<std::string> GlitchDifficultyOptions(uint8_t enabledDifficulties) {
static constexpr std::array glitchDifficulties{"Novice", "Intermediate", "Advanced", "Expert", "Hero"};
//TODO completely rewrite glitch section since oot3d glitches differ from oot
Option GlitchEquipSwapDins = LogicTrick("", LogicTempDesc);
Option GlitchEquipSwap = LogicTrick("", LogicTempDesc);
std::vector<std::string> selectableDifficulties;
selectableDifficulties.push_back("Disabled");
for (size_t i = 0; i < glitchDifficulties.size(); i++) {
if ((enabledDifficulties >> i) & 1) {
selectableDifficulties.push_back(glitchDifficulties[i]);
}
}
return selectableDifficulties;
}
Option GlitchRestrictedItems = Option::U8("Restricted Items", GlitchDifficultyOptions(0b00001), { GlitchRestrictedItemsDescDisabled , GlitchRestrictedItemsDescNovice });
Option GlitchSuperStab = Option::U8("Super Stab", GlitchDifficultyOptions(0b00001), { GlitchSuperStabDescDisabled , GlitchSuperStabDescNovice });
Option GlitchISG = Option::U8("Infinite Sword Glitch", GlitchDifficultyOptions(0b00111), { GlitchISGDescDisabled , GlitchISGDescNovice , GlitchISGDescIntermediate , GlitchISGDescAdvanced });
Option GlitchHover = Option::U8("Bomb Hover", GlitchDifficultyOptions(0b00111), { GlitchHoverDescDisabled , GlitchHoverDescNovice , GlitchHoverDescIntermediate , GlitchHoverDescAdvanced });
Option GlitchBombOI = Option::U8("Ocarina Items (Bomb)", GlitchDifficultyOptions(0b01111), { GlitchBombOIDescDisabled , GlitchBombOIDescNovice , GlitchBombOIDescIntermediate , GlitchBombOIDescAdvanced , GlitchBombOIDescExpert });
Option GlitchHoverBoost = Option::U8("HoverBoost", GlitchDifficultyOptions(0b00111), { GlitchHoverBoostDescDisabled , GlitchHoverBoostDescNovice , GlitchHoverBoostDescIntermediate , GlitchHoverBoostDescAdvanced });
Option GlitchSuperSlide = Option::U8("Extended Super Slide", GlitchDifficultyOptions(0b01111), { GlitchSuperSlideDescDisabled , GlitchSuperSlideDescNovice , GlitchSuperSlideDescIntermediate , GlitchSuperSlideDescAdvanced , GlitchSuperSlideDescExpert });
Option GlitchMegaflip = Option::U8("Megaflip", GlitchDifficultyOptions(0b11111), { GlitchMegaflipDescDisabled , GlitchMegaflipDescNovice , GlitchMegaflipDescIntermediate , GlitchMegaflipDescAdvanced , GlitchMegaflipDescExpert , GlitchMegaflipDescHero });
Option GlitchASlide = Option::U8("A-Slide", GlitchDifficultyOptions(0b01111), { GlitchASlideDescDisabled , GlitchASlideDescNovice , GlitchASlideDescIntermediate , GlitchASlideDescAdvanced , GlitchASlideDescExpert });
Option GlitchHammerSlide = Option::U8("Hammer Slide", GlitchDifficultyOptions(0b00011), { GlitchHammerSlideDescDisabled , GlitchHammerSlideDescNovice , GlitchHammerSlideDescIntermediate });
Option GlitchLedgeCancel = Option::U8("Ledge Cancel", GlitchDifficultyOptions(0b00111), { GlitchLedgeCancelDescDisabled , GlitchLedgeCancelDescNovice , GlitchLedgeCancelDescIntermediate , GlitchLedgeCancelDescAdvanced });
Option GlitchActionSwap = Option::U8("Action Swap", GlitchDifficultyOptions(0b00101), { GlitchActionSwapDescDisabled , GlitchActionSwapDescNovice , GlitchActionSwapDescAdvanced });
Option GlitchQPA = Option::U8("Quick Put Away", GlitchDifficultyOptions(0b01111), { GlitchQPADescDisabled , GlitchQPADescNovice , GlitchQPADescIntermediate , GlitchQPADescAdvanced , GlitchQPADescExpert });
Option GlitchHookshotClip = Option::U8("Hookshot Clip", GlitchDifficultyOptions(0b00011), { GlitchHookshotClipDescDisabled , GlitchHookshotClipDescNovice , GlitchHookshotClipDescIntermediate });
Option GlitchHookshotJump_Bonk = Option::U8("Hookshot Jump (Bonk)", GlitchDifficultyOptions(0b00111), { GlitchHookshotJump_BonkDescDisabled , GlitchHookshotJump_BonkDescNovice , GlitchHookshotJump_BonkDescIntermediate , GlitchHookshotJump_BonkDescAdvanced });
Option GlitchHookshotJump_Boots = Option::U8("Hookshot Jump (Boots)", GlitchDifficultyOptions(0b00111), { GlitchHookshotJump_BootsDescDisabled , GlitchHookshotJump_BootsDescNovice , GlitchHookshotJump_BootsDescIntermediate , GlitchHookshotJump_BootsDescAdvanced });
Option GlitchCutsceneDive = Option::U8("Cutscene Dives", GlitchDifficultyOptions(0b00111), { GlitchCutsceneDiveDescDisabled , GlitchCutsceneDiveDescNovice , GlitchCutsceneDiveDescIntermediate , GlitchCutsceneDiveDescAdvanced });
Option GlitchNaviDive_Stick = Option::U8("Navi Dive (Stick)", GlitchDifficultyOptions(0b00111), { GlitchNaviDive_StickDescDisabled , GlitchNaviDive_StickDescNovice , GlitchNaviDive_StickDescIntermediate , GlitchNaviDive_StickDescAdvanced });
Option GlitchTripleSlashClip = Option::U8("Triple Slash Clip", GlitchDifficultyOptions(0b01111), { GlitchTripleSlashClipDescDisabled , GlitchTripleSlashClipDescNovice , GlitchTripleSlashClipDescIntermediate , GlitchTripleSlashClipDescAdvanced , GlitchTripleSlashClipDescExpert });
Option GlitchLedgeClip = Option::U8("Ledge Clip", GlitchDifficultyOptions(0b00111), { GlitchLedgeClipDescDisabled , GlitchLedgeClipDescNovice , GlitchLedgeClipDescIntermediate , GlitchLedgeClipDescAdvanced });
Option GlitchSeamWalk = Option::U8("Seam Walk", GlitchDifficultyOptions(0b11111), { GlitchSeamWalkDescDisabled , GlitchSeamWalkDescNovice , GlitchSeamWalkDescIntermediate , GlitchSeamWalkDescAdvanced , GlitchSeamWalkDescExpert , GlitchSeamWalkDescHero });
std::vector<Option*> glitchCategories = {
&GlitchRestrictedItems,
&GlitchSuperStab,
&GlitchISG,
&GlitchHover,
&GlitchBombOI,
&GlitchHoverBoost,
&GlitchSuperSlide,
&GlitchMegaflip,
&GlitchASlide,
&GlitchHammerSlide,
&GlitchLedgeCancel,
&GlitchActionSwap,
&GlitchQPA,
&GlitchHookshotClip,
&GlitchHookshotJump_Bonk,
&GlitchHookshotJump_Boots,
&GlitchCutsceneDive,
&GlitchNaviDive_Stick,
&GlitchTripleSlashClip,
&GlitchLedgeClip,
&GlitchSeamWalk,
&GlitchEquipSwapDins,
&GlitchEquipSwap,
};
Option GlitchWWTEscape = Option::Bool("WWT Kokiri\n Forest Escape", {"Off", "On"}, {GlitchWWTEscapeDesc});
Option GlitchGVTentAsChild = Option::Bool("Enter GV Tent\n as Child", {"Off", "On"}, {GlitchGVTentAsChildDesc});
Option GlitchGFGuardSneak = Option::Bool("Sneak Past\n the GF Guard", {"Off", "On"}, {GlitchGFGuardSneakDesc});
Option GlitchItemlessWasteland = Option::Bool("Cross the HW\n w/o Items", {"Off", "On"}, {GlitchItemlessWastelandDesc});
Option GlitchOccamsStatue = Option::Bool("Occam's Statue", {"Off", "On"}, {GlitchOccamsStatueDesc});
Option GlitchZDOoBJumpSlash = Option::Bool("ZD OoB w/\n Jump Slash", {"Off", "On"}, {GlitchZDOoBJumpSlashDesc});
Option GlitchJabuStickRecoil = Option::Bool("Enter Jabu\n w/o Bottle", {"Off", "On"}, {GlitchJabuStickRecoilDesc});
Option GlitchJabuAdult = Option::Bool("Enter Jabu\n as Adult", {"Off", "On"}, {GlitchJabuAdultDesc});
Option GlitchBlueFireWall = Option::Bool("Break Walls\n w/ Blue Fire", {"Off", "On"}, {GlitchBlueFireWallDesc});
Option GlitchClassicHalfie = Option::Bool("Classic Halfie", {"Off", "On"}, {GlitchClassicHalfieDesc});
Option GlitchModernHalfie = Option::Bool("Modern Halfie", {"Off", "On"}, {GlitchModernHalfieDesc});
Option GlitchJabuSwitch = Option::Bool("Jabu Switch\n w/ CS item", {"Off", "On"}, {GlitchJabuSwitchDesc});
Option GlitchForestBKSkip = Option::Bool("Forest Temple\n BK Skip", {"Off", "On"}, {GlitchForestBKSkipDesc});
Option GlitchFireGrunzClip = Option::Bool("Fire Temple\n Grunz Clip", {"Off", "On"}, {GlitchFireGrunzClipDesc});
std::vector<Option*> miscGlitches = {
&GlitchWWTEscape,
&GlitchGVTentAsChild,
&GlitchGFGuardSneak,
&GlitchItemlessWasteland,
&GlitchOccamsStatue,
&GlitchZDOoBJumpSlash,
&GlitchJabuStickRecoil,
&GlitchJabuAdult,
&GlitchBlueFireWall,
&GlitchClassicHalfie,
&GlitchModernHalfie,
&GlitchJabuSwitch,
&GlitchForestBKSkip,
&GlitchFireGrunzClip,
};
Menu glitchCategorySettings = Menu::SubMenu("General Categories", &glitchCategories, false);
Menu miscGlitchSettings = Menu::SubMenu("Miscellaneous Glitches", &miscGlitches, false);
@ -2200,109 +2460,6 @@ namespace Settings {
StartingDoubleDefense.Unlock();
}
if (currentSetting != nullptr) {
if (currentSetting->GetName() == "All Tricks") {
for (uint16_t i = 1; i < Settings::trickOptions.size(); i++) {
trickOptions[i]->SetSelectedIndex(0);
}
if(currentSetting->GetSelectedOptionIndex() >= 1){ //novice options
LogicGrottosWithoutAgony.SetSelectedIndex(1);
LogicVisibleCollision.SetSelectedIndex(1);
LogicFewerTunicRequirements.SetSelectedIndex(1);
LogicLostWoodsGSBean.SetSelectedIndex(1);
LogicLabDiving.SetSelectedIndex(1);
LogicGraveyardPoH.SetSelectedIndex(1);
LogicGVHammerChest.SetSelectedIndex(1);
LogicManOnRoof.SetSelectedIndex(1);
LogicWindmillPoHHookshot.SetSelectedIndex(1);
LogicGoronCityLeftMost.SetSelectedIndex(1);
LogicZoraRiverLower.SetSelectedIndex(1);
LogicZoraRiverUpper.SetSelectedIndex(1);
LogicZFGreatFairy.SetSelectedIndex(1);
LogicDekuB1WebsWithBow.SetSelectedIndex(1);
LogicDCJump.SetSelectedIndex(1);
LogicJabuScrubJumpDive.SetSelectedIndex(1);
LogicForestOutdoorEastGS.SetSelectedIndex(1);
LogicFireScarecrow.SetSelectedIndex(1);
LogicWaterTempleTorchLongshot.SetSelectedIndex(1);
LogicWaterCentralGSFW.SetSelectedIndex(1);
LogicWaterNorthBasementLedgeJump.SetSelectedIndex(1);
LogicWaterRiverGS.SetSelectedIndex(1);
LogicSpiritLowerAdultSwitch.SetSelectedIndex(1);
LogicShadowStatue.SetSelectedIndex(1);
LogicChildDeadhand.SetSelectedIndex(1);
LogicGtgFakeWall.SetSelectedIndex(1);
LogicLensSpirit.SetSelectedIndex(1);
LogicLensShadow.SetSelectedIndex(1);
LogicLensGtg.SetSelectedIndex(1);
LogicLensJabuMQ.SetSelectedIndex(1);
LogicLensSpiritMQ.SetSelectedIndex(1);
LogicLensShadowMQ.SetSelectedIndex(1);
LogicLensBotwMQ.SetSelectedIndex(1);
LogicLensGtgMQ.SetSelectedIndex(1);
LogicFlamingChests.SetSelectedIndex(1);
}
if(currentSetting->GetSelectedOptionIndex() >= 2){ //intermediate options
LogicLabWallGS.SetSelectedIndex(1);
LogicChildDampeRacePoH.SetSelectedIndex(1);
LogicGerudoKitchen.SetSelectedIndex(1);
LogicOutsideGanonsGS.SetSelectedIndex(1);
LogicDMTSoilGS.SetSelectedIndex(1);
LogicDMTSummitHover.SetSelectedIndex(1);
LogicLinkGoronDins.SetSelectedIndex(1);
LogicGoronCityPotWithStrength.SetSelectedIndex(1);
//LogicCraterUpperToLower.SetSelectedIndex(1);
LogicBiggoronBolero.SetSelectedIndex(1);
LogicDekuB1Skip.SetSelectedIndex(1);
LogicDekuBasementGS.SetSelectedIndex(1);
LogicDCStaircase.SetSelectedIndex(1);
LogicDCScarecrowGS.SetSelectedIndex(1);
//LogicJabuBossGSAdult.SetSelectedIndex(1);
//LogicForestOutsideBackdoor.SetSelectedIndex(1);
LogicForestDoorFrame.SetSelectedIndex(1);
LogicFireBossDoorJump.SetSelectedIndex(1);
LogicFireSongOfTime.SetSelectedIndex(1);
LogicWaterCentralBow.SetSelectedIndex(1);
LogicWaterBossKeyRegion.SetSelectedIndex(1);
LogicWaterBKJumpDive.SetSelectedIndex(1);
LogicWaterFallingPlatformGS.SetSelectedIndex(1);
LogicSpiritChildBombchu.SetSelectedIndex(1);
LogicSpiritLobbyGS.SetSelectedIndex(1);
LogicSpiritMapChest.SetSelectedIndex(1);
LogicShadowFreestandingKey.SetSelectedIndex(1);
LogicLensShadowBack.SetSelectedIndex(1);
LogicLensBotw.SetSelectedIndex(1);
LogicLensCastle.SetSelectedIndex(1);
LogicLensShadowMQBack.SetSelectedIndex(1);
LogicLensCastleMQ.SetSelectedIndex(1);
LogicSpiritTrialHookshot.SetSelectedIndex(1);
}
if(currentSetting->GetSelectedOptionIndex() == 3){ //expert options
LogicLensWasteland.SetSelectedIndex(1);
LogicReverseWasteland.SetSelectedIndex(1);
LogicColossusGS.SetSelectedIndex(1);
LogicDMTBombable.SetSelectedIndex(1);
LogicGoronCityPot.SetSelectedIndex(1);
LogicChildRollingWithStrength.SetSelectedIndex(1);
LogicCraterBeanPoHWithHovers.SetSelectedIndex(1);
LogicDCSlingshotSkip.SetSelectedIndex(1);
LogicFireStrength.SetSelectedIndex(1);
LogicFireFlameMaze.SetSelectedIndex(1);
LogicWaterTempleUpperBoost.SetSelectedIndex(1);
LogicWaterCrackedWallNothing.SetSelectedIndex(1);
LogicWaterCrackedWallHovers.SetSelectedIndex(1);
LogicWaterDragonAdult.SetSelectedIndex(1);
LogicWaterDragonJumpDive.SetSelectedIndex(1);
LogicSpiritWall.SetSelectedIndex(1);
LogicSpiritSunChest.SetSelectedIndex(1);
//LogicShadowFireArrowEntry.SetSelectedIndex(1);
LogicShadowUmbrella.SetSelectedIndex(1);
LogicShadowBongo.SetSelectedIndex(1);
LogicGtgWithoutHookshot.SetSelectedIndex(1);
}
}
}
// Multiplayer
for (auto op : multiplayerOptions) {
if (op == &MP_Enabled) {
@ -2665,18 +2822,19 @@ namespace Settings {
}
//Function to set flags depending on settings
void UpdateSettings(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations) {
void UpdateSettings(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks) {
// RANDTODO: Switch this back once all logic options are implemented
// Logic.SetSelectedIndex(cvarSettings[RSK_LOGIC_RULES]);
//Logic.SetSelectedIndex(cvarSettings[RSK_LOGIC_RULES]);
//TODO switch back for glitch logic
switch (cvarSettings[RSK_LOGIC_RULES]) {
case RO_LOGIC_GLITCHLESS:
Logic.SetSelectedIndex(0);
break;
case RO_LOGIC_NO_LOGIC:
Logic.SetSelectedIndex(2);
break;
case RO_LOGIC_GLITCHLESS:
Logic.SetSelectedIndex(0);
break;
case RO_LOGIC_NO_LOGIC:
Logic.SetSelectedIndex(2);
break;
}
LocationsReachable.SetSelectedIndex(cvarSettings[RSK_ALL_LOCATIONS_REACHABLE]);
AddExcludedOptions();
@ -2689,6 +2847,13 @@ namespace Settings {
}
}
//tricks
for (auto randomizerTrick : enabledTricks) {
trickOptionMap[randomizerTrick]->SetSelectedIndex(1);
}
OpenForest.SetSelectedIndex(cvarSettings[RSK_FOREST]);
OpenKakariko.SetSelectedIndex(cvarSettings[RSK_KAK_GATE]);
ZorasFountain.SetSelectedIndex(cvarSettings[RSK_ZORAS_FOUNTAIN]);

240
soh/soh/Enhancements/randomizer/3drando/settings.hpp
View File

@ -893,7 +893,7 @@ class Menu {
};
namespace Settings {
void UpdateSettings(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations);
void UpdateSettings(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettings, std::set<RandomizerCheck> excludedLocations, std::set<RandomizerTrick> enabledTricks);
SettingsContext FillContext();
void InitSettings();
void SetDefaultSettings();
@ -1131,134 +1131,186 @@ void UpdateSettings(std::unordered_map<RandomizerSettingKey, uint8_t> cvarSettin
extern Option NightGSExpectSuns;
//Trick Settings
//New Trick Settings (from ootr https://github.com/ootrandomizer/OoT-Randomizer/blob/Dev/SettingsList.py, additions to this list marked)
extern Option ToggleAllTricks;
extern Option LogicGrottosWithoutAgony;
extern Option LogicVisibleCollision;
extern Option LogicGrottosWithoutAgony;
extern Option LogicFewerTunicRequirements;
extern Option LogicRustedSwitches;
extern Option LogicFlamingChests;
extern Option LogicBunnyHoodJump; //NEW not implemented
extern Option LogicDamageBoost; //NEW not implemented
extern Option LogicHoverBoost; //NEW not implemented
extern Option LogicAdultKokiriGS;
extern Option LogicLostWoodsBridge;
extern Option LogicMidoBackflip;
extern Option LogicLostWoodsGSBean;
extern Option LogicLabDiving;
extern Option LogicLabWallGS;
extern Option LogicCastleStormsGS;
extern Option LogicManOnRoof;
extern Option LogicKakarikoTowerGS;
extern Option LogicAdultWindmillPoH;
extern Option LogicChildWindmillPoH; //NEW not implemented
extern Option LogicKakarikoRooftopGS;
extern Option LogicGraveyardPoH;
extern Option LogicChildDampeRacePoH;
extern Option LogicGVHammerChest;
extern Option LogicGerudoKitchen;
extern Option LogicLensWasteland;
extern Option LogicReverseWasteland;
extern Option LogicColossusGS;
extern Option LogicOutsideGanonsGS;
extern Option LogicManOnRoof;
extern Option LogicWindmillPoHHookshot;
extern Option LogicDMTBombable;
extern Option LogicShadowFireArrowEntry;
extern Option LogicDMTSoilGS;
extern Option LogicDMTSummitHover;
extern Option LogicLinkGoronDins;
extern Option LogicGoronCityLeftMost;
extern Option LogicDMTBombable;
extern Option LogicDMTGSLowerHookshot;
extern Option LogicDMTGSLowerHovers;
extern Option LogicDMTGSLowerBean;
extern Option LogicDMTGSLowerJS; //NEW
extern Option LogicDMTClimbHovers;
extern Option LogicDMTGSUpper;
extern Option LogicBiggoronBolero; //not implemented - unnecessary with SoH rando
extern Option LogicGoronCityPot;
extern Option LogicGoronCityPotWithStrength;
extern Option LogicChildRollingWithStrength;
extern Option LogicCraterUpperToLower;
extern Option LogicGoronCityLeftMost;
extern Option LogicGoronCityGrotto;
extern Option LogicGoronCityLinkGoronDins;
extern Option LogicCraterBeanPoHWithHovers;
extern Option LogicBiggoronBolero;
extern Option LogicCraterBoleroJump;
extern Option LogicCraterBoulderJS;
extern Option LogicCraterBoulderSkip;
extern Option LogicZoraRiverLower;
extern Option LogicZoraRiverUpper;
extern Option LogicZFGreatFairy;
extern Option LogicDekuB1WebsWithBow;
extern Option LogicDekuB1Skip;
extern Option LogicZoraWithHovers;
extern Option LogicZoraWithCucco;
extern Option LogicKingZoraSkip;
extern Option LogicDomainGS;
extern Option LogicLabWallGS;
extern Option LogicLabDiving;
extern Option LogicWaterHookshotEntry;
extern Option LogicValleyCrateHovers;
extern Option LogicGerudoKitchen;
extern Option LogicGFJump;
extern Option LogicWastelandBunnyCrossing; //NEW not implemented
extern Option LogicWastelandCrossing;
extern Option LogicLensWasteland;
extern Option LogicReverseWasteland;
extern Option LogicColossusGS;
extern Option LogicDekuBasementGS;
extern Option LogicDCStaircase;
extern Option LogicDCJump;
extern Option LogicDCSlingshotSkip;
extern Option LogicDekuB1Skip;
extern Option LogicDekuB1WebsWithBow;
extern Option LogicDekuMQCompassGS;
extern Option LogicDekuMQLog;
extern Option LogicDCScarecrowGS;
extern Option LogicJabuBossGSAdult;
extern Option LogicJabuScrubJumpDive;
extern Option LogicForestOutsideBackdoor;
extern Option LogicForestDoorFrame;
extern Option LogicDCVinesGS;
extern Option LogicDCStaircase;
extern Option LogicDCSlingshotSkip;
extern Option LogicDCScrubRoom;
extern Option LogicDCJump;
extern Option LogicDCHammerFloor;
extern Option LogicDCMQChildBombs;
extern Option LogicDCMQEyesChild;
extern Option LogicDCMQEyesAdult;
extern Option LogicJabuAlcoveJumpDive;
extern Option LogicJabuBossHover;
extern Option LogicJabuNearBossRanged;
extern Option LogicJabuNearBossExplosives;
extern Option LogicLensJabuMQ;
extern Option LogicJabuMQRangJump; //not implemented - requires dungeon shortcuts which is not built into rando yet
extern Option LogicJabuMQSoTGS;
extern Option LogicLensBotw;
extern Option LogicChildDeadhand;
extern Option LogicBotwBasement;
extern Option LogicBotwMQPits;
extern Option LogicBotwMQDeadHandKey;
extern Option LogicForestFirstGS;
extern Option LogicForestOutdoorEastGS;
extern Option LogicForestVines;
extern Option LogicForestOutdoorsLedge;
extern Option LogicForestDoorFrame;
extern Option LogicForestOutsideBackdoor;
extern Option LogicForestMQWellSwim;
extern Option LogicForestMQBlockPuzzle;
extern Option LogicForestMQHallwaySwitchJS;
extern Option LogicForestMQHallwaySwitchHookshot; //not implemented yet
extern Option LogicForestMQHallwaySwitchBoomerang;
extern Option LogicFireBossDoorJump;
extern Option LogicFireSongOfTime;
extern Option LogicFireStrength;
extern Option LogicFireScarecrow;
extern Option LogicFireFlameMaze;
extern Option LogicFireSongOfTime;
extern Option LogicFireMQNearBoss;
extern Option LogicFireMQBlockedChest;
extern Option LogicFireMQBKChest;
extern Option LogicFireMQClimb;
extern Option LogicFireMQMazeSideRoom;
extern Option LogicFireMQMazeHovers;
extern Option LogicFireMQMazeJump;
extern Option LogicFireMQAboveMazeGS;
extern Option LogicFireMQFlameMaze;
extern Option LogicWaterTempleTorchLongshot;
extern Option LogicWaterTempleUpperBoost;
extern Option LogicWaterCentralBow;
extern Option LogicWaterCentralGSFW;
extern Option LogicWaterCrackedWallNothing;
extern Option LogicWaterCrackedWallHovers;
extern Option LogicWaterCrackedWallNothing;
extern Option LogicWaterBossKeyRegion;
extern Option LogicWaterBKJumpDive;
extern Option LogicWaterNorthBasementLedgeJump;
extern Option LogicWaterBKJumpDive;
extern Option LogicWaterCentralGSFW;
extern Option LogicWaterCentralGSIrons;
extern Option LogicWaterCentralBow;
extern Option LogicWaterFallingPlatformGSHookshot;
extern Option LogicWaterFallingPlatformGSBoomerang;
extern Option LogicWaterRiverGS;
extern Option LogicWaterDragonJumpDive;
extern Option LogicWaterDragonAdult;
extern Option LogicWaterRiverGS;
extern Option LogicWaterFallingPlatformGS;
extern Option LogicSpiritLowerAdultSwitch;
extern Option LogicSpiritChildBombchu;
extern Option LogicSpiritWall;
extern Option LogicSpiritLobbyGS;
extern Option LogicSpiritMapChest;
extern Option LogicSpiritSunChest;
extern Option LogicShadowFireArrowEntry;
extern Option LogicWaterDragonChild;
extern Option LogicWaterMQCentralPillar;
extern Option LogicWaterMQLockedGS;
extern Option LogicLensShadow;
extern Option LogicLensShadowPlatform;
extern Option LogicLensBongo;
extern Option LogicShadowUmbrella;
extern Option LogicShadowUmbrellaGS;
extern Option LogicShadowFreestandingKey;
extern Option LogicShadowStatue;
extern Option LogicShadowBongo;
extern Option LogicChildDeadhand;
extern Option LogicShadowBongo; //not implemented - projectiles are not expected for bongo anyways
extern Option LogicLensShadowMQ;
extern Option LogicLensShadowMQInvisibleBlades;
extern Option LogicLensShadowMQPlatform;
extern Option LogicLensShadowMQDeadHand;
extern Option LogicShadowMQGap;
extern Option LogicShadowMQInvisibleBlades;
extern Option LogicShadowMQHugePit;
extern Option LogicShadowMQWindyWalkway; //not implemented - requires dungeon shortcuts which is not built into rando yet
extern Option LogicLensSpirit;
extern Option LogicSpiritChildBombchu;
extern Option LogicSpiritLobbyGS;
extern Option LogicSpiritLowerAdultSwitch;
extern Option LogicSpiritLobbyJump;
extern Option LogicSpiritPlatformHookshot; //not implemented - requires boss shortcuts which is not built into rando yet
extern Option LogicSpiritMapChest;
extern Option LogicSpiritSunChest;
extern Option LogicSpiritWall;
extern Option LogicLensSpiritMQ;
extern Option LogicSpiritMQSunBlockSoT;
extern Option LogicSpiritMQSunBlockGS;
extern Option LogicSpiritMQLowerAdult;
extern Option LogicSpiritMQFrozenEye;
extern Option LogicIceBlockGS;
extern Option LogicIceMQRedIceGS;
extern Option LogicIceMQScarecrow;
extern Option LogicLensGtg;
extern Option LogicGtgWithoutHookshot;
extern Option LogicGtgFakeWall;
extern Option LogicLensSpirit;
extern Option LogicLensShadow;
extern Option LogicLensShadowBack;
extern Option LogicLensBotw;
extern Option LogicLensGtg;
extern Option LogicLensCastle;
extern Option LogicLensJabuMQ;
extern Option LogicLensSpiritMQ;
extern Option LogicLensShadowMQ;
extern Option LogicLensShadowMQBack;
extern Option LogicLensBotwMQ;
extern Option LogicLensGtgMQ;
extern Option LogicLensCastleMQ;
extern Option LogicGtgMQWithHookshot;
extern Option LogicGtgMQWithoutHookshot;
extern Option LogicLensCastle;
extern Option LogicSpiritTrialHookshot;
extern Option LogicFlamingChests;
extern Option LogicLensCastleMQ;
extern Option LogicFireTrialMQ;
extern Option LogicShadowTrialMQ;
extern Option LogicLightTrialMQ;
//Glitch Settings
extern Option GlitchRestrictedItems;
extern Option GlitchSuperStab;
extern Option GlitchISG;
extern Option GlitchHover;
extern Option GlitchBombOI;
extern Option GlitchHoverBoost;
extern Option GlitchSuperSlide;
extern Option GlitchMegaflip;
extern Option GlitchASlide;
extern Option GlitchHammerSlide;
extern Option GlitchLedgeCancel;
extern Option GlitchActionSwap;
extern Option GlitchQPA;
extern Option GlitchHookshotClip;
extern Option GlitchHookshotJump_Bonk;
extern Option GlitchHookshotJump_Boots;
extern Option GlitchCutsceneDive;
extern Option GlitchNaviDive_Stick;
extern Option GlitchTripleSlashClip;
extern Option GlitchLedgeClip;
extern Option GlitchSeamWalk;
//Misc Glitch Settings
extern Option GlitchWWTEscape;
extern Option GlitchGVTentAsChild;
extern Option GlitchGFGuardSneak;
extern Option GlitchItemlessWasteland;
extern Option GlitchOccamsStatue;
extern Option GlitchZDOoBJumpSlash;
extern Option GlitchJabuStickRecoil;
extern Option GlitchJabuAdult;
extern Option GlitchBlueFireWall;
extern Option GlitchClassicHalfie;
extern Option GlitchModernHalfie;
extern Option GlitchJabuSwitch;
extern Option GlitchForestBKSkip;
extern Option GlitchFireGrunzClip;
extern Option GlitchEquipSwapDins;
extern Option GlitchEquipSwap;
//Multiplayer Settings
extern Option MP_Enabled;

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

@ -11,6 +11,7 @@
#include "utils.hpp"
#include "shops.hpp"
#include "hints.hpp"
#include "../randomizer_tricks.h"
#include "pool_functions.hpp"
#include "soh/Enhancements/randomizer/randomizer_check_objects.h"
#include <nlohmann/json.hpp>
@ -485,20 +486,20 @@ static void WriteStartingInventory() {
// Writes the enabled tricks to the spoiler log, if there are any.
static void WriteEnabledTricks(tinyxml2::XMLDocument& spoilerLog) {
auto parentNode = spoilerLog.NewElement("enabled-tricks");
//auto parentNode = spoilerLog.NewElement("enabled-tricks");
for (const auto& setting : Settings::trickOptions) {
if (setting->GetSelectedOptionIndex() != TRICK_ENABLED || !setting->IsCategory(OptionCategory::Setting)) {
if (setting->GetSelectedOptionIndex() != TRICK_ENABLED/* || !setting->IsCategory(OptionCategory::Setting)*/) {
continue;
}
auto node = parentNode->InsertNewChildElement("trick");
node->SetAttribute("name", RemoveLineBreaks(setting->GetName()).c_str());
jsonData["enabledTricks"].push_back(RemoveLineBreaks(RandomizerTricks::GetRTName((RandomizerTrick)std::stoi(setting->GetName()))).c_str());
//auto node = parentNode->InsertNewChildElement("trick");
//node->SetAttribute("name", RemoveLineBreaks(setting->GetName()).c_str());
}
if (!parentNode->NoChildren()) {
spoilerLog.RootElement()->InsertEndChild(parentNode);
}
// if (!parentNode->NoChildren()) {
// spoilerLog.RootElement()->InsertEndChild(parentNode);
//}
}
// Writes the enabled glitches to the spoiler log, if there are any.
@ -855,7 +856,7 @@ const char* SpoilerLog_Write(int language) {
WriteSettings();
WriteExcludedLocations();
WriteStartingInventory();
//WriteEnabledTricks(spoilerLog);
WriteEnabledTricks(spoilerLog);
//if (Settings::Logic.Is(LOGIC_GLITCHED)) {
// WriteEnabledGlitches(spoilerLog);
//}

429
soh/soh/Enhancements/randomizer/randomizer.cpp
View File

@ -21,6 +21,7 @@
#include "../../../src/overlays/actors/ovl_En_GirlA/z_en_girla.h"
#include <stdexcept>
#include "randomizer_check_objects.h"
#include "randomizer_tricks.h"
#include <sstream>
#include <tuple>
#include <functional>
@ -43,6 +44,8 @@ std::unordered_map<std::string, RandomizerCheckArea> SpoilerfileAreaNameToEnum;
std::unordered_map<std::string, HintType> SpoilerfileHintTypeNameToEnum;
std::multimap<std::tuple<s16, s16, s32>, RandomizerCheckObject> checkFromActorMultimap;
std::set<RandomizerCheck> excludedLocations;
std::set<RandomizerTrick> enabledTricks;
std::set<RandomizerTrick> enabledGlitches;
u8 generated;
char* seedString;
@ -384,6 +387,17 @@ bool Randomizer::SpoilerFileExists(const char* spoilerFileName) {
#pragma GCC pop_options
#pragma optimize("", on)
void DrawTagChips(const std::vector<RandomizerTrickTag> &rtTags) {
for (auto rtTag : rtTags) {
ImGui::SameLine();
ImGui::BeginDisabled();
ImGui::PushStyleColor(ImGuiCol_Button, RandomizerTricks::GetRTTagColor(rtTag));
ImGui::SmallButton(RandomizerTricks::GetRTTagName(rtTag).c_str());
ImGui::PopStyleColor();
ImGui::EndDisabled();
}
}
void Randomizer::LoadRandomizerSettings(const char* spoilerFileName) {
if (strcmp(spoilerFileName, "") != 0) {
ParseRandomizerSettingsFile(spoilerFileName);
@ -3096,6 +3110,16 @@ void GenerateRandomizerImgui(std::string seed = "") {
excludedLocations.insert((RandomizerCheck)std::stoi(excludedLocationString));
}
// todo: better way to sort out linking tricks rather than name
std::set<RandomizerTrick> enabledTricks;
std::stringstream enabledTrickStringStream(CVarGetString("gRandomizeEnabledTricks", ""));
std::string enabledTrickString;
while (getline(enabledTrickStringStream, enabledTrickString, ',')) {
enabledTricks.insert((RandomizerTrick)std::stoi(enabledTrickString));
}
// Update the visibilitiy before removing conflicting excludes (in case the locations tab wasn't viewed)
RandomizerCheckObjects::UpdateImGuiVisibility();
@ -3107,7 +3131,7 @@ void GenerateRandomizerImgui(std::string seed = "") {
}
}
RandoMain::GenerateRando(cvarSettings, excludedLocations, seed);
RandoMain::GenerateRando(cvarSettings, excludedLocations, enabledTricks, seed);
CVarSetInteger("gRandoGenerating", 0);
CVarSave();
@ -4701,7 +4725,26 @@ void DrawRandoEditor(bool& open) {
locationsTabOpen = false;
}
static bool tricksTabOpen = false;
if (ImGui::BeginTabItem("Tricks/Glitches")) {
if (!tricksTabOpen) {
tricksTabOpen = true;
//RandomizerTricks::UpdateImGuiVisibility();
// todo: this efficently when we build out cvar array support
std::stringstream enabledTrickStringStream(CVarGetString("gRandomizeEnabledTricks", ""));
std::string enabledTrickString;
enabledTricks.clear();
while (getline(enabledTrickStringStream, enabledTrickString, ',')) {
enabledTricks.insert((RandomizerTrick)std::stoi(enabledTrickString));
}
std::stringstream enabledGlitchStringStream(CVarGetString("gRandomizeEnabledGlitches", ""));
std::string enabledGlitchString;
enabledGlitches.clear();
while (getline(enabledGlitchStringStream, enabledGlitchString, ',')) {
enabledGlitches.insert((RandomizerTrick)std::stoi(enabledGlitchString));
}
}
ImGui::PushStyleVar(ImGuiStyleVar_CellPadding, cellPadding);
if (ImGui::BeginTable("tableRandoLogic", 1, ImGuiTableFlags_BordersH | ImGuiTableFlags_BordersV)) {
ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthStretch, 200.0f);
@ -4710,12 +4753,14 @@ void DrawRandoEditor(bool& open) {
ImGui::PushItemWidth(170.0);
ImGui::Text("Logic Rules");
UIWidgets::InsertHelpHoverText(
"Glitchless - No glitches are required, but may require some minor tricks.\n"
"Glitchless - No glitches are required, but may require some minor tricks. Additional tricks may be enabled and disabled below.\n"
"\n"
//"Glitched - Glitches may be required to beat the game. You can disable and enable glitches below.\n"
//"\n"
"No logic - Item placement is completely random. MAY BE IMPOSSIBLE TO BEAT."
);
UIWidgets::EnhancementCombobox("gRandomizeLogicRules", randoLogicRules, RO_LOGIC_GLITCHLESS);
if (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) == RO_LOGIC_GLITCHLESS) {
if (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) != RO_LOGIC_NO_LOGIC) {
ImGui::SameLine();
UIWidgets::EnhancementCheckbox(Settings::LocationsReachable.GetName().c_str(), "gRandomizeAllLocationsReachable", false, "", UIWidgets::CheckboxGraphics::Cross, RO_GENERIC_ON);
UIWidgets::InsertHelpHoverText(
@ -4739,35 +4784,383 @@ void DrawRandoEditor(bool& open) {
ImGui::PopItemWidth();
ImGui::EndTable();
}
if (ImGui::BeginTable("tableRandoTricksGlitches", 2, ImGuiTableFlags_BordersH | ImGuiTableFlags_BordersV)) {
ImGui::TableSetupColumn("Disabled", ImGuiTableColumnFlags_WidthStretch, 200.0f);
ImGui::TableSetupColumn("Enabled", ImGuiTableColumnFlags_WidthStretch, 200.0f);
// Tricks
static std::unordered_map<RandomizerTrickArea, bool> areaTreeDisabled {
{RTAREA_GENERAL, true},
{RTAREA_KOKIRI_FOREST, true},
{RTAREA_LOST_WOODS, true},
{RTAREA_SACRED_FOREST_MEADOW, true},
{RTAREA_HYRULE_FIELD, true},
{RTAREA_LAKE_HYLIA, true},
{RTAREA_GERUDO_VALLEY, true},
{RTAREA_GERUDO_FORTRESS, true},
{RTAREA_WASTELAND, true},
{RTAREA_DESERT_COLOSSUS, true},
{RTAREA_MARKET, true},
{RTAREA_HYRULE_CASTLE, true},
{RTAREA_KAKARIKO_VILLAGE, true},
{RTAREA_GRAVEYARD, true},
{RTAREA_DEATH_MOUNTAIN_TRAIL, true},
{RTAREA_GORON_CITY, true},
{RTAREA_DEATH_MOUNTAIN_CRATER, true},
{RTAREA_ZORAS_RIVER, true},
{RTAREA_ZORAS_DOMAIN, true},
{RTAREA_ZORAS_FOUNTAIN, true},
{RTAREA_LON_LON_RANCH, true},
{RTAREA_DEKU_TREE, true},
{RTAREA_DODONGOS_CAVERN, true},
{RTAREA_JABU_JABUS_BELLY, true},
{RTAREA_FOREST_TEMPLE, true},
{RTAREA_FIRE_TEMPLE, true},
{RTAREA_WATER_TEMPLE, true},
{RTAREA_SPIRIT_TEMPLE, true},
{RTAREA_SHADOW_TEMPLE, true},
{RTAREA_BOTTOM_OF_THE_WELL, true},
{RTAREA_ICE_CAVERN, true},
{RTAREA_GERUDO_TRAINING_GROUND, true},
{RTAREA_GANONS_CASTLE, true}
};
static std::unordered_map<RandomizerTrickArea, bool> areaTreeEnabled {
{RTAREA_GENERAL, true},
{RTAREA_KOKIRI_FOREST, true},
{RTAREA_LOST_WOODS, true},
{RTAREA_SACRED_FOREST_MEADOW, true},
{RTAREA_HYRULE_FIELD, true},
{RTAREA_LAKE_HYLIA, true},
{RTAREA_GERUDO_VALLEY, true},
{RTAREA_GERUDO_FORTRESS, true},
{RTAREA_WASTELAND, true},
{RTAREA_DESERT_COLOSSUS, true},
{RTAREA_MARKET, true},
{RTAREA_HYRULE_CASTLE, true},
{RTAREA_KAKARIKO_VILLAGE, true},
{RTAREA_GRAVEYARD, true},
{RTAREA_DEATH_MOUNTAIN_TRAIL, true},
{RTAREA_GORON_CITY, true},
{RTAREA_DEATH_MOUNTAIN_CRATER, true},
{RTAREA_ZORAS_RIVER, true},
{RTAREA_ZORAS_DOMAIN, true},
{RTAREA_ZORAS_FOUNTAIN, true},
{RTAREA_LON_LON_RANCH, true},
{RTAREA_DEKU_TREE, true},
{RTAREA_DODONGOS_CAVERN, true},
{RTAREA_JABU_JABUS_BELLY, true},
{RTAREA_FOREST_TEMPLE, true},
{RTAREA_FIRE_TEMPLE, true},
{RTAREA_WATER_TEMPLE, true},
{RTAREA_SPIRIT_TEMPLE, true},
{RTAREA_SHADOW_TEMPLE, true},
{RTAREA_BOTTOM_OF_THE_WELL, true},
{RTAREA_ICE_CAVERN, true},
{RTAREA_GERUDO_TRAINING_GROUND, true},
{RTAREA_GANONS_CASTLE, true}
};
static std::unordered_map<RandomizerTrickTag, bool> showTag {
{RTTAG_NOVICE,true},
{RTTAG_INTERMEDIATE,true},
{RTTAG_ADVANCED,true},
{RTTAG_EXPERT,true},
{RTTAG_EXTREME,true}
};
static ImGuiTextFilter trickSearch;
trickSearch.Draw("Filter (inc,-exc)", 490.0f);
if (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) != RO_LOGIC_NO_LOGIC) {
ImGui::SameLine();
if (ImGui::Button("Disable All")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
auto etfound = enabledTricks.find(randomizerTrick);
if (!rtObject.rtGlitch && etfound != enabledTricks.end()) {
enabledTricks.erase(etfound);
}
}
}
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
ImGui::SameLine();
if (ImGui::Button("Enable All")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (!rtObject.rtGlitch && !enabledTricks.count(rtObject.rt)) {
enabledTricks.insert(randomizerTrick);
}
}
}
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
}
if (ImGui::BeginTable("trickTags", showTag.size(), ImGuiTableFlags_Resizable | ImGuiTableFlags_NoSavedSettings | ImGuiTableFlags_Borders)) {
for (auto [rtTag, isShown] : showTag) {
ImGui::TableNextColumn();
ImGui::PushStyleColor(ImGuiCol_Header, RandomizerTricks::GetRTTagColor(rtTag));
ImGui::Selectable(RandomizerTricks::GetRTTagName(rtTag).c_str(), &showTag[rtTag]);
ImGui::PopStyleColor(1);
}
ImGui::EndTable();
}
if (ImGui::BeginTable("tableRandoTricks", 2, ImGuiTableFlags_BordersH | ImGuiTableFlags_BordersV)) {
ImGui::TableSetupColumn("Disabled Tricks", ImGuiTableColumnFlags_WidthStretch, 200.0f);
ImGui::TableSetupColumn("Enabled Tricks", ImGuiTableColumnFlags_WidthStretch, 200.0f);
ImGui::PushItemFlag(ImGuiItemFlags_Disabled, true);
ImGui::TableHeadersRow();
ImGui::PopItemFlag();
ImGui::TableNextRow();
if (CVarGetInteger("gRandomizeLogicRules", RO_LOGIC_GLITCHLESS) != RO_LOGIC_NO_LOGIC) {
// COLUMN 1 - DISABLED TRICKS AND GLITCHES
ImGui::TableNextColumn();
window->DC.CurrLineTextBaseOffset = 0.0f;
ImGui::BeginChild("ChildTricksGlitchesDisabled", ImVec2(0, -8));
// COLUMN 1 - DISABLED TRICKS
ImGui::TableNextColumn();
window->DC.CurrLineTextBaseOffset = 0.0f;
if (ImGui::Button("Collapse All##disabled")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
!enabledTricks.count(rtObject.rt) &&
!rtObject.rtGlitch) {
ImGui::Text("Coming soon");
hasTricks = true;
break;
}
}
if (hasTricks) {
areaTreeDisabled[rtArea] = false;
}
}
}
ImGui::SameLine();
if (ImGui::Button("Open All##disabled")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
!enabledTricks.count(rtObject.rt) &&
!rtObject.rtGlitch) {
ImGui::EndChild();
hasTricks = true;
break;
}
}
if (hasTricks) {
areaTreeDisabled[rtArea] = true;
}
}
}
ImGui::SameLine();
if (ImGui::Button("Enable Visible")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (!rtObject.rtGlitch && !enabledTricks.count(rtObject.rt) && trickSearch.PassFilter(rtObject.rtShortName.c_str()) && areaTreeDisabled[rtArea] && RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags)) {
enabledTricks.insert(randomizerTrick);
}
}
}
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
ImGui::BeginChild("ChildTricksDisabled", ImVec2(0, -8), false, ImGuiWindowFlags_HorizontalScrollbar);
// COLUMN 2 - ENABLED TRICKS AND GLITCHES
ImGui::TableNextColumn();
window->DC.CurrLineTextBaseOffset = 0.0f;
ImGui::BeginChild("ChildTricksGlitchesEnabled", ImVec2(0, -8));
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
trickSearch.PassFilter(rtObject.rtShortName.c_str()) &&
!enabledTricks.count(rtObject.rt) &&
RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags) &&
!rtObject.rtGlitch) {
ImGui::Text("Coming soon");
hasTricks = true;
break;
}
}
if (hasTricks) {
ImGui::TreeNodeSetOpen(ImGui::GetID(RandomizerTricks::GetRTAreaName(rtArea).c_str()), areaTreeDisabled[rtArea]);
ImGui::SetNextItemOpen(true, ImGuiCond_Once);
if (ImGui::TreeNode(RandomizerTricks::GetRTAreaName(rtArea).c_str())) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
trickSearch.PassFilter(rtObject.rtShortName.c_str()) &&
!enabledTricks.count(rtObject.rt) &&
RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags) &&
!rtObject.rtGlitch) {
if (ImGui::ArrowButton(std::to_string(rtObject.rt).c_str(), ImGuiDir_Right)) {
enabledTricks.insert(rtObject.rt);
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
DrawTagChips(*rtObject.rtTags);
ImGui::SameLine();
ImGui::Text(rtObject.rtShortName.c_str());
UIWidgets::InsertHelpHoverText(rtObject.rtDesc.c_str());
}
}
areaTreeDisabled[rtArea] = true;
ImGui::TreePop();
} else {
areaTreeDisabled[rtArea] = false;
}
}
}
ImGui::EndChild();
ImGui::EndChild();
// COLUMN 2 - ENABLED TRICKS
ImGui::TableNextColumn();
window->DC.CurrLineTextBaseOffset = 0.0f;
if (ImGui::Button("Collapse All##enabled")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
enabledTricks.count(rtObject.rt) &&
!rtObject.rtGlitch) {
hasTricks = true;
break;
}
}
if (hasTricks) {
areaTreeEnabled[rtArea] = false;
}
}
}
ImGui::SameLine();
if (ImGui::Button("Open All##enabled")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
enabledTricks.count(rtObject.rt) &&
!rtObject.rtGlitch) {
hasTricks = true;
break;
}
}
if (hasTricks) {
areaTreeEnabled[rtArea] = true;
}
}
}
ImGui::SameLine();
if (ImGui::Button("Disable Visible")) {
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
auto etfound = enabledTricks.find(randomizerTrick);
if (!rtObject.rtGlitch && etfound != enabledTricks.end() && trickSearch.PassFilter(rtObject.rtShortName.c_str()) && areaTreeEnabled[rtArea] && RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags)) {
enabledTricks.erase(etfound);
}
}
}
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
ImGui::BeginChild("ChildTricksEnabled", ImVec2(0, -8), false, ImGuiWindowFlags_HorizontalScrollbar);
for (auto [rtArea, rtObjects] : RandomizerTricks::GetAllRTObjectsByArea()) {
bool hasTricks = false;
for (auto [randomizerTrick, rtObject] : rtObjects) {
if (rtObject.visibleInImgui &&
trickSearch.PassFilter(rtObject.rtShortName.c_str()) &&
enabledTricks.count(rtObject.rt) &&
RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags) &&
!rtObject.rtGlitch) {
hasTricks = true;
break;
}
}
if (hasTricks) {
ImGui::TreeNodeSetOpen(ImGui::GetID(RandomizerTricks::GetRTAreaName(rtArea).c_str()), areaTreeEnabled[rtArea]);
ImGui::SetNextItemOpen(true, ImGuiCond_Once);
if (ImGui::TreeNode(RandomizerTricks::GetRTAreaName(rtArea).c_str())) {
for (auto [randomizerTrick, rtObject] : rtObjects) {
auto etfound = enabledTricks.find(rtObject.rt);
if (rtObject.visibleInImgui &&
trickSearch.PassFilter(rtObject.rtShortName.c_str()) &&
etfound != enabledTricks.end() &&
RandomizerTricks::CheckRTTags(showTag, *rtObject.rtTags) &&
!rtObject.rtGlitch) {
if (ImGui::ArrowButton(std::to_string(rtObject.rt).c_str(), ImGuiDir_Left)) {
enabledTricks.erase(etfound);
std::string enabledTrickString = "";
for (auto enabledTrickIt : enabledTricks) {
enabledTrickString += std::to_string(enabledTrickIt);
enabledTrickString += ",";
}
CVarSetString("gRandomizeEnabledTricks", enabledTrickString.c_str());
LUS::RequestCvarSaveOnNextTick();
}
DrawTagChips(*rtObject.rtTags);
ImGui::SameLine();
ImGui::Text(rtObject.rtShortName.c_str());
UIWidgets::InsertHelpHoverText(rtObject.rtDesc.c_str());
}
}
areaTreeEnabled[rtArea] = true;
ImGui::TreePop();
} else {
areaTreeEnabled[rtArea] = false;
}
}
}
ImGui::EndChild();
} else {
ImGui::TableNextColumn();
ImGui::BeginChild("ChildTrickAreas", ImVec2(0, -8));
ImGui::Text("Requires Logic Turned On.");
ImGui::EndChild();
ImGui::TableNextColumn();
ImGui::BeginChild("ChildTricksDisabled", ImVec2(0, -8));
ImGui::Text("Requires Logic Turned On.");
ImGui::EndChild();
ImGui::TableNextColumn();
ImGui::BeginChild("ChildTricksEnabled", ImVec2(0, -8));
ImGui::Text("Requires Logic Turned On.");
ImGui::EndChild();
}
ImGui::EndTable();
}
ImGui::PopStyleVar(1);
ImGui::EndTabItem();
} else {
tricksTabOpen = false;
}
if (ImGui::BeginTabItem("Starting Inventory")) {

1
soh/soh/Enhancements/randomizer/randomizer.h
View File

@ -9,6 +9,7 @@
#include <memory>
#include <soh/Enhancements/randomizer/randomizerTypes.h>
#include "soh/Enhancements/randomizer/randomizer_check_objects.h"
#include "soh/Enhancements/randomizer/randomizer_tricks.h"
#include <soh/Enhancements/custom-message/CustomMessageManager.h>
#include "soh/Enhancements/item-tables/ItemTableTypes.h"

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

@ -850,6 +850,264 @@ typedef enum {
RC_MAX
} RandomizerCheck;
// Randomizer tricks and glitches (beta) based on knowledge of what is achievable in Ship of Harkinian randomizer, excludes Item manipulation (e.g. RBA/GIM/SRM) and Wrong Warping and Ganon BK Skip
// TODO Fill and alphabetize (area based tricks must have area in name and come alphetized after general tricks)
// TODO test commented out tricks to see if consistent with console on SoH
// TODO add area specific tricks
typedef enum {
RT_VISIBLE_COLLISION, // -- general tricks
RT_GROTTOS_WITHOUT_AGONY,
RT_FEWER_TUNIC_REQUIREMENTS,
RT_RUSTED_SWITCHES,
RT_FLAMING_CHESTS,
RT_BUNNY_HOOD_JUMPS,
RT_DAMAGE_BOOST_SIMPLE,
RT_HOVER_BOOST_SIMPLE,
RT_KF_ADULT_GS, // -- location tricks
RT_LW_BRIDGE,
RT_LW_MIDO_BACKFLIP,
RT_LW_GS_BEAN,
RT_HC_STORMS_GS,
RT_KAK_MAN_ON_ROOF,
RT_KAK_TOWER_GS,
RT_KAK_ADULT_WINDMILL_POH,
RT_KAK_CHILD_WINDMILL_POH,
RT_KAK_ROOFTOP_GS,
RT_GY_POH,
RT_GY_CHILD_DAMPE_RACE_POH,
RT_GY_SHADOW_FIRE_ARROWS,
RT_DMT_SOIL_GS,
RT_DMT_BOMBABLE,
RT_DMT_HOOKSHOT_LOWER_GS,
RT_DMT_HOVERS_LOWER_GS,
RT_DMT_BEAN_LOWER_GS,
RT_DMT_JS_LOWER_GS,
RT_DMT_CLIMB_HOVERS,
RT_DMT_UPPER_GS,
RT_DMT_BOLERO_BIGGORON,
RT_GC_POT,
RT_GC_POT_STRENGTH,
RT_GC_ROLLING_STRENGTH,
RT_GC_LEFTMOST,
RT_GC_GROTTO,
RT_GC_LINK_GORON_DINS,
RT_DMC_HOVER_BEAN_POH,
RT_DMC_BOLERO_JUMP,
RT_DMC_BOULDER_JS,
RT_DMC_BOULDER_SKIP,
RT_ZR_LOWER,
RT_ZR_UPPER,
RT_ZR_HOVERS,
RT_ZR_CUCCO,
RT_ZD_KING_ZORA_SKIP,
RT_ZD_GS,
RT_LH_LAB_WALL_GS,
RT_LH_LAB_DIVING,
RT_LH_WATER_HOOKSHOT,
RT_GV_CRATE_HOVERS,
RT_GF_KITCHEN,
RT_GF_JUMP,
RT_HW_BUNNY_CROSSING,
RT_HW_CROSSING,
RT_LENS_HW,
RT_HW_REVERSE,
RT_COLOSSUS_GS,
RT_DEKU_BASEMENT_GS,
RT_DEKU_B1_SKIP,
RT_DEKU_B1_BOW_WEBS,
RT_DEKU_MQ_COMPASS_GS,
RT_DEKU_MQ_LOG,
RT_DC_SCARECROW_GS,
RT_DC_VINES_GS,
RT_DC_STAIRCASE,
RT_DC_SLINGSHOT_SKIP,
RT_DC_SCRUB_ROOM,
RT_DC_JUMP,
RT_DC_HAMMER_FLOOR,
RT_DC_MQ_CHILD_BOMBS,
RT_DC_MQ_CHILD_EYES,
RT_DC_MQ_ADULT_EYES,
RT_JABU_ALCOVE_JUMP_DIVE,
RT_JABU_BOSS_HOVER,
RT_JABU_NEAR_BOSS_RANGED,
RT_JABU_NEAR_BOSS_EXPLOSIVES,
RT_LENS_JABU_MQ,
RT_JABU_MQ_RANG_JUMP,
RT_JABU_MQ_SOT_GS,
RT_LENS_BOTW,
RT_BOTW_CHILD_DEADHAND,
RT_BOTW_BASEMENT,
RT_BOTW_MQ_PITS,
RT_BOTW_MQ_DEADHAND_KEY,
RT_FOREST_FIRST_GS,
RT_FOREST_OUTDOORS_EAST_GS,
RT_FOREST_VINES,
RT_FOREST_OUTDOORS_LEDGE,
RT_FOREST_DOORFRAME,
RT_FOREST_OUTSIDE_BACKDOOR,
RT_FOREST_MQ_WELL_SWIM,
RT_FOREST_MQ_BLOCK_PUZZLE,
RT_FOREST_MQ_JS_HALLWAY_SWITCH,
RT_FOREST_MQ_HOOKSHOT_HALLWAY_SWITCH,
RT_FOREST_MQ_RANG_HALLWAY_SWITCH,
RT_FIRE_BOSS_DOOR_JUMP,
RT_FIRE_SOT,
RT_FIRE_STRENGTH,
RT_FIRE_SCARECROW,
RT_FIRE_FLAME_MAZE,
RT_FIRE_MQ_NEAR_BOSS,
RT_FIRE_MQ_BLOCKED_CHEST,
RT_FIRE_MQ_BK_CHEST,
RT_FIRE_MQ_CLIMB,
RT_FIRE_MQ_MAZE_SIDE_ROOM,
RT_FIRE_MQ_MAZE_HOVERS,
RT_FIRE_MQ_MAZE_JUMP,
RT_FIRE_MQ_ABOVE_MAZE_GS,
RT_FIRE_MQ_FLAME_MAZE,
RT_WATER_LONGSHOT_TORCH,
RT_WATER_CRACKED_WALL_HOVERS,
RT_WATER_CRACKED_WALL,
RT_WATER_BK_REGION,
RT_WATER_NORTH_BASEMENT_LEDGE_JUMP,
RT_WATER_BK_JUMP_DIVE,
RT_WATER_FW_CENTRAL_GS,
RT_WATER_IRONS_CENTRAL_GS,
RT_WATER_CENTRAL_BOW,
RT_WATER_HOOKSHOT_FALLING_PLATFORM_GS,
RT_WATER_RANG_FALLING_PLATFORM_GS,
RT_WATER_RIVER_GS,
RT_WATER_DRAGON_JUMP_DIVE,
RT_WATER_ADULT_DRAGON,
RT_WATER_CHILD_DRAGON,
RT_WATER_MQ_CENTRAL_PILLAR,
RT_WATER_MQ_LOCKED_GS,
RT_LENS_SHADOW,
RT_LENS_SHADOW_PLATFORM,
RT_LENS_BONGO,
RT_SHADOW_UMBRELLA,
RT_SHADOW_UMBRELLA_GS,
RT_SHADOW_FREESTANDING_KEY,
RT_SHADOW_STATUE,
RT_SHADOW_BONGO,
RT_LENS_SHADOW_MQ,
RT_LENS_SHADOW_MQ_INVISIBLE_BLADES,
RT_LENS_SHADOW_MQ_PLATFORM,
RT_LENS_SHADOW_MQ_DEADHAND,
RT_SHADOW_MQ_GAP,
RT_SHADOW_MQ_INVISIBLE_BLADES,
RT_SHADOW_MQ_HUGE_PIT,
RT_SHADOW_MQ_WINDY_WALKWAY,
RT_LENS_SPIRIT,
RT_SPIRIT_CHILD_CHU,
RT_SPIRIT_LOBBY_GS,
RT_SPIRIT_LOWER_ADULT_SWITCH,
RT_SPIRIT_LOBBY_JUMP,
RT_SPIRIT_PLATFORM_HOOKSHOT,
RT_SPIRIT_MAP_CHEST,
RT_SPIRIT_SUN_CHEST,
RT_SPIRIT_WALL,
RT_LENS_SPIRIT_MQ,
RT_SPIRIT_MQ_SUN_BLOCK_SOT,
RT_SPIRIT_MQ_SUN_BLOCK_GS,
RT_SPIRIT_MQ_LOWER_ADULT,
RT_SPIRIT_MQ_FROZEN_EYE,
RT_ICE_BLOCK_GS,
RT_ICE_MQ_RED_ICE_GS,
RT_ICE_MQ_SCARECROW,
RT_LENS_GTG,
RT_GTG_WITHOUT_HOOKSHOT,
RT_GTG_FAKE_WALL,
RT_LENS_GTG_MQ,
RT_GTG_MQ_WITH_HOOKSHOT,
RT_GTG_MQ_WIHTOUT_HOOKSHOT,
RT_LENS_GANON,
RT_GANON_SPIRIT_TRIAL_HOOKSHOT,
RT_LENS_GANON_MQ,
RT_GANON_MQ_FIRE_TRIAL,
RT_GANON_MQ_SHADOW_TRIAL,
RT_GANON_MQ_LIGHT_TRIAL,
//RT_ROCS_FEATHER --if implemented with main branch
RT_FOREST_TEMPLE_BK_SKIP,
RT_FIRE_TEMPLE_BK_SKIP,
RT_WATER_TEMPLE_BK_SKIP,
RT_SHADOW_TEMPLE_BK_SKIP,
RT_SPIRIT_BK_SKIP,
RT_ACUTE_ANGLE_CLIP,
RT_ADVANCED_CLIPS,
RT_BLANK_A,
RT_CUTSCENE_DIVE,
RT_DAMAGE_BOOST,
RT_DOOM_JUMP,
RT_EPG,
RT_EQUIP_SWAP,
RT_EQUIP_SWAP_EXPECTS_DINS,
RT_FLAME_STORAGE,
RT_FW_VOID_WARP,
RT_GROUND_CLIP,
RT_GROUND_JUMP,
RT_HESS,
RT_HOOKSHOT_CLIP,
RT_HOOKSHOT_JUMP,
RT_HOVERING,
RT_HOVERING_BOW_SLINGSHOT,
RT_HOVERING_CONTORTION,
RT_HOVERING_ENEMY,
RT_HOVERING_HOVERBOOTS,
RT_HOVERING_WALL,
RT_ISG,
RT_LADDER_CLIP,
RT_LADDER_CLIP_HOOKSHOT,
RT_LEDGE_CANCEL,
RT_LEDGE_CLIP,
RT_LUNGE_STORAGE,
RT_MEGAFLIP_BOMB,
RT_MEGAFLIP_BOMBCHU,
RT_MEGASIDEHOP_BOMB,
RT_MEGASIDEHOP_BOMBCHU,
RT_NAVI_DIVE,
RT_OCARINA_ITEMS,
RT_OCARINA_ITEMS_BOMB,
RT_OCARINA_ITEMS_ESS,
RT_OCARINA_ITEMS_PUTAWAY,
RT_ONE_WAY_CLIPS,
RT_QUICKDRAW,
RT_QUICK_PUTAWAY,
RT_SEEMWALK,
RT_SUPERSLIDE,
RT_SUPERSLIDE_TELEPORT,
RT_TIME_STOP,
RT_TRIPLE_SLASH_CLIP,
RT_VINE_CLIP,
RT_WEIRDSHOT,
RT_WEIRDSHOT_CHU,
RT_WEIRDSHOT_ENEMY,
//RT_FW_VOID_WARP_FAST_TEXT, --untested tricks:
//RT_ACTION_SWAP,
//RT_ACTOR_GLITCH,
//RT_ADULT_TRADE_TTG,
RT_TOT_DOT_SKIP_SWORDLESS, //AREA SPECIFIC GLITCHES
RT_TOT_DOT_SKIP_SWORD,
RT_LLR_STEAL_EPONA,
RT_KF_POKEY_SKIP,
RT_KF_MIDO_SKIP,
RT_KF_CLIMB_TWINS_HOUSE,
RT_KF_DEKU_TREE_ADULT,
RT_KF_WWT_ESCAPE,
RT_LW_AQUAESCAPE,
RT_LW_MIDO_SKIP_ADULT,
RT_OGC_GOLD_GAUNTLET_SKIP,
RT_GY_ROYAL_TOMB,
RT_ZF_JABU_ADULT_BOMBCHU,
RT_ZF_JABU_ADULT_HOVERBOOT_BOMB,
RT_FOREST_TEMPLE_FOUR_POE_SKIP,
RT_FOREST_TEMPLE_JUNGLE_JUMP,
//RT_DARUNIA_CUTSCENE,
RT_BOTTOM_OF_THE_WELL_SKULL_PUSH,
RT_GANONS_CASTLE_BARRIER_SKIP_HOVER,
RT_GANONS_CASTLE_GOLD_GAUNTLET_SKIP,
RT_MAX
} RandomizerTrick;
// based on https://github.com/TestRunnerSRL/OoT-Randomizer/blob/e337d7f603b91a6bacb618fb32cc7fd70ed9ffca/ItemList.py
typedef enum {
RG_NONE,
@ -1467,6 +1725,7 @@ typedef enum {
// Logic (glitchless/no logic)
typedef enum {
RO_LOGIC_GLITCHLESS,
//RO_LOGIC_GLITCHED,
RO_LOGIC_NO_LOGIC,
} RandoOptionLogic;

393
soh/soh/Enhancements/randomizer/randomizer_tricks.cpp Normal file
View File

@ -0,0 +1,393 @@
#include "randomizer_tricks.h"
#include <map>
#include <string>
#include <libultraship/bridge.h>
#include <ImGuiImpl.h>
#include "z64.h"
//Difficulty base tag vectors:
std::vector<RandomizerTrickTag> noviceBase{RTTAG_NOVICE};
std::vector<RandomizerTrickTag> intermediateBase{RTTAG_INTERMEDIATE};
std::vector<RandomizerTrickTag> advancedBase{RTTAG_ADVANCED};
std::vector<RandomizerTrickTag> expertBase{RTTAG_EXPERT};
std::vector<RandomizerTrickTag> extremeBase{RTTAG_EXTREME};
// Trick names and descriptions obtained from https://github.com/OoTRandomizer/OoT-Randomizer/blob/Dev/SettingsList.py with additions and edits
// Difficulties initially decided on personal opinions, will be updated based on community feedback. todo: update glitch difficulties
// Novice - if you were told X is possible, then you would be likely be able to do it either first time or it is something easily repeatable without any setup
// Intermediate - may take a few attempts or a small setup to achieve, or is an easily repeatable trick with a small frame window
// Advanced - may have a tight time window to achieve, have a long setup, or small frame window to perform
// Expert - typically a series of small frame windows or longer setups, likely to require buffering
// Extreme - this may require several frame perfect tricks, long setups or heavy reliance on environment to perform
// Experimental - not implemented; these tricks may let you put the game into a softlockable state
// Please see https://www.youtube.com/playlist?list=PLqsXSioZwQyoa23_27l5NZq5IZdKRi5Sm for reference on performing several of these tricks
// RandomizerTrick, RTVORMQ, RTAREA, rt_tags rt_glitch (is it a glitch) "Short name", "Description"
std::unordered_map<RandomizerTrick, RandomizerTrickObject> rtObjects = {
RT_OBJECT(RT_ACUTE_ANGLE_CLIP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Acute angle clip", "Enables locations requiring jumpslash clips through walls which meet at an acute angle."),
RT_OBJECT(RT_ADVANCED_CLIPS, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Advanced clips", "Enables locations requiring clips through walls and objects requiring precise jumps or other tricks."),
RT_OBJECT(RT_BLANK_A, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Blank A", "Enables locations requiring blank A button; NOTE: this requires the 'Quick Putaway' restoration."),
RT_OBJECT(RT_DOOM_JUMP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Doom Jump", "Enables locations requiring doom jumps."),
RT_OBJECT(RT_EPG, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "EPG", "Enables locations requiring use of the Entrance Point Glitch."),
RT_OBJECT(RT_EQUIP_SWAP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Equip Swap", "Enables locations requiring use of equip swap; NOTE: this may expect the 'Allow cursor to be over any slot' enhancement to be turned off."),
RT_OBJECT(RT_EQUIP_SWAP_EXPECTS_DINS, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Equip Swap Require's Din's Fire", "Enables locations requiring use of equip swap once din's fire is found."),
RT_OBJECT(RT_FLAME_STORAGE, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Flame Storage", "Enables locations requiring flame storage."),
RT_OBJECT(RT_GROUND_CLIP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Ground Clip", "Enables locations requiring ground clips."),
RT_OBJECT(RT_GROUND_JUMP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Ground Jump", "Enables locations requiring ground jumps."),
RT_OBJECT(RT_HESS, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "HESS", "Enables locations requiring a Hyper Extended Super Slide."),
RT_OBJECT(RT_HOOKSHOT_CLIP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Hookshot Clip", "Enables locations requiring hookshot clips."),
RT_OBJECT(RT_HOOKSHOT_JUMP, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "Hookshot Jump", "Enables locations requiring hookshot jumps."),
RT_OBJECT(RT_ISG, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, true, "ISG", "Enables locations requiring use of the infinite sword glitch."),
RT_OBJECT(RT_VISIBLE_COLLISION, RTVORMQ_BOTH, RTAREA_GENERAL, &noviceBase, false, "Pass Through Visible One-Way Collision", "Allows climbing through the platform to reach Impa's House Back as adult with no items and going through the Kakariko Village Gate as child when coming from the Mountain Trail side."),
RT_OBJECT(RT_GROTTOS_WITHOUT_AGONY, RTVORMQ_BOTH, RTAREA_GENERAL, &noviceBase, false, "Hidden Grottos without Stone of Agony", "Allows entering hidden grottos without the Stone of Agony."),
RT_OBJECT(RT_FEWER_TUNIC_REQUIREMENTS, RTVORMQ_BOTH, RTAREA_GENERAL, &intermediateBase, false, "Fewer Tunic Requirements", "Allows the following possible without Tunics: - Enter Water Temple. The area below the center pillar still requires Zora Tunic. Applies to MQ also. - Enter Fire Temple. Only the first floor is accessible, and not Volvagia. Only Applies to MQ."),
RT_OBJECT(RT_RUSTED_SWITCHES, RTVORMQ_BOTH, RTAREA_GENERAL, &noviceBase, false, "Hammer Rusted Switches Through Walls", "Applies to: - Fire Temple Highest Goron Chest. - MQ Fire Temple Lizalfos Maze. - MQ Spirit Trial."),
RT_OBJECT(RT_FLAMING_CHESTS, RTVORMQ_BOTH, RTAREA_GENERAL, &intermediateBase, false, "Flaming Chests", "The chests encircled in flames in Gerudo Training Grounds and in Spirit Temple can be opened by running into the flames while Link is invincible after taking damage."),
//RT_OBJECT(RT_BUNNY_HOOD_JUMPS, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, false, "Bunny Hood Jumps", "Allows reaching locations using Bunny Hood's extended jumps."),
//RT_OBJECT(RT_DAMAGE_BOOST_SIMPLE, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, false, "Simple damage boosts", "Allows damage boosts to reach Hyrule Castle guards, the bomb bag area in DC and the Gerudo Valley crate Piece of Heart. Can be combined with \"Simple hover boosts\" for reaching far distances."),
//RT_OBJECT(RT_HOVER_BOOST_SIMPLE, RTVORMQ_BOTH, RTAREA_GENERAL, &advancedBase, false, "Simple hover boosts", "Allows equipping of hover boots when link is moving at high speeds to extend distance covered. Can be combined with \"Simple damage boosts\" for greater uses."),
RT_OBJECT(RT_KF_ADULT_GS, RTVORMQ_BOTH, RTAREA_KOKIRI_FOREST, &noviceBase, false, "Adult Kokiri Forest GS with Hover Boots", "Can be obtained without Hookshot by using the Hover Boots off of one of the roots."),
RT_OBJECT(RT_LW_BRIDGE, RTVORMQ_BOTH, RTAREA_LOST_WOODS, &expertBase, false, "Jump onto the Lost Woods Bridge as Adult with Nothing", "With very precise movement it's possible for adult to jump onto the bridge without needing Longshot, Hover Boots, or Bean."),
RT_OBJECT(RT_LW_MIDO_BACKFLIP, RTVORMQ_BOTH, RTAREA_LOST_WOODS, &noviceBase, false, "Backflip over Mido as Adult", "With a specific position and angle, you can backflip over Mido."),
RT_OBJECT(RT_LW_GS_BEAN, RTVORMQ_BOTH, RTAREA_LOST_WOODS, &intermediateBase, false, "Lost Woods Adult GS without Bean", "You can collect the token with a precise Hookshot use, as long as you can kill the Skulltula somehow first. It can be killed using Longshot, Bow, Bombchus or Din's Fire."),
RT_OBJECT(RT_HC_STORMS_GS, RTVORMQ_BOTH, RTAREA_HYRULE_CASTLE, &intermediateBase, false, "Hyrule Castle Storms Grotto GS with Just Boomerang", "With precise throws, the Boomerang alone can kill the Skulltula and collect the token, without first needing to blow up the wall."),
RT_OBJECT(RT_KAK_MAN_ON_ROOF, RTVORMQ_BOTH, RTAREA_KAKARIKO_VILLAGE, &noviceBase, false, "Man on Roof without Hookshot", "Can be reached by side-hopping off the watchtower as either age, or by jumping onto the potion shop's roof from the ledge as adult."),
RT_OBJECT(RT_KAK_TOWER_GS, RTVORMQ_BOTH, RTAREA_KAKARIKO_VILLAGE, &intermediateBase, false, "Kakariko Tower GS with Jump Slash", "Climb the tower as high as you can without touching the Gold Skulltula, then let go and jump slash immediately. By jump-slashing from as low on the ladder as possible to still hit the Skulltula, this trick can be done without taking fall damage."),
RT_OBJECT(RT_KAK_ADULT_WINDMILL_POH, RTVORMQ_BOTH, RTAREA_KAKARIKO_VILLAGE, &noviceBase, false, "Windmill PoH as Adult with Nothing", "Can jump up to the spinning platform from below as adult."),
//RT_OBJECT(RT_KAK_CHILD_WINDMILL_POH, RTVORMQ_BOTH, RTAREA_KAKARIKO_VILLAGE, &extremeBase, false, "Windmill PoH as Child with Precise Jump Slash", "Can jump up to the spinning platform from below as child with a precise jumpslash timed with the platforms rotation."),
RT_OBJECT(RT_KAK_ROOFTOP_GS, RTVORMQ_BOTH, RTAREA_KAKARIKO_VILLAGE, &advancedBase, false, "Kakariko Rooftop GS with Hover Boots", "Take the Hover Boots from the entrance to Impa's House over to the rooftop of Skulltula House. From there, a precise Hover Boots backwalk with backflip can be used to get onto a hill above the side of the village. And then from there you can Hover onto Impa's rooftop to kill the Skulltula and backflip into the token."),
RT_OBJECT(RT_GY_POH, RTVORMQ_BOTH, RTAREA_GRAVEYARD, &intermediateBase, false, "Graveyard Freestanding PoH with Boomerang", "Using a precise moving setup you can obtain the Piece of Heart by having the Boomerang interact with it along the return path."),
RT_OBJECT(RT_GY_CHILD_DAMPE_RACE_POH, RTVORMQ_BOTH, RTAREA_GRAVEYARD, &noviceBase, false, "Second Dampe Race as Child", "It is possible to complete the second dampe race as child in under a minute, but it is a strict time limit."),
RT_OBJECT(RT_GY_SHADOW_FIRE_ARROWS, RTVORMQ_BOTH, RTAREA_GRAVEYARD, &expertBase, false, "Shadow Temple Entry with Fire Arrows", "It is possible to light all of the torches to open the Shadow Temple entrance with just Fire Arrows, but you must be very quick, precise, and strategic with how you take your shots."),
RT_OBJECT(RT_DMT_SOIL_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &intermediateBase, false, "Death Mountain Trail Soil GS without Destroying Boulder", "Bugs will go into the soft soil even while the boulder is still blocking the entrance. Then, using a precise moving setup you can kill the Gold Skulltula and obtain the token by having the Boomerang interact with it along the return path."),
RT_OBJECT(RT_DMT_BOMBABLE, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &intermediateBase, false, "Death Mountain Trail Chest with Strength", "Child Link can blow up the wall using a nearby bomb flower. You must backwalk with the flower and then quickly throw it toward the wall."),
RT_OBJECT(RT_DMT_HOOKSHOT_LOWER_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &intermediateBase, false, "Death Mountain Trail Lower Red Rock GS with Hookshot", "After killing the Skulltula, the token can be fished out of the rock without needing to destroy it, by using the Hookshot in the correct way."),
RT_OBJECT(RT_DMT_HOVERS_LOWER_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &advancedBase, false, "Death Mountain Trail Lower Red Rock GS with Hover Boots", "After killing the Skulltula, the token can be collected without needing to destroy the rock by backflipping down onto it with the Hover Boots. First use the Hover Boots to stand on a nearby fence, and go for the Skulltula Token from there."),
RT_OBJECT(RT_DMT_BEAN_LOWER_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &expertBase, false, "Death Mountain Trail Lower Red Rock GS with Magic Bean", "After killing the Skulltula, the token can be collected without needing to destroy the rock by jumping down onto it from the bean plant, midflight, with precise timing and positioning."),
RT_OBJECT(RT_DMT_JS_LOWER_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &intermediateBase, false, "Death Mountain Trail Lower Red Rock GS with Jump Slash", "After killing the Skulltula, the token can be collected without needing to destroy the rock by jump slashing from a precise angle."),
RT_OBJECT(RT_DMT_CLIMB_HOVERS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &advancedBase, false, "Death Mountain Trail Climb with Hover Boots", "It is possible to use the Hover Boots to bypass needing to destroy the boulders blocking the path to the top of Death Mountain."),
RT_OBJECT(RT_DMT_UPPER_GS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &noviceBase, false, "Death Mountain Trail Upper Red Rock GS without Hammer", "After killing the Skulltula, the token can be collected by backflipping into the rock at the correct angle."),
//RT_OBJECT(RT_DMT_BOLERO_BIGGORON, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_TRAIL, &intermediateBase, false, "Deliver Eye Drops with Bolero of Fire", "Playing a warp song normally causes a trade item to spoil immediately, however, it is possible use Bolero to reach Biggoron and still deliver the Eye Drops before they spoil. If you do not wear the Goron Tunic, the heat timer inside the crater will override the trade item\'s timer. When you exit to Death Mountain Trail you will have one second to show the Eye Drops before they expire. You can get extra time to show the Eye Drops if you warp immediately upon receiving them. If you don't have many hearts, you may have to reset the heat timer by quickly dipping in and out of Darunia\'s chamber or quickly equipping and unequipping the Goron Tunic. This trick does not apply if \"Randomize Warp Song Destinations\" is enabled, or if the settings are such that trade items do not need to be delivered within a time limit."),
RT_OBJECT(RT_GC_POT, RTVORMQ_BOTH, RTAREA_GORON_CITY, &advancedBase, false, "Goron City Spinning Pot PoH with Bombchu", "A Bombchu can be used to stop the spinning pot, but it can be quite finicky to get it to work."),
RT_OBJECT(RT_GC_POT_STRENGTH, RTVORMQ_BOTH, RTAREA_GORON_CITY, &intermediateBase, false, "Goron City Spinning Pot PoH with Strength", "Allows for stopping the Goron City Spinning Pot using a bomb flower alone, requiring strength in lieu of inventory explosives."),
RT_OBJECT(RT_GC_ROLLING_STRENGTH, RTVORMQ_BOTH, RTAREA_GORON_CITY, &intermediateBase, false, "Rolling Goron (Hot Rodder Goron) as Child with Strength", "Use the bombflower on the stairs or near Medigoron. Timing is tight, especially without backwalking."),
RT_OBJECT(RT_GC_LINK_GORON_DINS, RTVORMQ_BOTH, RTAREA_GORON_CITY, &noviceBase, false, "Stop Link the Goron with Din\'s Fire","The timing is quite awkward."),
RT_OBJECT(RT_GC_LEFTMOST, RTVORMQ_BOTH, RTAREA_GORON_CITY, &advancedBase, false, "Goron City Maze Left Chest with Hover Boots", "A precise backwalk starting from on top of the crate and ending with a precisely-timed backflip can reach this chest without needing either the Hammer or Silver Gauntlets."),
RT_OBJECT(RT_GC_GROTTO, RTVORMQ_BOTH, RTAREA_GORON_CITY, &advancedBase, false, "Goron City Grotto with Hookshot While Taking Damage", "It is possible to reach the Goron City Grotto by quickly using the Hookshot while in the midst of taking damage from the lava floor."),
RT_OBJECT(RT_DMC_HOVER_BEAN_POH, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_CRATER, &noviceBase, false, "Crater\'s Bean PoH with Hover Boots", "Hover from the base of the bridge near Goron City and walk up the very steep slope."),
RT_OBJECT(RT_DMC_BOLERO_JUMP, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_CRATER, &extremeBase, false, "Death Mountain Crater Jump to Bolero", "As Adult , using a shield to drop a pot while you have the perfect speed and position, the pot can push you that little extra distance you need to jump across the gap in the bridge."),
RT_OBJECT(RT_DMC_BOULDER_JS, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_CRATER, &noviceBase, false, "Death Mountain Crater Upper to Lower with Hammer", "With the Hammer, you can jump slash the rock twice in the same jump in order to destroy it before you fall into the lava."),
RT_OBJECT(RT_DMC_BOULDER_SKIP, RTVORMQ_BOTH, RTAREA_DEATH_MOUNTAIN_CRATER, &intermediateBase, false, "Death Mountain Crater Upper to Lower Boulder Skip", "As adult, With careful positioning, you can jump to the ledge where the boulder is, then use repeated ledge grabs to shimmy to a climbable ledge. This trick supersedes \"Death Mountain Crater Upper to Lower with Hammer\"."),
RT_OBJECT(RT_ZR_LOWER, RTVORMQ_BOTH, RTAREA_ZORAS_RIVER, &intermediateBase, false, "Zora\'s River Lower Freestanding PoH as Adult with Nothing", "Adult can reach this PoH with a precise jump, no Hover Boots required."),
RT_OBJECT(RT_ZR_UPPER, RTVORMQ_BOTH, RTAREA_ZORAS_RIVER, &intermediateBase, false, "Zora\'s River Upper Freestanding PoH as Adult with Nothing", "Adult can reach this PoH with a precise jump, no Hover Boots required."),
RT_OBJECT(RT_ZR_HOVERS, RTVORMQ_BOTH, RTAREA_ZORAS_RIVER, &noviceBase, false, "Zora\'s Domain Entry with Cucco", "You can fly behind the waterfall with a Cucco as child."),
RT_OBJECT(RT_ZR_CUCCO, RTVORMQ_BOTH, RTAREA_ZORAS_RIVER, &noviceBase, false, "Zora\'s Domain Entry with Hover Boots", "Can hover behind the waterfall as adult."),
RT_OBJECT(RT_ZD_KING_ZORA_SKIP, RTVORMQ_BOTH, RTAREA_ZORAS_DOMAIN, &intermediateBase, false, "Skip King Zora as Adult with Nothing", "With a precise jump as adult, it is possible to get on the fence next to King Zora from the front to access Zora's Fountain."),
RT_OBJECT(RT_ZD_GS, RTVORMQ_BOTH, RTAREA_ZORAS_DOMAIN, &intermediateBase, false, "Zora\'s Domain GS with No Additional Items", "A precise jump slash can kill the Skulltula and recoil back onto the top of the frozen waterfall. To kill it, the logic normally guarantees one of Hookshot, Bow, or Magic."),
RT_OBJECT(RT_LH_LAB_WALL_GS, RTVORMQ_BOTH, RTAREA_LAKE_HYLIA, &noviceBase, false, "Lake Hylia Lab Wall GS with Jump Slash", "The jump slash to actually collect the token is somewhat precise."),
RT_OBJECT(RT_LH_LAB_DIVING, RTVORMQ_BOTH, RTAREA_LAKE_HYLIA, &noviceBase, false, "Lake Hylia Lab Dive without Gold Scale", "Remove the Iron Boots in the midst of Hookshotting the underwater crate."),
RT_OBJECT(RT_LH_WATER_HOOKSHOT, RTVORMQ_BOTH, RTAREA_LAKE_HYLIA, &intermediateBase, false, "Water Temple Entry without Iron Boots using Hookshot", "When entering Water Temple using Gold Scale instead of Iron Boots, the Longshot is usually used to be able to hit the switch and open the gate. But, by standing in a particular spot, the switch can be hit with only the reach of the Hookshot."),
RT_OBJECT(RT_GV_CRATE_HOVERS, RTVORMQ_BOTH, RTAREA_GERUDO_VALLEY, &intermediateBase, false, "Gerudo Valley Crate PoH as Adult with Hover Boots", "From the far side of Gerudo Valley, a precise Hover Boots movement and jump-slash recoil can allow adult to reach the ledge with the crate PoH without needing Longshot. You will take fall damage."),
RT_OBJECT(RT_GF_KITCHEN, RTVORMQ_BOTH, RTAREA_GERUDO_FORTRESS, &noviceBase, false, "Thieves\' Hideout \"Kitchen\" with No Additional Items", "Allows passing through the kitchen by avoiding being seen by the guards. The logic normally guarantees Bow or Hookshot to stun them from a distance, or Hover Boots to cross the room without needing to deal with the guards."),
RT_OBJECT(RT_GF_JUMP, RTVORMQ_BOTH, RTAREA_GERUDO_FORTRESS, &noviceBase, false, "Gerudo\'s Fortress Ledge Jumps", "Adult can jump onto the top roof of the fortress without going through the interior of the hideout."),
//RT_OBJECT(RT_HW_BUNNY_CROSSING, RTVORMQ_BOTH, RTAREA_WASTELAND, &noviceBase, false, "Wasteland Crossing with Bunny Hood","You can beat the quicksand by using the increased speed of the Bunny Hood. Note that jumping to the carpet merchant as child typically requires a fairly precise jump slash."),
RT_OBJECT(RT_HW_CROSSING, RTVORMQ_BOTH, RTAREA_WASTELAND, &intermediateBase, false, "Wasteland Crossing without Hover Boots or Longshot", "You can beat the quicksand by backwalking across it in a specific way. Note that jumping to the carpet merchant as child typically requires a fairly precise jump slash."),
RT_OBJECT(RT_LENS_HW, RTVORMQ_BOTH, RTAREA_WASTELAND, &intermediateBase, false, "Lensless Wasteland", "By memorizing the path, you can travel through the Wasteland without using the Lens of Truth to see the Poe. The equivalent trick for going in reverse through the Wasteland is \"Reverse Wasteland\"."),
RT_OBJECT(RT_HW_REVERSE, RTVORMQ_BOTH, RTAREA_WASTELAND, &intermediateBase, false, "Reverse Wasteland", "By memorizing the path, you can travel through the Wasteland in reverse. Note that jumping to the carpet merchant as child typically requires a fairly precise jump slash. The equivalent trick for going forward through the Wasteland is \"Lensless Wasteland\". To cross the river of sand with no additional items, be sure to also enable \"Wasteland Crossing without Hover Boots or Longshot\". Unless all overworld entrances are randomized, child Link will not be expected to do anything at Gerudo's Fortress."),
RT_OBJECT(RT_COLOSSUS_GS, RTVORMQ_BOTH, RTAREA_DESERT_COLOSSUS, &noviceBase, false, "Colossus Hill GS with Hookshot", "Somewhat precise. If you kill enough Leevers you can get enough of a break to take some time to aim more carefully."),
RT_OBJECT(RT_DEKU_BASEMENT_GS, RTVORMQ_VANILLA, RTAREA_DEKU_TREE, &noviceBase, false, "Deku Tree Basement Vines GS with Jump Slash", "Can be defeated by doing a precise jump slash."),
RT_OBJECT(RT_DEKU_B1_SKIP, RTVORMQ_BOTH, RTAREA_DEKU_TREE, &intermediateBase, false, "Deku Tree Basement without Slingshot", "A precise jump can be used to skip needing to use the Slingshot to go around B1 of the Deku Tree. If used with the \"Closed Forest\" setting, a Slingshot will not be guaranteed to exist somewhere inside the Forest. This trick applies to both Vanilla and Master Quest."),
RT_OBJECT(RT_DEKU_B1_BOW_WEBS, RTVORMQ_VANILLA, RTAREA_DEKU_TREE, &noviceBase, false, "Deku Tree Basement Web to Gohma with Bow", "All spider web walls in the Deku Tree basement can be burnt as adult with just a bow by shooting through torches. This trick only applies to the circular web leading to Gohma; the two vertical webs are always in logic. Backflip onto the chest near the torch at the bottom of the vine wall. With precise positioning you can shoot through the torch to the right edge of the circular web. This allows completion of adult Deku Tree with no fire source."),
RT_OBJECT(RT_DEKU_MQ_COMPASS_GS, RTVORMQ_MQ, RTAREA_DEKU_TREE, &noviceBase, false, "Deku Tree MQ Compass Room GS Boulders with Just Hammer", "Climb to the top of the vines, then let go and jump slash immediately to destroy the boulders using the Hammer, without needing to spawn a Song of Time block."),
RT_OBJECT(RT_DEKU_MQ_LOG, RTVORMQ_MQ, RTAREA_DEKU_TREE, &noviceBase, false, "Deku Tree MQ Roll Under the Spiked Log", "You can get past the spiked log by rolling to briefly shrink your hitbox. As adult, the timing is a bit more precise."),
RT_OBJECT(RT_DC_SCARECROW_GS, RTVORMQ_VANILLA, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Scarecrow GS with Armos Statue", "You can jump off an Armos Statue to reach the alcove with the Gold Skulltula. It takes quite a long time to pull the statue the entire way. The jump to the alcove can be a bit picky when done as child."),
RT_OBJECT(RT_DC_VINES_GS, RTVORMQ_VANILLA, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Vines GS from Below with Longshot", "The vines upon which this Skulltula rests are one- sided collision. You can use the Longshot to get it from below, by shooting it through the vines, bypassing the need to lower the staircase."),
RT_OBJECT(RT_DC_STAIRCASE, RTVORMQ_VANILLA, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Staircase with Bow", "The Bow can be used to knock down the stairs with two well-timed shots."),
RT_OBJECT(RT_DC_SLINGSHOT_SKIP, RTVORMQ_VANILLA, RTAREA_DODONGOS_CAVERN, &expertBase, false, "Dodongo\'s Cavern Child Slingshot Skips", "With precise platforming, child can cross the platforms while the flame circles are there. When enabling this trick, it's recommended that you also enable the Adult variant: \"Dodongo's Cavern Spike Trap Room Jump without Hover Boots\"."),
RT_OBJECT(RT_DC_SCRUB_ROOM, RTVORMQ_VANILLA, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Two Scrub Room with Strength", "With help from a conveniently-positioned block, Adult can quickly carry a bomb flower over to destroy the mud wall blocking the room with two Deku Scrubs."),
RT_OBJECT(RT_DC_JUMP, RTVORMQ_BOTH, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Spike Trap Room Jump without Hover Boots", "The jump is adult Link only. Applies to both Vanilla and MQ."),
RT_OBJECT(RT_DC_HAMMER_FLOOR, RTVORMQ_BOTH, RTAREA_DODONGOS_CAVERN, &noviceBase, false, "Dodongo\'s Cavern Smash the Boss Lobby Floor", "The bombable floor before King Dodongo can be destroyed with Hammer if hit in the very center. This is only relevant with Shuffle Boss Entrances or if Dodongo's Cavern is MQ and either variant of \"Dodongo's Cavern MQ Light the Eyes with Strength\" is on."),
RT_OBJECT(RT_DC_MQ_CHILD_BOMBS, RTVORMQ_MQ, RTAREA_DODONGOS_CAVERN, &advancedBase, false, "Dodongo\'s Cavern MQ Early Bomb Bag Area as Child", "With a precise jump slash from above, you can reach the Bomb Bag area as only child without needing a Slingshot. You will take fall damage."),
RT_OBJECT(RT_DC_MQ_CHILD_EYES, RTVORMQ_MQ, RTAREA_DODONGOS_CAVERN, &expertBase, false, "Dodongo\'s Cavern MQ Light the Eyes with Strength as Child", "If you move very quickly, it is possible to use the bomb flower at the top of the room to light the eyes. To perform this trick as child is significantly more difficult than adult. The player is also expected to complete the DC back area without explosives, including getting past the Armos wall to the switch for the boss door."),
RT_OBJECT(RT_DC_MQ_ADULT_EYES, RTVORMQ_MQ, RTAREA_DODONGOS_CAVERN, &advancedBase, false, "Dodongo\'s Cavern MQ Light the Eyes with Strength as Adult", "If you move very quickly, it is possible to use the bomb flower at the top of the room to light the eyes."),
RT_OBJECT(RT_JABU_ALCOVE_JUMP_DIVE, RTVORMQ_BOTH, RTAREA_JABU_JABUS_BELLY, &noviceBase, false, "Jabu Underwater Alcove as Adult with Jump Dive", "Standing above the underwater tunnel leading to the scrub, jump down and swim through the tunnel. This allows adult to access the alcove with no Scale or Iron Boots. In vanilla Jabu, this alcove has a business scrub. In MQ Jabu, it has the compass chest and a door switch for the main floor."),
RT_OBJECT(RT_JABU_BOSS_HOVER, RTVORMQ_VANILLA, RTAREA_JABU_JABUS_BELLY, &intermediateBase, false, "Jabu Near Boss Room with Hover Boots", "A box for the blue switch can be carried over by backwalking with one while the elevator is at its peak. Alternatively, you can skip transporting a box by quickly rolling from the switch and opening the door before it closes. However, the timing for this is very tight."),
RT_OBJECT(RT_JABU_NEAR_BOSS_RANGED, RTVORMQ_BOTH, RTAREA_JABU_JABUS_BELLY, &noviceBase, false, "Jabu Near Boss Ceiling Switch/GS without Boomerang or Explosives", "Vanilla Jabu: From near the entrance into the room, you can hit the switch that opens the door to the boss room using a precisely-aimed use of the Slingshot, Bow, or Longshot. As well, if you climb to the top of the vines you can stand on the right edge of the platform and shoot around the glass. From this distance, even the Hookshot can reach the switch. This trick is only relevant if \"Shuffle Boss Entrances\" is enabled. MQ Jabu: A Gold Skulltula Token can be collected with the Hookshot or Longshot using the same methods as hitting the switch in vanilla. This MQ trick is not currently relevant in logic."),
RT_OBJECT(RT_JABU_NEAR_BOSS_EXPLOSIVES, RTVORMQ_VANILLA, RTAREA_JABU_JABUS_BELLY, &intermediateBase, false, "Jabu Near Boss Ceiling Switch with Explosives", "You can hit the switch that opens the door to the boss room using a precisely-aimed Bombchu. Also, using the Hover Boots, adult can throw a Bomb at the switch. This trick is only relevant if \"Shuffle Boss Entrances\" is enabled."),
RT_OBJECT(RT_LENS_JABU_MQ, RTVORMQ_MQ, RTAREA_JABU_JABUS_BELLY, &noviceBase, false, "Jabu MQ without Lens of Truth", "Removes the requirements for the Lens of Truth in Jabu MQ."),
//RT_OBJECT(RT_JABU_MQ_RANG_JUMP, RTVORMQ_MQ, RTAREA_JABU_JABUS_BELLY, &advancedBase, false, "Jabu MQ Compass Chest with Boomerang", "Boomerang can reach the cow switch to spawn the chest by targeting the cow, jumping off of the ledge where the chest spawns, and throwing the Boomerang in midair. This is only relevant with Jabu Jabu's Belly dungeon shortcuts enabled."),
RT_OBJECT(RT_JABU_MQ_SOT_GS, RTVORMQ_MQ, RTAREA_JABU_JABUS_BELLY, &intermediateBase, false, "Jabu MQ Song of Time Block GS with Boomerang", "Allow the Boomerang to return to you through the Song of Time block to grab the token."),
RT_OBJECT(RT_LENS_BOTW, RTVORMQ_VANILLA, RTAREA_BOTTOM_OF_THE_WELL, &noviceBase, false, "Bottom of the Well without Lens of Truth", "Removes the requirements for the Lens of Truth in Bottom of the Well."),
RT_OBJECT(RT_BOTW_CHILD_DEADHAND, RTVORMQ_BOTH, RTAREA_BOTTOM_OF_THE_WELL, &noviceBase, false, "Child Dead Hand without Kokiri Sword", "Requires 9 sticks or 5 jump slashes."),
RT_OBJECT(RT_BOTW_BASEMENT, RTVORMQ_VANILLA, RTAREA_BOTTOM_OF_THE_WELL, &noviceBase, false, "Bottom of the Well Map Chest with Strength & Sticks", "The chest in the basement can be reached with strength by doing a jump slash with a lit stick to access the bomb flowers."),
RT_OBJECT(RT_BOTW_MQ_PITS, RTVORMQ_MQ, RTAREA_BOTTOM_OF_THE_WELL, &noviceBase, false, "Bottom of the Well MQ Jump Over the Pits", "While the pits in Bottom of the Well don't allow you to jump just by running straight at them, you can still get over them by side-hopping or backflipping across. With explosives, this allows you to access the central areas without Zelda's Lullaby. With Zelda's Lullaby, it allows you to access the west inner room without explosives."),
RT_OBJECT(RT_BOTW_MQ_DEADHAND_KEY, RTVORMQ_MQ, RTAREA_BOTTOM_OF_THE_WELL, &noviceBase, false, "Bottom of the Well MQ Dead Hand Freestanding Key with Boomerang", "Boomerang can fish the item out of the rubble without needing explosives to blow it up."),
RT_OBJECT(RT_FOREST_FIRST_GS, RTVORMQ_VANILLA, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Forest Temple First Room GS with Difficult-to-Use Weapons", "Allows killing this Skulltula with Sword or Sticks by jump slashing it as you let go from the vines. You can avoid taking fall damage by recoiling onto the tree. Also allows killing it as Child with a Bomb throw. It's much more difficult to use a Bomb as child due to Child Link's shorter height."),
RT_OBJECT(RT_FOREST_OUTDOORS_EAST_GS, RTVORMQ_VANILLA, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Forest Temple East Courtyard GS with Boomerang", "Precise Boomerang throws can allow child to kill the Skulltula and collect the token."),
RT_OBJECT(RT_FOREST_VINES, RTVORMQ_BOTH, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Forest Temple East Courtyard Vines with Hookshot", "The vines in Forest Temple leading to where the well drain switch is in the standard form can be barely reached with just the Hookshot. Applies to MQ also."),
RT_OBJECT(RT_FOREST_OUTDOORS_LEDGE, RTVORMQ_BOTH, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Forest Temple NE Outdoors Ledge with Hover Boots", "With precise Hover Boots movement you can fall down to this ledge from upper balconies. If done precisely enough, it is not necessary to take fall damage. In MQ, this skips a Longshot requirement. In Vanilla, this can skip a Hookshot requirement in entrance randomizer."),
RT_OBJECT(RT_FOREST_DOORFRAME, RTVORMQ_BOTH, RTAREA_FOREST_TEMPLE, &advancedBase, false, "Forest Temple East Courtyard Door Frame with Hover Boots", "A precise Hover Boots movement from the upper balconies in this courtyard can be used to get on top of the door frame. Applies to both Vanilla and Master Quest. In Vanilla, from on top the door frame you can summon Pierre, allowing you to access the falling ceiling room early. In Master Quest, this allows you to obtain the GS on the door frame as adult without Hookshot or Song of Time."),
RT_OBJECT(RT_FOREST_OUTSIDE_BACKDOOR, RTVORMQ_BOTH, RTAREA_FOREST_TEMPLE, &advancedBase, false, "Forest Temple Outside Backdoor with Jump Slash", "A jump slash recoil can be used to reach the ledge in the block puzzle room that leads to the west courtyard. This skips a potential Hover Boots requirement in vanilla, and it can sometimes apply in MQ as well. This trick can be performed as both ages."),
RT_OBJECT(RT_FOREST_MQ_WELL_SWIM, RTVORMQ_MQ, RTAREA_FOREST_TEMPLE, &advancedBase, false, "Swim Through Forest Temple MQ Well with Hookshot", "Shoot the vines in the well as low and as far to the right as possible, and then immediately swim under the ceiling to the right. This can only be required if Forest Temple is in its Master Quest form."),
RT_OBJECT(RT_FOREST_MQ_BLOCK_PUZZLE, RTVORMQ_MQ, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Skip Forest Temple MQ Block Puzzle with Bombchu", "Send the Bombchu straight up the center of the wall directly to the left upon entering the room."),
RT_OBJECT(RT_FOREST_MQ_JS_HALLWAY_SWITCH, RTVORMQ_MQ, RTAREA_FOREST_TEMPLE, &noviceBase, false, "Forest Temple MQ Twisted Hallway Switch with Jump Slash", "The switch to twist the hallway can be hit with a jump slash through the glass block. To get in front of the switch, either use the Hover Boots or hit the shortcut switch at the top of the room and jump from the glass blocks that spawn. Sticks can be used as child, but the Kokiri Sword is too short to reach through the glass."),
//RT_OBJECT(RT_FOREST_MQ_HOOKSHOT_HALLWAY_SWITCH, RTVORMQ_MQ, RTAREA_FOREST_TEMPLE, &intermediateBase, false, "Forest Temple MQ Twisted Hallway Switch with Hookshot", "There's a very small gap between the glass block and the wall. Through that gap you can hookshot the target on the ceiling."),
RT_OBJECT(RT_FOREST_MQ_RANG_HALLWAY_SWITCH, RTVORMQ_MQ, RTAREA_FOREST_TEMPLE, &intermediateBase, false, "Forest Temple MQ Twisted Hallway Switch with Boomerang", "The Boomerang can return to Link through walls, allowing child to hit the hallway switch. This can be used to allow adult to pass through later, or in conjuction with \"Forest Temple Outside Backdoor with Jump Slash\"."),
RT_OBJECT(RT_FIRE_BOSS_DOOR_JUMP, RTVORMQ_BOTH, RTAREA_FIRE_TEMPLE, &noviceBase, false, "Fire Temple Boss Door without Hover Boots or Pillar", "The Fire Temple Boss Door can be reached as adult with a precise jump. You must be touching the side wall of the room so that Link will grab the ledge from farther away than is normally possible."),
RT_OBJECT(RT_FIRE_SOT, RTVORMQ_VANILLA, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple Song of Time Room GS without Song of Time", "A precise jump can be used to reach this room."),
RT_OBJECT(RT_FIRE_STRENGTH, RTVORMQ_VANILLA, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple Climb without Strength", "A precise jump can be used to skip pushing the block."),
RT_OBJECT(RT_FIRE_SCARECROW, RTVORMQ_VANILLA, RTAREA_FIRE_TEMPLE, &expertBase, false, "Fire Temple East Tower without Scarecrow\'s Song", "Also known as \"Pixelshot\". The Longshot can reach the target on the elevator itself, allowing you to skip needing to spawn the scarecrow."),
RT_OBJECT(RT_FIRE_FLAME_MAZE, RTVORMQ_VANILLA, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple Flame Wall Maze Skip", "If you move quickly you can sneak past the edge of a flame wall before it can rise up to block you. To do it without taking damage is more precise. Allows you to progress without needing either a Small Key or Hover Boots."),
RT_OBJECT(RT_FIRE_MQ_NEAR_BOSS, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &noviceBase, false, "Fire Temple MQ Chest Near Boss without Breaking Crate", "The hitbox for the torch extends a bit outside of the crate. Shoot a flaming arrow at the side of the crate to light the torch without needing to get over there and break the crate."),
RT_OBJECT(RT_FIRE_MQ_BLOCKED_CHEST, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple MQ Big Lava Room Blocked Door without Hookshot", "There is a gap between the hitboxes of the flame wall in the big lava room. If you know where this gap is located, you can jump through it and skip needing to use the Hookshot. To do this without taking damage is more precise."),
RT_OBJECT(RT_FIRE_MQ_BK_CHEST, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple MQ Boss Key Chest without Bow", "It is possible to light both of the timed torches to unbar the door to the boss key chest's room with just Din's Fire if you move very quickly between the two torches. It is also possible to unbar the door with just Din's by abusing an oversight in the way the game counts how many torches have been lit."),
RT_OBJECT(RT_FIRE_MQ_CLIMB, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &noviceBase, false, "Fire Temple MQ Climb without Fire Source", "You can use the Hover Boots to hover around to the climbable wall, skipping the need to use a fire source and spawn a Hookshot target."),
RT_OBJECT(RT_FIRE_MQ_MAZE_SIDE_ROOM, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &noviceBase, false, "Fire Temple MQ Lizalfos Maze Side Room without Box", "You can walk from the blue switch to the door and quickly open the door before the bars reclose. This skips needing to reach the upper sections of the maze to get a box to place on the switch."),
RT_OBJECT(RT_FIRE_MQ_MAZE_HOVERS, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &noviceBase, false, "Fire Temple MQ Lower to Upper Lizalfos Maze with Hover Boots", "Use the Hover Boots off of a crate to climb to the upper maze without needing to spawn and use the Hookshot targets."),
RT_OBJECT(RT_FIRE_MQ_MAZE_JUMP, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple MQ Lower to Upper Lizalfos Maze with Precise Jump", "A precise jump off of a crate can be used to climb to the upper maze without needing to spawn and use the Hookshot targets. This trick supersedes both \"Fire Temple MQ Lower to Upper Lizalfos Maze with Hover Boots\" and \"Fire Temple MQ Lizalfos Maze Side Room without Box\"."),
RT_OBJECT(RT_FIRE_MQ_ABOVE_MAZE_GS, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &intermediateBase,/*todo*/ false, "Fire Temple MQ Above Flame Wall Maze GS from Below with Longshot", "The floor of the room that contains this Skulltula is only solid from above. From the maze below, the Longshot can be shot through the ceiling to obtain the token with two fewer small keys than normal."),
RT_OBJECT(RT_FIRE_MQ_FLAME_MAZE, RTVORMQ_MQ, RTAREA_FIRE_TEMPLE, &intermediateBase, false, "Fire Temple MQ Flame Wall Maze Skip", "If you move quickly you can sneak past the edge of a flame wall before it can rise up to block you. To do it without taking damage is more precise. Allows you to reach the side room GS without needing Song of Time or Hover Boots. If either of \"Fire Temple MQ Lower to Upper Lizalfos Maze with Hover Boots\" or \"with Precise Jump\" are enabled, this also allows you to progress deeper into the dungeon without Hookshot."),
RT_OBJECT(RT_WATER_LONGSHOT_TORCH, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Torch Longshot", "Stand on the eastern side of the central pillar and longshot the torches on the bottom level. Swim through the corridor and float up to the top level. This allows access to this area and lower water levels without Iron Boots. The majority of the tricks that allow you to skip Iron Boots in the Water Temple are not going to be relevant unless this trick is first enabled."),
RT_OBJECT(RT_WATER_CRACKED_WALL_HOVERS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Cracked Wall with Hover Boots", "With a midair side-hop while wearing the Hover Boots, you can reach the cracked wall without needing to raise the water up to the middle level."),
RT_OBJECT(RT_WATER_CRACKED_WALL, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &intermediateBase, false, "Water Temple Cracked Wall with No Additional Items", "A precise jump slash (among other methods) will get you to the cracked wall without needing the Hover Boots or to raise the water to the middle level. This trick supersedes \"Water Temple Cracked Wall with Hover Boots\"."),
RT_OBJECT(RT_WATER_BK_REGION, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &intermediateBase, false, "Water Temple Boss Key Region with Hover Boots", "With precise Hover Boots movement it is possible to reach the boss key chest's region without needing the Longshot. It is not necessary to take damage from the spikes. The Gold Skulltula Token in the following room can also be obtained with just the Hover Boots."),
RT_OBJECT(RT_WATER_NORTH_BASEMENT_LEDGE_JUMP, RTVORMQ_BOTH, RTAREA_WATER_TEMPLE, &intermediateBase, false, "Water Temple North Basement Ledge with Precise Jump", "In the northern basement there's a ledge from where, in vanilla Water Temple, boulders roll out into the room. Normally to jump directly to this ledge logically requires the Hover Boots, but with precise jump, it can be done without them. This trick applies to both Vanilla and Master Quest."),
RT_OBJECT(RT_WATER_BK_JUMP_DIVE, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Boss Key Jump Dive", "Stand on the very edge of the raised corridor leading from the push block room to the rolling boulder corridor. Face the gold skulltula on the waterfall and jump over the boulder corridor floor into the pool of water, swimming right once underwater. This allows access to the boss key room without Iron boots."),
RT_OBJECT(RT_WATER_FW_CENTRAL_GS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Central Pillar GS with Farore\'s Wind", "If you set Farore's Wind inside the central pillar and then return to that warp point after raising the water to the highest level, you can obtain this Skulltula Token with Hookshot or Boomerang."),
RT_OBJECT(RT_WATER_IRONS_CENTRAL_GS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Central Pillar GS with Iron Boots", "After opening the middle water level door into the central pillar, the door will stay unbarred so long as you do not leave the room -- even if you were to raise the water up to the highest level. With the Iron Boots to go through the door after the water has been raised, you can obtain the Skulltula Token with the Hookshot."),
RT_OBJECT(RT_WATER_CENTRAL_BOW, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &advancedBase, false, "Water Temple Central Bow Target without Longshot or Hover Boots", "A very precise Bow shot can hit the eye switch from the floor above. Then, you can jump down into the hallway and make through it before the gate closes. It can also be done as child, using the Slingshot instead of the Bow."),
RT_OBJECT(RT_WATER_HOOKSHOT_FALLING_PLATFORM_GS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Falling Platform Room GS with Hookshot", "If you stand on the very edge of the platform, this Gold Skulltula can be obtained with only the Hookshot."),
RT_OBJECT(RT_WATER_RANG_FALLING_PLATFORM_GS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &intermediateBase, false, "Water Temple Falling Platform Room GS with Boomerang", "If you stand on the very edge of the platform, this Gold Skulltula can be obtained with only the Boomerang."),
RT_OBJECT(RT_WATER_RIVER_GS, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &intermediateBase, false, "Water Temple River GS without Iron Boots", "Standing on the exposed ground toward the end of the river, a precise Longshot use can obtain the token. The Longshot cannot normally reach far enough to kill the Skulltula, however. You'll first have to find some other way of killing it."),
RT_OBJECT(RT_WATER_DRAGON_JUMP_DIVE, RTVORMQ_BOTH, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Dragon Statue Jump Dive", "If you come into the dragon statue room from the serpent river, you can jump down from above and get into the tunnel without needing either Iron Boots or a Scale. This trick applies to both Vanilla and Master Quest. In Vanilla, you must shoot the switch from above with the Bow, and then quickly get through the tunnel before the gate closes."),
RT_OBJECT(RT_WATER_ADULT_DRAGON, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple Dragon Statue Switch from Above the Water as Adult", "Normally you need both Hookshot and Iron Boots to hit the switch and swim through the tunnel to get to the chest. But by hitting the switch from dry land, using one of Bombchus, Hookshot, or Bow, it is possible to skip one or both of those requirements. After the gate has been opened, besides just using the Iron Boots, a well-timed dive with at least the Silver Scale could be used to swim through the tunnel. If coming from the serpent river, a jump dive can also be used to get into the tunnel."),
RT_OBJECT(RT_WATER_CHILD_DRAGON, RTVORMQ_VANILLA, RTAREA_WATER_TEMPLE, &advancedBase, false, "Water Temple Dragon Statue Switch from Above the Water as Child", "It is possible for child to hit the switch from dry land using one of Bombchus, Slingshot or Boomerang. Then, to get to the chest, child can dive through the tunnel using at least the Silver Scale. The timing and positioning of this dive needs to be perfect to actually make it under the gate, and it all needs to be done very quickly to be able to get through before the gate closes. Be sure to enable \"Water Temple Dragon Statue Switch from Above the Water as Adult\" for adult's variant of this trick."),
RT_OBJECT(RT_WATER_MQ_CENTRAL_PILLAR, RTVORMQ_MQ, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple MQ Central Pillar with Fire Arrows", "Slanted torches have misleading hitboxes. Whenever you see a slanted torch jutting out of the wall, you can expect most or all of its hitbox is actually on the other side that wall. This can make slanted torches very finicky to light when using arrows. The torches in the central pillar of MQ Water Temple are a particularly egregious example. Logic normally expects Din's Fire and Song of Time."),
RT_OBJECT(RT_WATER_MQ_LOCKED_GS, RTVORMQ_MQ, RTAREA_WATER_TEMPLE, &noviceBase, false, "Water Temple MQ North Basement GS without Small Key", "There is an invisible Hookshot target that can be used to get over the gate that blocks you from going to this Skulltula early, skipping a small key as well as needing Hovers or Scarecrow to reach the locked door."),
RT_OBJECT(RT_LENS_SHADOW, RTVORMQ_VANILLA, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple Stationary Objects without Lens of Truth", "Removes the requirements for the Lens of Truth in Shadow Temple for most areas in the dungeon except for crossing the moving platform in the huge pit room and for fighting Bongo Bongo."),
RT_OBJECT(RT_LENS_SHADOW_PLATFORM, RTVORMQ_VANILLA, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple Invisible Moving Platform without Lens of Truth", "Removes the requirements for the Lens of Truth in Shadow Temple to cross the invisible moving platform in the huge pit room in either direction."),
RT_OBJECT(RT_LENS_BONGO, RTVORMQ_BOTH, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple Bongo Bongo without Lens of Truth", "Bongo Bongo can be defeated without the use of Lens of Truth, as the hands give a pretty good idea of where the eye is."),
RT_OBJECT(RT_SHADOW_UMBRELLA, RTVORMQ_BOTH, RTAREA_SHADOW_TEMPLE, &expertBase, false, "Shadow Temple Stone Umbrella Skip", "A very precise Hover Boots movement from off of the lower chest can get you on top of the crushing spikes without needing to pull the block. Applies to both Vanilla and Master Quest."),
RT_OBJECT(RT_SHADOW_UMBRELLA_GS, RTVORMQ_BOTH, RTAREA_SHADOW_TEMPLE, &expertBase, false, "Shadow Temple Falling Spikes GS with Hover Boots", "After killing the Skulltula, a very precise Hover Boots movement from off of the lower chest can get you on top of the crushing spikes without needing to pull the block. From there, another very precise Hover Boots movement can be used to obtain the token without needing the Hookshot. Applies to both Vanilla and Master Quest. For obtaining the chests in this room with just Hover Boots, be sure to enable \"Shadow Temple Stone Umbrella Skip\"."),
RT_OBJECT(RT_SHADOW_FREESTANDING_KEY, RTVORMQ_VANILLA, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple Freestanding Key with Bombchu", "Release the Bombchu with good timing so that it explodes near the bottom of the pot."),
RT_OBJECT(RT_SHADOW_STATUE, RTVORMQ_BOTH, RTAREA_SHADOW_TEMPLE, &intermediateBase, false, "Shadow Temple River Statue with Bombchu", "By sending a Bombchu around the edge of the gorge, you can knock down the statue without needing a Bow. Applies in both vanilla and MQ Shadow."),
RT_OBJECT(RT_SHADOW_BONGO, RTVORMQ_BOTH, RTAREA_SHADOW_TEMPLE, &intermediateBase, false, "Shadow Temple Bongo Bongo without projectiles", "Using precise sword slashes, Bongo Bongo can be defeated without using projectiles. This is only relevant in conjunction with Shadow Temple dungeon shortcuts or shuffled boss entrances."),
RT_OBJECT(RT_LENS_SHADOW_MQ, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple MQ Stationary Objects without Lens of Truth", "Removes the requirements for the Lens of Truth in Shadow Temple MQ for most areas in the dungeon. See \"Shadow Temple MQ Invisible Moving Platform without Lens of Truth\", \"Shadow Temple MQ Invisible Blades Silver Rupees without Lens of Truth\", \"Shadow Temple MQ 2nd Dead Hand without Lens of Truth\", and \"Shadow Temple Bongo Bongo without Lens of Truth\" for exceptions."),
RT_OBJECT(RT_LENS_SHADOW_MQ_INVISIBLE_BLADES, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple MQ Invisible Blades Silver Rupees without Lens of Truth", "Removes the requirement for the Lens of Truth or Nayru's Love in Shadow Temple MQ for the Invisible Blades room silver rupee collection."),
RT_OBJECT(RT_LENS_SHADOW_MQ_PLATFORM, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple MQ Invisible Moving Platform without Lens of Truth", "Removes the requirements for the Lens of Truth in Shadow Temple MQ to cross the invisible moving platform in the huge pit room in either direction."),
RT_OBJECT(RT_LENS_SHADOW_MQ_DEADHAND, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &noviceBase, false, "Shadow Temple MQ 2nd Dead Hand without Lens of Truth", "Dead Hand spawns in a random spot within the room. Having Lens removes the hassle of having to comb the room looking for his spawn location."),
RT_OBJECT(RT_SHADOW_MQ_GAP, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &intermediateBase, false, "Shadow Temple MQ Truth Spinner Gap with Longshot", "You can Longshot a torch and jump-slash recoil onto the tongue. It works best if you Longshot the right torch from the left side of the room."),
RT_OBJECT(RT_SHADOW_MQ_INVISIBLE_BLADES, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &intermediateBase, false, "Shadow Temple MQ Invisible Blades without Song of Time", "The Like Like can be used to boost you into the silver rupee or recovery hearts that normally require Song of Time. This cannot be performed on OHKO since the Like Like does not boost you high enough if you die."),
RT_OBJECT(RT_SHADOW_MQ_HUGE_PIT, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &intermediateBase, false, "Shadow Temple MQ Lower Huge Pit without Fire Source", "Normally a frozen eye switch spawns some platforms that you can use to climb down, but there's actually a small piece of ground that you can stand on that you can just jump down to."),
//RT_OBJECT(RT_SHADOW_MQ_WINDY_WALKWAY, RTVORMQ_MQ, RTAREA_SHADOW_TEMPLE, &intermediateBase, todo false, "Shadow Temple MQ Windy Walkway Reverse without Hover Boots", "With shadow dungeon shortcuts enabled, it is possible to jump from the alcove in the windy hallway to the middle platform. There are two methods: wait out the fan opposite the door and hold forward, or jump to the right to be pushed by the fan there towards the platform ledge. Note that jumps of this distance are inconsistent, but still possible."),
RT_OBJECT(RT_LENS_SPIRIT, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple without Lens of Truth", "Removes the requirements for the Lens of Truth in Spirit Temple."),
RT_OBJECT(RT_SPIRIT_CHILD_CHU, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple Child Side Bridge with Bombchu", "A carefully-timed Bombchu can hit the switch."),
RT_OBJECT(RT_SPIRIT_LOBBY_GS, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple Main Room GS with Boomerang", "Standing on the highest part of the arm of the statue, a precise Boomerang throw can kill and obtain this Gold Skulltula. You must throw the Boomerang slightly off to the side so that it curves into the Skulltula, as aiming directly at it will clank off of the wall in front."),
RT_OBJECT(RT_SPIRIT_LOWER_ADULT_SWITCH, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &advancedBase, false, "Spirit Temple Lower Adult Switch with Bombs", "A bomb can be used to hit the switch on the ceiling, but it must be thrown from a particular distance away and with precise timing."),
RT_OBJECT(RT_SPIRIT_LOBBY_JUMP, RTVORMQ_BOTH, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple Main Room Jump from Hands to Upper Ledges", "A precise jump to obtain the following as adult without needing one of Hover Boots, or Hookshot (in vanilla) or Song of Time (in MQ): - Spirit Temple Statue Room Northeast Chest - Spirit Temple GS Lobby - Spirit Temple MQ Central Chamber Top Left Pot (Left) - Spirit Temple MQ Central Chamber Top Left Pot (Right)"),
//RT_OBJECT(RT_SPIRIT_PLATFORM_HOOKSHOT, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple Main Room Hookshot to Boss Platform", "Precise hookshot aiming at the platform chains can be used to reach the boss platform from the middle landings. Using a jump slash immediately after reaching a chain makes aiming more lenient. Relevant only when Spirit Temple boss shortcuts are on."),
RT_OBJECT(RT_SPIRIT_MAP_CHEST, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple Map Chest with Bow", "To get a line of sight from the upper torch to the map chest torches, you must pull an Armos statue all the way up the stairs."),
RT_OBJECT(RT_SPIRIT_SUN_CHEST, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &advancedBase, false, "Spirit Temple Sun Block Room Chest with Bow", "Using the blocks in the room as platforms you can get lines of sight to all three torches. The timer on the torches is quite short so you must move quickly in order to light all three."),
RT_OBJECT(RT_SPIRIT_WALL, RTVORMQ_VANILLA, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple Shifting Wall with No Additional Items", "Logic normally guarantees a way of dealing with both the Beamos and the Walltula before climbing the wall."),
RT_OBJECT(RT_LENS_SPIRIT_MQ, RTVORMQ_MQ, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple MQ without Lens of Truth", "Removes the requirements for the Lens of Truth in Spirit Temple MQ."),
RT_OBJECT(RT_SPIRIT_MQ_SUN_BLOCK_SOT, RTVORMQ_MQ, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple MQ Sun Block Room as Child without Song of Time", "While adult can easily jump directly to the switch that unbars the door to the sun block room, child Link cannot make the jump without spawning a Song of Time block to jump from. You can skip this by throwing the crate down onto the switch from above, which does unbar the door, however the crate immediately breaks, so you must move quickly to get through the door before it closes back up."),
RT_OBJECT(RT_SPIRIT_MQ_SUN_BLOCK_GS, RTVORMQ_MQ, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple MQ Sun Block Room GS with Boomerang", "Throw the Boomerang in such a way that it curves through the side of the glass block to hit the Gold Skulltula."),
RT_OBJECT(RT_SPIRIT_MQ_LOWER_ADULT, RTVORMQ_MQ, RTAREA_SPIRIT_TEMPLE, &intermediateBase, false, "Spirit Temple MQ Lower Adult without Fire Arrows", "By standing in a precise position it is possible to light two of the torches with a single use of Din\'s Fire. This saves enough time to be able to light all three torches with only Din\'s."),
RT_OBJECT(RT_SPIRIT_MQ_FROZEN_EYE, RTVORMQ_MQ, RTAREA_SPIRIT_TEMPLE, &noviceBase, false, "Spirit Temple MQ Frozen Eye Switch without Fire", "You can melt the ice by shooting an arrow through a torch. The only way to find a line of sight for this shot is to first spawn a Song of Time block, and then stand on the very edge of it."),
RT_OBJECT(RT_ICE_BLOCK_GS, RTVORMQ_VANILLA, RTAREA_ICE_CAVERN, &intermediateBase, false, "Ice Cavern Block Room GS with Hover Boots", "The Hover Boots can be used to get in front of the Skulltula to kill it with a jump slash. Then, the Hover Boots can again be used to obtain the Token, all without Hookshot or Boomerang."),
RT_OBJECT(RT_ICE_MQ_RED_ICE_GS, RTVORMQ_MQ, RTAREA_ICE_CAVERN, &intermediateBase, false, "Ice Cavern MQ Red Ice GS without Song of Time", "If you side-hop into the perfect position, you can briefly stand on the platform with the red ice just long enough to dump some blue fire."),
RT_OBJECT(RT_ICE_MQ_SCARECROW, RTVORMQ_MQ, RTAREA_ICE_CAVERN, &intermediateBase, /*todo*/ false, "Ice Cavern MQ Scarecrow GS with No Additional Items", "As adult a precise jump can be used to reach this alcove."),
RT_OBJECT(RT_LENS_GTG, RTVORMQ_VANILLA, RTAREA_GERUDO_TRAINING_GROUND, &noviceBase, false, "Gerudo Training Ground without Lens of Truth", "Removes the requirements for the Lens of Truth in Gerudo Training Ground."),
RT_OBJECT(RT_GTG_WITHOUT_HOOKSHOT, RTVORMQ_VANILLA, RTAREA_GERUDO_TRAINING_GROUND, &intermediateBase, false, "Gerudo Training Ground Left Side Silver Rupees without Hookshot", "After collecting the rest of the silver rupees in the room, you can reach the final silver rupee on the ceiling by being pulled up into it after getting grabbed by the Wallmaster. Then, you must also reach the exit of the room without the use of the Hookshot. If you move quickly you can sneak past the edge of a flame wall before it can rise up to block you. To do so without taking damage is more precise."),
RT_OBJECT(RT_GTG_FAKE_WALL, RTVORMQ_BOTH, RTAREA_GERUDO_TRAINING_GROUND, &noviceBase, false, "Reach Gerudo Training Ground Fake Wall Ledge with Hover Boots", "A precise Hover Boots use from the top of the chest can allow you to grab the ledge without needing the usual requirements. In Master Quest, this always skips a Song of Time requirement. In Vanilla, this skips a Hookshot requirement, but is only relevant if \"Gerudo Training Ground Left Side Silver Rupees without Hookshot\" is enabled."),
RT_OBJECT(RT_LENS_GTG_MQ, RTVORMQ_MQ, RTAREA_GERUDO_TRAINING_GROUND, &noviceBase, false, "Gerudo Training Ground MQ without Lens of Truth", "Removes the requirements for the Lens of Truth in Gerudo Training Ground MQ."),
RT_OBJECT(RT_GTG_MQ_WITH_HOOKSHOT, RTVORMQ_MQ, RTAREA_GERUDO_TRAINING_GROUND, &noviceBase, false, "Gerudo Training Ground MQ Left Side Silver Rupees with Hookshot", "The highest silver rupee can be obtained by hookshotting the target and then immediately jump slashing toward the rupee."),
RT_OBJECT(RT_GTG_MQ_WIHTOUT_HOOKSHOT, RTVORMQ_MQ, RTAREA_GERUDO_TRAINING_GROUND, &intermediateBase, false, "Gerudo Training Ground MQ Left Side Silver Rupees without Hookshot", "After collecting the rest of the silver rupees in the room, you can reach the final silver rupee on the ceiling by being pulled up into it after getting grabbed by the Wallmaster. The Wallmaster will not track you to directly underneath the rupee. You should take the last step to be under the rupee after the Wallmaster has begun its attempt to grab you. Also included with this trick is that fact that the switch that unbars the door to the final chest of GTG can be hit without a projectile, using a precise jump slash. This trick supersedes \"Gerudo Training Ground MQ Left Side Silver Rupees with Hookshot\"."),
RT_OBJECT(RT_LENS_GANON, RTVORMQ_VANILLA, RTAREA_GANONS_CASTLE, &noviceBase, false, "Ganon\'s Castle without Lens of Truth", "Removes the requirements for the Lens of Truth in Ganon's Castle."),
RT_OBJECT(RT_GANON_SPIRIT_TRIAL_HOOKSHOT, RTVORMQ_VANILLA, RTAREA_GANONS_CASTLE, &noviceBase, false, "Spirit Trial without Hookshot", "The highest rupee can be obtained as either age by performing a precise jump and a well-timed jumpslash off of an Armos."),
RT_OBJECT(RT_LENS_GANON_MQ, RTVORMQ_MQ, RTAREA_GANONS_CASTLE, &noviceBase, false, "Ganon\'s Castle MQ without Lens of Truth", "Removes the requirements for the Lens of Truth in Ganon's Castle MQ."),
RT_OBJECT(RT_GANON_MQ_FIRE_TRIAL, RTVORMQ_MQ, RTAREA_GANONS_CASTLE, &advancedBase, /*todo*/ false, "Fire Trial MQ with Hookshot", "It's possible to hook the target at the end of fire trial with just Hookshot, but it requires precise aim and perfect positioning. The main difficulty comes from getting on the very corner of the obelisk without falling into the lava."),
RT_OBJECT(RT_GANON_MQ_SHADOW_TRIAL, RTVORMQ_MQ, RTAREA_GANONS_CASTLE, &noviceBase, false, "Shadow Trial MQ Torch with Bow", "You can light the torch in this room without a fire source by shooting an arrow through the lit torch at the beginning of the room. Because the room is so dark and the unlit torch is so far away, it can be difficult to aim the shot correctly."),
RT_OBJECT(RT_GANON_MQ_LIGHT_TRIAL, RTVORMQ_MQ, RTAREA_GANONS_CASTLE, &intermediateBase, /*todo*/ false, "Light Trial MQ without Hookshot", "If you move quickly you can sneak past the edge of a flame wall before it can rise up to block you. In this case to do it without taking damage is especially precise.")
};
std::unordered_map<RandomizerTrickArea, std::string> rtAreaNames = {
{ RTAREA_GENERAL, "General Tricks"},
//{ RTAREA_BK_SKIPS, "Boss Key Skips"},
{ RTAREA_KOKIRI_FOREST, "Kokiri Forest"},
{ RTAREA_LOST_WOODS, "Lost Woods"},
{ RTAREA_SACRED_FOREST_MEADOW, "Sacred Forest Meadow"},
{ RTAREA_HYRULE_FIELD, "Hyrule Field"},
{ RTAREA_LAKE_HYLIA, "Lake Hylia"},
{ RTAREA_GERUDO_VALLEY, "Gerudo Valley"},
{ RTAREA_GERUDO_FORTRESS, "Gerudo Fortress"},
{ RTAREA_WASTELAND, "Desert Wasteland"},
{ RTAREA_DESERT_COLOSSUS, "Desert Colossus"},
{ RTAREA_MARKET, "Hyrule Market"},
{ RTAREA_HYRULE_CASTLE, "Hyrule Castle"},
{ RTAREA_KAKARIKO_VILLAGE, "Kakariko Village"},
{ RTAREA_GRAVEYARD, "Graveyard"},
{ RTAREA_DEATH_MOUNTAIN_TRAIL, "Death Mountain Trail"},
{ RTAREA_GORON_CITY, "Goron City"},
{ RTAREA_DEATH_MOUNTAIN_CRATER, "Death Mountain Crater"},
{ RTAREA_ZORAS_RIVER, "Zora's River"},
{ RTAREA_ZORAS_DOMAIN, "Zora's Domain"},
{ RTAREA_ZORAS_FOUNTAIN, "Zora's Fountain"},
{ RTAREA_LON_LON_RANCH, "Lon Lon Ranch"},
{ RTAREA_DEKU_TREE, "Deku Tree"},
{ RTAREA_DODONGOS_CAVERN, "Dodongo's Cavern"},
{ RTAREA_JABU_JABUS_BELLY, "Jabu Jabu's Belly"},
{ RTAREA_FOREST_TEMPLE, "Forest Temple"},
{ RTAREA_FIRE_TEMPLE, "Fire Temple"},
{ RTAREA_WATER_TEMPLE, "Water Temple"},
{ RTAREA_SPIRIT_TEMPLE, "Spirit Temple"},
{ RTAREA_SHADOW_TEMPLE, "Shadow Temple"},
{ RTAREA_BOTTOM_OF_THE_WELL, "Bottom of the Well"},
{ RTAREA_ICE_CAVERN, "Ice Cavern"},
{ RTAREA_GERUDO_TRAINING_GROUND, "Gerudo Training Grounds"},
{ RTAREA_GANONS_CASTLE, "Ganon's Castle"},
{ RTAREA_INVALID, "Invalid"},
};
std::unordered_map<RandomizerTrickTag, std::string> rtTagNames = {
{RTTAG_NOVICE, "Novice"},
{RTTAG_INTERMEDIATE, "Intermediate"},
{RTTAG_ADVANCED, "Advanced"},
{RTTAG_EXPERT, "Expert"},
{RTTAG_EXTREME, "Extreme"},
/*{RTTAG_LENS, "Lens"},
{RTTAG_BKSKIP, "Boss Key Skip"},
{RTTAG_EXPERIMENTAL, "Experimental"}*/
};
std::unordered_map<RandomizerTrickArea, std::unordered_map<RandomizerTrick, RandomizerTrickObject>> rtObjectsByArea = {};
std::unordered_map<RandomizerTrick, RandomizerTrickObject> RandomizerTricks::GetAllRTObjects() {
return rtObjects;
}
std::unordered_map<RandomizerTrickArea, std::unordered_map<RandomizerTrick,RandomizerTrickObject>> RandomizerTricks::GetAllRTObjectsByArea() {
if (rtObjectsByArea.size() == 0) {
for (auto& [randomizerTrick, rtObject] : rtObjects) {
rtObjectsByArea[rtObject.rtArea][randomizerTrick] = rtObject;
}
}
return rtObjectsByArea;
}
std::string RandomizerTricks::GetRTAreaName(RandomizerTrickArea area) {
return rtAreaNames[area];
}
std::string RandomizerTricks::GetRTTagName(RandomizerTrickTag tag) {
return rtTagNames[tag];
}
std::string RandomizerTricks::GetRTName(RandomizerTrick trick) {
return rtObjects[trick].rtShortName;
}
ImVec4 RandomizerTricks::GetRTAreaColor(RandomizerTrickArea area) {
switch (area) {
case RTAREA_GENERAL:
return ImVec4(0.4f,0.4f,0.4f,1.0f);
case RTAREA_KOKIRI_FOREST:
return ImVec4(0.3f,0.6f,0.0f,1.0f);
case RTAREA_LOST_WOODS:
return ImVec4(0.0f,0.6f,0.0f,1.0f);
case RTAREA_SACRED_FOREST_MEADOW:
return ImVec4(0.0f,0.6f,0.2f,1.0f);
case RTAREA_HYRULE_FIELD:
return ImVec4(0.5f,1.0f,0.2f,1.0f);
case RTAREA_LAKE_HYLIA:
return ImVec4(0.0f,0.2f,1.0f,1.0f);
case RTAREA_GERUDO_VALLEY:
return ImVec4(0.6f,0.6f,0.15f,1.0f);
case RTAREA_GERUDO_FORTRESS:
return ImVec4(0.6f,0.5f,0.2f,1.0f);
case RTAREA_WASTELAND:
return ImVec4(0.7f,0.6f,0.3f,1.0f);
case RTAREA_DESERT_COLOSSUS:
return ImVec4(0.5f,0.5f,0.3f,1.0f);
case RTAREA_MARKET:
return ImVec4(0.6f,0.6f,0.6f,1.0f);
case RTAREA_HYRULE_CASTLE:
return ImVec4(0.5f,0.5f,0.5f,1.0f);
case RTAREA_KAKARIKO_VILLAGE:
return ImVec4(0.8f,0.4f,0.25f,1.0f);
case RTAREA_GRAVEYARD:
return ImVec4(0.5f,0.0f,1.0f,1.0f);
case RTAREA_DEATH_MOUNTAIN_TRAIL:
return ImVec4(0.8f,0.3f,0.1f,1.0f);
case RTAREA_GORON_CITY:
return ImVec4(0.75f,0.60f,0.18f,1.0f);
case RTAREA_DEATH_MOUNTAIN_CRATER:
return ImVec4(1.0f,0.0f,0.0f,1.0f);
case RTAREA_ZORAS_RIVER:
return ImVec4(0.0f,0.5f,0.7f,1.0f);
case RTAREA_ZORAS_DOMAIN:
return ImVec4(0.0f,0.5f,0.5f,1.0f);
case RTAREA_ZORAS_FOUNTAIN:
return ImVec4(0.0f,0.6f,0.75f,1.0f);
case RTAREA_LON_LON_RANCH:
return ImVec4(0.4f,0.25f,0.1f,1.0f);
case RTAREA_DEKU_TREE:
return ImVec4(0.2f,0.65f,0.3f,1.0f);
case RTAREA_DODONGOS_CAVERN:
return ImVec4(0.88f,0.07f,0.37f,1.0f);
case RTAREA_JABU_JABUS_BELLY:
return ImVec4(0.06f,0.32f,0.73f,1.0f);
case RTAREA_FOREST_TEMPLE:
return ImVec4(0.1f,0.55f,0.1f,1.0f);
case RTAREA_FIRE_TEMPLE:
return ImVec4(1.0f,0.4f,0.0f,1.0f);
case RTAREA_WATER_TEMPLE:
return ImVec4(0.0f,0.0f,1.0f,1.0f);
case RTAREA_SPIRIT_TEMPLE:
return ImVec4(0.7f,0.35f,0.0f,1.0f);
case RTAREA_SHADOW_TEMPLE:
return ImVec4(0.45f,0.0f,0.45f,1.0f);
case RTAREA_BOTTOM_OF_THE_WELL:
return ImVec4(0.7f,0.05f,1.0f,1.0f);
case RTAREA_ICE_CAVERN:
return ImVec4(0.0f,0.65f,0.65f,1.0f);
case RTAREA_GERUDO_TRAINING_GROUND:
return ImVec4(0.65f,0.57f,0.0f,1.0f);
case RTAREA_GANONS_CASTLE:
return ImVec4(0.2f,0.0f,0.4f,1.0f);
default:
return ImVec4(0.1f,0.1f,0.1f,1.0f);
}
}
ImVec4 RandomizerTricks::GetRTTagColor(RandomizerTrickTag tag) {
switch(tag) {
case RTTAG_NOVICE:
return ImVec4(0.09f,0.55f,0.37f,1.0f);
case RTTAG_INTERMEDIATE:
return ImVec4(0.95f,0.52f,0.0f,1.0f);
case RTTAG_ADVANCED:
return ImVec4(0.0f,0.29f,0.71f,1.0f);
case RTTAG_EXPERT:
return ImVec4(0.53f,0.05f,0.14f,1.0f);
case RTTAG_EXTREME:
return ImVec4(0.27f,0.0f,0.27f,1.0f);
default:
return ImVec4(0.5f,0.5f,0.5f,1.0f);
/*case RTTAG_LENS:
return ImVec4(.f,.f,.f,1.0f);
case RTTAG_BKSKIP:
return ImVec4(.f,.f,.f,1.0f);
case RTTAG_EXPERIMENTAL:
return ImVec4(.f,.f,.f,1.0f);*/
}
}
bool RandomizerTricks::CheckRTTags(std::unordered_map<RandomizerTrickTag, bool> &showTag, const std::vector<RandomizerTrickTag> &rtTags) {
for (auto rtTag : rtTags) {
if (showTag[rtTag]) {
return true;
}
}
return false;
}

86
soh/soh/Enhancements/randomizer/randomizer_tricks.h Normal file
View File

@ -0,0 +1,86 @@
#pragma once
#include "randomizerTypes.h"
#include <string>
#include <map>
#include <ImGuiImpl.h>
typedef enum {
RTAREA_GENERAL,
//RTAREA_BK_SKIPS,
RTAREA_KOKIRI_FOREST,
RTAREA_LOST_WOODS,
RTAREA_SACRED_FOREST_MEADOW,
RTAREA_HYRULE_FIELD,
RTAREA_LAKE_HYLIA,
RTAREA_GERUDO_VALLEY,
RTAREA_GERUDO_FORTRESS,
RTAREA_WASTELAND,
RTAREA_DESERT_COLOSSUS,
RTAREA_MARKET,
RTAREA_HYRULE_CASTLE,
RTAREA_KAKARIKO_VILLAGE,
RTAREA_GRAVEYARD,
RTAREA_DEATH_MOUNTAIN_TRAIL,
RTAREA_GORON_CITY,
RTAREA_DEATH_MOUNTAIN_CRATER,
RTAREA_ZORAS_RIVER,
RTAREA_ZORAS_DOMAIN,
RTAREA_ZORAS_FOUNTAIN,
RTAREA_LON_LON_RANCH,
RTAREA_DEKU_TREE,
RTAREA_DODONGOS_CAVERN,
RTAREA_JABU_JABUS_BELLY,
RTAREA_FOREST_TEMPLE,
RTAREA_FIRE_TEMPLE,
RTAREA_WATER_TEMPLE,
RTAREA_SPIRIT_TEMPLE,
RTAREA_SHADOW_TEMPLE,
RTAREA_BOTTOM_OF_THE_WELL,
RTAREA_ICE_CAVERN,
RTAREA_GERUDO_TRAINING_GROUND,
RTAREA_GANONS_CASTLE,
RTAREA_INVALID
} RandomizerTrickArea;
typedef enum {
RTVORMQ_VANILLA,
RTVORMQ_MQ,
RTVORMQ_BOTH
} RandomizerTrickVanillaOrMQ;
typedef enum {
RTTAG_NOVICE,
RTTAG_INTERMEDIATE,
RTTAG_ADVANCED,
RTTAG_EXPERT,
RTTAG_EXTREME,
/*RTTAG_LENS,
RTTAG_BKSKIP
RTTAG_EXPERIMENTAL*/
} RandomizerTrickTag;
//todo tags
#define RT_OBJECT(rt, rt_v_or_mq, rt_area, rt_tags, rt_glitch, rt_shortname, rt_desc) \
{ rt, {rt, rt_v_or_mq, rt_area, rt_tags, rt_glitch, true, rt_shortname, rt_desc} }
typedef struct {
RandomizerTrick rt;
RandomizerTrickVanillaOrMQ vOrMQ;
RandomizerTrickArea rtArea;
std::vector<RandomizerTrickTag> *rtTags;
bool rtGlitch;
bool visibleInImgui;
std::string rtShortName;
std::string rtDesc;
} RandomizerTrickObject;
namespace RandomizerTricks {
std::unordered_map<RandomizerTrick, RandomizerTrickObject> GetAllRTObjects();
std::unordered_map<RandomizerTrickArea, std::unordered_map<RandomizerTrick,RandomizerTrickObject>> GetAllRTObjectsByArea();
std::string GetRTAreaName(RandomizerTrickArea area);
std::string GetRTTagName(RandomizerTrickTag tag);
std::string GetRTName(RandomizerTrick trick);
ImVec4 GetRTAreaColor(RandomizerTrickArea area);
ImVec4 GetRTTagColor(RandomizerTrickTag tag);
bool CheckRTTags(std::unordered_map<RandomizerTrickTag, bool> &showTag, const std::vector<RandomizerTrickTag> &rtTags);
}