mirror of
https://github.com/ArchipelagoMW/Archipelago.git
synced 2026-03-30 08:23:26 -07:00
1586 lines
86 KiB
Python
1586 lines
86 KiB
Python
from typing import Dict, FrozenSet, Tuple, TYPE_CHECKING
|
|
from worlds.generic.Rules import set_rule, add_rule, forbid_item
|
|
from .options import IceGrappling, LadderStorage, CombatLogic
|
|
from .rules import (has_ability, has_sword, has_melee, has_ice_grapple_logic, has_lantern, has_mask, can_ladder_storage,
|
|
laurels_zip)
|
|
from .er_data import Portal
|
|
from .ladder_storage_data import ow_ladder_groups, region_ladders, easy_ls, medium_ls, hard_ls
|
|
from .combat_logic import has_combat_reqs
|
|
from BaseClasses import Region, CollectionState
|
|
|
|
if TYPE_CHECKING:
|
|
from . import TunicWorld
|
|
|
|
laurels = "Hero's Laurels"
|
|
grapple = "Magic Orb"
|
|
ice_dagger = "Magic Dagger"
|
|
fire_wand = "Magic Wand"
|
|
lantern = "Lantern"
|
|
fairies = "Fairy"
|
|
coins = "Golden Coin"
|
|
prayer = "Pages 24-25 (Prayer)"
|
|
holy_cross = "Pages 42-43 (Holy Cross)"
|
|
icebolt = "Pages 52-53 (Icebolt)"
|
|
key = "Key"
|
|
house_key = "Old House Key"
|
|
vault_key = "Fortress Vault Key"
|
|
mask = "Scavenger Mask"
|
|
red_hexagon = "Red Questagon"
|
|
green_hexagon = "Green Questagon"
|
|
blue_hexagon = "Blue Questagon"
|
|
gold_hexagon = "Gold Questagon"
|
|
|
|
|
|
def has_ladder(ladder: str, state: CollectionState, world: "TunicWorld") -> bool:
|
|
return not world.options.shuffle_ladders or state.has(ladder, world.player)
|
|
|
|
|
|
def set_er_region_rules(world: "TunicWorld", regions: Dict[str, Region], portal_pairs: Dict[Portal, Portal]) -> None:
|
|
player = world.player
|
|
options = world.options
|
|
|
|
# input scene destination tag, returns portal's name and paired portal's region
|
|
def get_portal_info(portal_sd: str) -> Tuple[str, str]:
|
|
for portal1, portal2 in portal_pairs.items():
|
|
if portal1.scene_destination() == portal_sd:
|
|
return portal1.name, portal2.region
|
|
if portal2.scene_destination() == portal_sd:
|
|
return portal2.name, portal1.region
|
|
raise Exception("no matches found in get_portal_info")
|
|
|
|
# input scene destination tag, returns paired portal's name and region
|
|
def get_paired_portal(portal_sd: str) -> Tuple[str, str]:
|
|
for portal1, portal2 in portal_pairs.items():
|
|
if portal1.scene_destination() == portal_sd:
|
|
return portal2.name, portal2.region
|
|
if portal2.scene_destination() == portal_sd:
|
|
return portal1.name, portal1.region
|
|
raise Exception("no matches found in get_paired_portal")
|
|
|
|
regions["Menu"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
# Overworld
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Holy Cross"],
|
|
rule=lambda state: has_ability(holy_cross, state, world))
|
|
|
|
# grapple on the west side, down the stairs from moss wall, across from ruined shop
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Beach"],
|
|
rule=lambda state: has_ladder("Ladders in Overworld Town", state, world)
|
|
or state.has_any({laurels, grapple}, player))
|
|
# regions["Overworld Beach"].connect(
|
|
# connecting_region=regions["Overworld"],
|
|
# rule=lambda state: has_ladder("Ladders in Overworld Town", state, world)
|
|
# or state.has_any({laurels, grapple}, player))
|
|
|
|
# region for combat logic, no need to connect it to beach since it would be the same as the ow -> beach cxn
|
|
ow_tunnel_beach = regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Tunnel to Beach"])
|
|
|
|
regions["Overworld Beach"].connect(
|
|
connecting_region=regions["Overworld Tunnel to Beach"],
|
|
rule=lambda state: state.has(laurels, player) or has_ladder("Ladders in Overworld Town", state, world))
|
|
|
|
regions["Overworld Beach"].connect(
|
|
connecting_region=regions["Overworld West Garden Laurels Entry"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Overworld West Garden Laurels Entry"].connect(
|
|
connecting_region=regions["Overworld Beach"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Overworld Beach"].connect(
|
|
connecting_region=regions["Overworld to Atoll Upper"],
|
|
rule=lambda state: has_ladder("Ladder to Ruined Atoll", state, world))
|
|
regions["Overworld to Atoll Upper"].connect(
|
|
connecting_region=regions["Overworld Beach"],
|
|
rule=lambda state: has_ladder("Ladder to Ruined Atoll", state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld to Atoll Upper"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Overworld to Atoll Upper"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: state.has_any({laurels, grapple}, player))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Belltower"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
regions["Overworld Belltower"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
# ice grapple rudeling across rubble, drop bridge, ice grapple rudeling down
|
|
regions["Overworld Belltower"].connect(
|
|
connecting_region=regions["Overworld to West Garden Upper"],
|
|
rule=lambda state: has_ladder("Ladders to West Bell", state, world)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
regions["Overworld to West Garden Upper"].connect(
|
|
connecting_region=regions["Overworld Belltower"],
|
|
rule=lambda state: has_ladder("Ladders to West Bell", state, world))
|
|
|
|
regions["Overworld Belltower"].connect(
|
|
connecting_region=regions["Overworld Belltower at Bell"],
|
|
rule=lambda state: has_ladder("Ladders to West Bell", state, world))
|
|
|
|
# long dong, do not make a reverse connection here or to belltower, maybe readd later
|
|
# regions["Overworld above Patrol Cave"].connect(
|
|
# connecting_region=regions["Overworld Belltower at Bell"],
|
|
# rule=lambda state: options.logic_rules and state.has(fire_wand, player))
|
|
|
|
# can laurels through the ruined passage door at either corner
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Ruined Passage Door"],
|
|
rule=lambda state: state.has(key, player, 2)
|
|
or laurels_zip(state, world))
|
|
regions["Overworld Ruined Passage Door"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: laurels_zip(state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["After Ruined Passage"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["After Ruined Passage"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Above Ruined Passage"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world)
|
|
or state.has(laurels, player))
|
|
regions["Above Ruined Passage"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world)
|
|
or state.has(laurels, player))
|
|
|
|
regions["After Ruined Passage"].connect(
|
|
connecting_region=regions["Above Ruined Passage"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world))
|
|
regions["Above Ruined Passage"].connect(
|
|
connecting_region=regions["After Ruined Passage"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world))
|
|
|
|
regions["Above Ruined Passage"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["Above Ruined Passage"],
|
|
rule=lambda state: has_ladder("Ladders near Weathervane", state, world)
|
|
or state.has(laurels, player))
|
|
|
|
# nmg: ice grapple the slimes, works both ways consistently
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["After Ruined Passage"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["After Ruined Passage"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world))
|
|
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["Overworld at Patrol Cave"])
|
|
regions["Overworld at Patrol Cave"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Overworld at Patrol Cave"].connect(
|
|
connecting_region=regions["Overworld above Patrol Cave"],
|
|
rule=lambda state: has_ladder("Ladders near Patrol Cave", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Overworld above Patrol Cave"].connect(
|
|
connecting_region=regions["Overworld at Patrol Cave"],
|
|
rule=lambda state: has_ladder("Ladders near Patrol Cave", state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld above Patrol Cave"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world)
|
|
or state.has(grapple, player))
|
|
regions["Overworld above Patrol Cave"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world))
|
|
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["Overworld above Patrol Cave"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Overworld above Patrol Cave"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Overworld Checkpoint", state, world))
|
|
|
|
regions["Overworld above Patrol Cave"].connect(
|
|
connecting_region=regions["Upper Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Patrol Cave", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Upper Overworld"].connect(
|
|
connecting_region=regions["Overworld above Patrol Cave"],
|
|
rule=lambda state: has_ladder("Ladders near Patrol Cave", state, world)
|
|
or state.has(grapple, player))
|
|
|
|
regions["Upper Overworld"].connect(
|
|
connecting_region=regions["Overworld above Quarry Entrance"],
|
|
rule=lambda state: state.has_any({grapple, laurels}, player))
|
|
regions["Overworld above Quarry Entrance"].connect(
|
|
connecting_region=regions["Upper Overworld"],
|
|
rule=lambda state: state.has_any({grapple, laurels}, player))
|
|
|
|
regions["Upper Overworld"].connect(
|
|
connecting_region=regions["Overworld after Temple Rafters"],
|
|
rule=lambda state: has_ladder("Ladder near Temple Rafters", state, world))
|
|
regions["Overworld after Temple Rafters"].connect(
|
|
connecting_region=regions["Upper Overworld"],
|
|
rule=lambda state: has_ladder("Ladder near Temple Rafters", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Overworld above Quarry Entrance"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladders near Dark Tomb", state, world))
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld above Quarry Entrance"],
|
|
rule=lambda state: has_ladder("Ladders near Dark Tomb", state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld after Envoy"],
|
|
rule=lambda state: state.has_any({laurels, grapple}, player)
|
|
or state.has("Sword Upgrade", player, 4))
|
|
regions["Overworld after Envoy"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: state.has_any({laurels, grapple}, player)
|
|
or state.has("Sword Upgrade", player, 4))
|
|
|
|
regions["Overworld after Envoy"].connect(
|
|
connecting_region=regions["Overworld Quarry Entry"],
|
|
rule=lambda state: has_ladder("Ladder to Quarry", state, world))
|
|
regions["Overworld Quarry Entry"].connect(
|
|
connecting_region=regions["Overworld after Envoy"],
|
|
rule=lambda state: has_ladder("Ladder to Quarry", state, world))
|
|
|
|
# ice grapple through the gate
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Quarry Entry"],
|
|
rule=lambda state: has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
regions["Overworld Quarry Entry"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ice_grapple_logic(False, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Swamp Upper Entry"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Overworld Swamp Upper Entry"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Swamp Lower Entry"],
|
|
rule=lambda state: has_ladder("Ladder to Swamp", state, world)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
regions["Overworld Swamp Lower Entry"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ladder("Ladder to Swamp", state, world))
|
|
|
|
regions["East Overworld"].connect(
|
|
connecting_region=regions["Overworld Special Shop Entry"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Overworld Special Shop Entry"].connect(
|
|
connecting_region=regions["East Overworld"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
# region made for combat logic
|
|
ow_to_well_entry = regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Well Entry Area"])
|
|
regions["Overworld Well Entry Area"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
regions["Overworld Well Entry Area"].connect(
|
|
connecting_region=regions["Overworld Well Ladder"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world))
|
|
regions["Overworld Well Ladder"].connect(
|
|
connecting_region=regions["Overworld Well Entry Area"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world))
|
|
|
|
# nmg: can ice grapple through the door
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Old House Door"],
|
|
rule=lambda state: state.has(house_key, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
|
|
# lure enemy over and ice grapple through
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Southeast Cross Door"],
|
|
rule=lambda state: has_ability(holy_cross, state, world)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
regions["Overworld Southeast Cross Door"].connect(
|
|
connecting_region=regions["Overworld"],
|
|
rule=lambda state: has_ability(holy_cross, state, world))
|
|
|
|
# not including ice grapple through this because we're not including it on the other door
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Fountain Cross Door"],
|
|
rule=lambda state: has_ability(holy_cross, state, world)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
regions["Overworld Fountain Cross Door"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Town Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Overworld Town Portal"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Spawn Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Overworld Spawn Portal"].connect(
|
|
connecting_region=regions["Overworld"])
|
|
|
|
# nmg: ice grapple through temple door
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Temple Door"],
|
|
rule=lambda state: state.has_all({"Ring Eastern Bell", "Ring Western Bell"}, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
|
|
regions["Overworld Temple Door"].connect(
|
|
connecting_region=regions["Overworld above Patrol Cave"],
|
|
rule=lambda state: state.has(grapple, player))
|
|
|
|
regions["Overworld Tunnel Turret"].connect(
|
|
connecting_region=regions["Overworld Beach"],
|
|
rule=lambda state: has_ladder("Ladders in Overworld Town", state, world)
|
|
or state.has(grapple, player))
|
|
regions["Overworld Beach"].connect(
|
|
connecting_region=regions["Overworld Tunnel Turret"],
|
|
rule=lambda state: has_ladder("Ladders in Overworld Town", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
# don't need the ice grapple rule since you can go from ow -> beach -> tunnel
|
|
regions["Overworld"].connect(
|
|
connecting_region=regions["Overworld Tunnel Turret"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
# regions["Overworld Tunnel Turret"].connect(
|
|
# connecting_region=regions["Overworld"],
|
|
# rule=lambda state: state.has_any({grapple, laurels}, player))
|
|
|
|
# Overworld side areas
|
|
regions["Old House Front"].connect(
|
|
connecting_region=regions["Old House Back"])
|
|
# laurels through the gate, use left wall to space yourself
|
|
regions["Old House Back"].connect(
|
|
connecting_region=regions["Old House Front"],
|
|
rule=lambda state: laurels_zip(state, world))
|
|
|
|
regions["Sealed Temple"].connect(
|
|
connecting_region=regions["Sealed Temple Rafters"])
|
|
regions["Sealed Temple Rafters"].connect(
|
|
connecting_region=regions["Sealed Temple"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Furnace Walking Path"].connect(
|
|
connecting_region=regions["Furnace Ladder Area"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Furnace Ladder Area"].connect(
|
|
connecting_region=regions["Furnace Walking Path"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Furnace Walking Path"].connect(
|
|
connecting_region=regions["Furnace Fuse"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Furnace Fuse"].connect(
|
|
connecting_region=regions["Furnace Walking Path"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Furnace Fuse"].connect(
|
|
connecting_region=regions["Furnace Ladder Area"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Furnace Ladder Area"].connect(
|
|
connecting_region=regions["Furnace Fuse"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Hourglass Cave"].connect(
|
|
connecting_region=regions["Hourglass Cave Tower"],
|
|
rule=lambda state: has_ladder("Ladders in Hourglass Cave", state, world))
|
|
|
|
# East Forest
|
|
regions["Forest Belltower Upper"].connect(
|
|
connecting_region=regions["Forest Belltower Main"])
|
|
|
|
regions["Forest Belltower Main"].connect(
|
|
connecting_region=regions["Forest Belltower Lower"],
|
|
rule=lambda state: has_ladder("Ladder to East Forest", state, world))
|
|
|
|
# nmg: ice grapple up to dance fox spot, and vice versa
|
|
regions["East Forest"].connect(
|
|
connecting_region=regions["East Forest Dance Fox Spot"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["East Forest Dance Fox Spot"].connect(
|
|
connecting_region=regions["East Forest"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["East Forest"].connect(
|
|
connecting_region=regions["East Forest Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["East Forest Portal"].connect(
|
|
connecting_region=regions["East Forest"])
|
|
|
|
regions["East Forest"].connect(
|
|
connecting_region=regions["Lower Forest"],
|
|
rule=lambda state: has_ladder("Ladders to Lower Forest", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Lower Forest"].connect(
|
|
connecting_region=regions["East Forest"],
|
|
rule=lambda state: has_ladder("Ladders to Lower Forest", state, world))
|
|
|
|
regions["Guard House 1 East"].connect(
|
|
connecting_region=regions["Guard House 1 West"])
|
|
regions["Guard House 1 West"].connect(
|
|
connecting_region=regions["Guard House 1 East"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Guard House 2 Upper"].connect(
|
|
connecting_region=regions["Guard House 2 Lower"],
|
|
rule=lambda state: has_ladder("Ladders to Lower Forest", state, world))
|
|
regions["Guard House 2 Lower"].connect(
|
|
connecting_region=regions["Guard House 2 Upper"],
|
|
rule=lambda state: has_ladder("Ladders to Lower Forest", state, world))
|
|
|
|
# nmg: ice grapple from upper grave path exit to the rest of it
|
|
regions["Forest Grave Path Upper"].connect(
|
|
connecting_region=regions["Forest Grave Path Main"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Forest Grave Path Main"].connect(
|
|
connecting_region=regions["Forest Grave Path Upper"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Forest Grave Path Main"].connect(
|
|
connecting_region=regions["Forest Grave Path by Grave"])
|
|
# nmg: ice grapple or laurels through the gate
|
|
regions["Forest Grave Path by Grave"].connect(
|
|
connecting_region=regions["Forest Grave Path Main"],
|
|
rule=lambda state: has_ice_grapple_logic(False, IceGrappling.option_easy, state, world)
|
|
or laurels_zip(state, world))
|
|
|
|
regions["Forest Grave Path by Grave"].connect(
|
|
connecting_region=regions["Forest Hero's Grave"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Forest Hero's Grave"].connect(
|
|
connecting_region=regions["Forest Grave Path by Grave"])
|
|
|
|
# Beneath the Well and Dark Tomb
|
|
regions["Beneath the Well Ladder Exit"].connect(
|
|
connecting_region=regions["Beneath the Well Front"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world))
|
|
regions["Beneath the Well Front"].connect(
|
|
connecting_region=regions["Beneath the Well Ladder Exit"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world))
|
|
|
|
btw_front_main = regions["Beneath the Well Front"].connect(
|
|
connecting_region=regions["Beneath the Well Main"],
|
|
rule=lambda state: has_melee(state, player) or state.has(fire_wand, player))
|
|
regions["Beneath the Well Main"].connect(
|
|
connecting_region=regions["Beneath the Well Front"])
|
|
|
|
regions["Beneath the Well Main"].connect(
|
|
connecting_region=regions["Beneath the Well Back"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world))
|
|
btw_back_main = regions["Beneath the Well Back"].connect(
|
|
connecting_region=regions["Beneath the Well Main"],
|
|
rule=lambda state: has_ladder("Ladders in Well", state, world)
|
|
and (has_melee(state, player) or state.has(fire_wand, player)))
|
|
|
|
regions["Well Boss"].connect(
|
|
connecting_region=regions["Dark Tomb Checkpoint"])
|
|
# can laurels through the gate, no setup needed
|
|
regions["Dark Tomb Checkpoint"].connect(
|
|
connecting_region=regions["Well Boss"],
|
|
rule=lambda state: laurels_zip(state, world))
|
|
|
|
dt_entry_to_upper = regions["Dark Tomb Entry Point"].connect(
|
|
connecting_region=regions["Dark Tomb Upper"],
|
|
rule=lambda state: has_lantern(state, world))
|
|
regions["Dark Tomb Upper"].connect(
|
|
connecting_region=regions["Dark Tomb Entry Point"])
|
|
|
|
regions["Dark Tomb Upper"].connect(
|
|
connecting_region=regions["Dark Tomb Main"],
|
|
rule=lambda state: has_ladder("Ladder in Dark Tomb", state, world))
|
|
regions["Dark Tomb Main"].connect(
|
|
connecting_region=regions["Dark Tomb Upper"],
|
|
rule=lambda state: has_ladder("Ladder in Dark Tomb", state, world))
|
|
|
|
regions["Dark Tomb Main"].connect(
|
|
connecting_region=regions["Dark Tomb Dark Exit"])
|
|
dt_exit_to_main = regions["Dark Tomb Dark Exit"].connect(
|
|
connecting_region=regions["Dark Tomb Main"],
|
|
rule=lambda state: has_lantern(state, world))
|
|
|
|
# West Garden
|
|
# combat logic regions
|
|
wg_before_to_after_terry = regions["West Garden before Terry"].connect(
|
|
connecting_region=regions["West Garden after Terry"])
|
|
wg_after_to_before_terry = regions["West Garden after Terry"].connect(
|
|
connecting_region=regions["West Garden before Terry"])
|
|
|
|
regions["West Garden after Terry"].connect(
|
|
connecting_region=regions["West Garden South Checkpoint"])
|
|
wg_checkpoint_to_after_terry = regions["West Garden South Checkpoint"].connect(
|
|
connecting_region=regions["West Garden after Terry"])
|
|
|
|
wg_checkpoint_to_dagger = regions["West Garden South Checkpoint"].connect(
|
|
connecting_region=regions["West Garden at Dagger House"])
|
|
regions["West Garden at Dagger House"].connect(
|
|
connecting_region=regions["West Garden South Checkpoint"])
|
|
|
|
wg_checkpoint_to_before_boss = regions["West Garden South Checkpoint"].connect(
|
|
connecting_region=regions["West Garden before Boss"])
|
|
regions["West Garden before Boss"].connect(
|
|
connecting_region=regions["West Garden South Checkpoint"])
|
|
|
|
regions["West Garden Laurels Exit Region"].connect(
|
|
connecting_region=regions["West Garden at Dagger House"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["West Garden at Dagger House"].connect(
|
|
connecting_region=regions["West Garden Laurels Exit Region"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["West Garden after Boss"].connect(
|
|
connecting_region=regions["West Garden before Boss"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
wg_to_after_gk = regions["West Garden before Boss"].connect(
|
|
connecting_region=regions["West Garden after Boss"],
|
|
rule=lambda state: state.has(laurels, player) or has_sword(state, player))
|
|
|
|
regions["West Garden before Terry"].connect(
|
|
connecting_region=regions["West Garden Hero's Grave Region"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["West Garden Hero's Grave Region"].connect(
|
|
connecting_region=regions["West Garden before Terry"])
|
|
|
|
regions["West Garden Portal"].connect(
|
|
connecting_region=regions["West Garden Portal Item"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["West Garden Portal Item"].connect(
|
|
connecting_region=regions["West Garden Portal"],
|
|
rule=lambda state: state.has(laurels, player) and has_ability(prayer, state, world))
|
|
|
|
# can ice grapple to and from the item behind the magic dagger house
|
|
regions["West Garden Portal Item"].connect(
|
|
connecting_region=regions["West Garden at Dagger House"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["West Garden at Dagger House"].connect(
|
|
connecting_region=regions["West Garden Portal Item"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_medium, state, world))
|
|
|
|
# Atoll and Frog's Domain
|
|
# nmg: ice grapple the bird below the portal
|
|
regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Lower Entry Area"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
regions["Ruined Atoll Lower Entry Area"].connect(
|
|
connecting_region=regions["Ruined Atoll"],
|
|
rule=lambda state: state.has(laurels, player) or state.has(grapple, player))
|
|
|
|
regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Ladder Tops"],
|
|
rule=lambda state: has_ladder("Ladders in South Atoll", state, world))
|
|
|
|
regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Frog Mouth"],
|
|
rule=lambda state: state.has(laurels, player) or state.has(grapple, player))
|
|
regions["Ruined Atoll Frog Mouth"].connect(
|
|
connecting_region=regions["Ruined Atoll"],
|
|
rule=lambda state: state.has(laurels, player) or state.has(grapple, player))
|
|
|
|
regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Frog Eye"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
regions["Ruined Atoll Frog Eye"].connect(
|
|
connecting_region=regions["Ruined Atoll"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
|
|
regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Ruined Atoll Portal"].connect(
|
|
connecting_region=regions["Ruined Atoll"])
|
|
|
|
atoll_statue = regions["Ruined Atoll"].connect(
|
|
connecting_region=regions["Ruined Atoll Statue"],
|
|
rule=lambda state: has_ability(prayer, state, world)
|
|
and (has_ladder("Ladders in South Atoll", state, world)
|
|
# shoot fuse and have the shot hit you mid-LS
|
|
or (can_ladder_storage(state, world) and state.has(fire_wand, player)
|
|
and options.ladder_storage >= LadderStorage.option_hard)))
|
|
regions["Ruined Atoll Statue"].connect(
|
|
connecting_region=regions["Ruined Atoll"])
|
|
|
|
regions["Frog Stairs Eye Exit"].connect(
|
|
connecting_region=regions["Frog Stairs Upper"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
regions["Frog Stairs Upper"].connect(
|
|
connecting_region=regions["Frog Stairs Eye Exit"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
|
|
regions["Frog Stairs Upper"].connect(
|
|
connecting_region=regions["Frog Stairs Lower"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
regions["Frog Stairs Lower"].connect(
|
|
connecting_region=regions["Frog Stairs Upper"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
|
|
regions["Frog Stairs Lower"].connect(
|
|
connecting_region=regions["Frog Stairs to Frog's Domain"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
regions["Frog Stairs to Frog's Domain"].connect(
|
|
connecting_region=regions["Frog Stairs Lower"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
|
|
regions["Frog's Domain Entry"].connect(
|
|
connecting_region=regions["Frog's Domain"],
|
|
rule=lambda state: has_ladder("Ladders to Frog's Domain", state, world))
|
|
|
|
regions["Frog's Domain"].connect(
|
|
connecting_region=regions["Frog's Domain Back"],
|
|
rule=lambda state: state.has(grapple, player))
|
|
|
|
# Library
|
|
regions["Library Exterior Tree Region"].connect(
|
|
connecting_region=regions["Library Exterior Ladder Region"],
|
|
rule=lambda state: state.has_any({grapple, laurels}, player)
|
|
and has_ladder("Ladders in Library", state, world))
|
|
regions["Library Exterior Ladder Region"].connect(
|
|
connecting_region=regions["Library Exterior Tree Region"],
|
|
rule=lambda state: has_ability(prayer, state, world)
|
|
and ((state.has(laurels, player) and has_ladder("Ladders in Library", state, world))
|
|
or state.has(grapple, player)))
|
|
|
|
regions["Library Hall Bookshelf"].connect(
|
|
connecting_region=regions["Library Hall"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
regions["Library Hall"].connect(
|
|
connecting_region=regions["Library Hall Bookshelf"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
|
|
regions["Library Hall"].connect(
|
|
connecting_region=regions["Library Hero's Grave Region"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Library Hero's Grave Region"].connect(
|
|
connecting_region=regions["Library Hall"])
|
|
|
|
regions["Library Hall to Rotunda"].connect(
|
|
connecting_region=regions["Library Hall"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
regions["Library Hall"].connect(
|
|
connecting_region=regions["Library Hall to Rotunda"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
|
|
regions["Library Rotunda to Hall"].connect(
|
|
connecting_region=regions["Library Rotunda"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
regions["Library Rotunda"].connect(
|
|
connecting_region=regions["Library Rotunda to Hall"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
|
|
regions["Library Rotunda"].connect(
|
|
connecting_region=regions["Library Rotunda to Lab"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
regions["Library Rotunda to Lab"].connect(
|
|
connecting_region=regions["Library Rotunda"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
|
|
regions["Library Lab Lower"].connect(
|
|
connecting_region=regions["Library Lab"],
|
|
rule=lambda state: state.has_any({grapple, laurels}, player)
|
|
and has_ladder("Ladders in Library", state, world))
|
|
regions["Library Lab"].connect(
|
|
connecting_region=regions["Library Lab Lower"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
and has_ladder("Ladders in Library", state, world))
|
|
|
|
regions["Library Lab"].connect(
|
|
connecting_region=regions["Library Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world)
|
|
and has_ladder("Ladders in Library", state, world))
|
|
regions["Library Portal"].connect(
|
|
connecting_region=regions["Library Lab"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world)
|
|
or state.has(laurels, player))
|
|
|
|
regions["Library Lab"].connect(
|
|
connecting_region=regions["Library Lab to Librarian"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
regions["Library Lab to Librarian"].connect(
|
|
connecting_region=regions["Library Lab"],
|
|
rule=lambda state: has_ladder("Ladders in Library", state, world))
|
|
|
|
# Eastern Vault Fortress
|
|
regions["Fortress Exterior from East Forest"].connect(
|
|
connecting_region=regions["Fortress Exterior from Overworld"],
|
|
rule=lambda state: state.has(laurels, player) or state.has(grapple, player))
|
|
regions["Fortress Exterior from Overworld"].connect(
|
|
connecting_region=regions["Fortress Exterior from East Forest"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Fortress Exterior near cave"].connect(
|
|
connecting_region=regions["Fortress Exterior from Overworld"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Fortress Exterior from Overworld"].connect(
|
|
connecting_region=regions["Fortress Exterior near cave"],
|
|
rule=lambda state: state.has(laurels, player) or has_ability(prayer, state, world))
|
|
|
|
# shoot far fire pot, enemy gets aggro'd
|
|
regions["Fortress Exterior near cave"].connect(
|
|
connecting_region=regions["Fortress Courtyard"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_hard, state, world))
|
|
|
|
regions["Fortress Exterior near cave"].connect(
|
|
connecting_region=regions["Beneath the Vault Entry"],
|
|
rule=lambda state: has_ladder("Ladder to Beneath the Vault", state, world))
|
|
regions["Beneath the Vault Entry"].connect(
|
|
connecting_region=regions["Fortress Exterior near cave"],
|
|
rule=lambda state: has_ladder("Ladder to Beneath the Vault", state, world))
|
|
|
|
regions["Fortress Courtyard"].connect(
|
|
connecting_region=regions["Fortress Exterior from Overworld"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
# nmg: can ice grapple an enemy in the courtyard
|
|
regions["Fortress Exterior from Overworld"].connect(
|
|
connecting_region=regions["Fortress Courtyard"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Fortress Courtyard Upper"].connect(
|
|
connecting_region=regions["Fortress Courtyard"])
|
|
# nmg: can ice grapple to the upper ledge
|
|
regions["Fortress Courtyard"].connect(
|
|
connecting_region=regions["Fortress Courtyard Upper"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Fortress Courtyard Upper"].connect(
|
|
connecting_region=regions["Fortress Exterior from Overworld"])
|
|
|
|
regions["Beneath the Vault Ladder Exit"].connect(
|
|
connecting_region=regions["Beneath the Vault Main"],
|
|
rule=lambda state: has_ladder("Ladder to Beneath the Vault", state, world)
|
|
and has_lantern(state, world))
|
|
regions["Beneath the Vault Main"].connect(
|
|
connecting_region=regions["Beneath the Vault Ladder Exit"],
|
|
rule=lambda state: has_ladder("Ladder to Beneath the Vault", state, world))
|
|
|
|
regions["Beneath the Vault Main"].connect(
|
|
connecting_region=regions["Beneath the Vault Back"])
|
|
regions["Beneath the Vault Back"].connect(
|
|
connecting_region=regions["Beneath the Vault Main"],
|
|
rule=lambda state: has_lantern(state, world))
|
|
|
|
regions["Fortress East Shortcut Upper"].connect(
|
|
connecting_region=regions["Fortress East Shortcut Lower"])
|
|
# nmg: can ice grapple upwards
|
|
regions["Fortress East Shortcut Lower"].connect(
|
|
connecting_region=regions["Fortress East Shortcut Upper"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
# nmg: ice grapple through the big gold door, can do it both ways
|
|
regions["Eastern Vault Fortress"].connect(
|
|
connecting_region=regions["Eastern Vault Fortress Gold Door"],
|
|
rule=lambda state: state.has_all({"Activate Eastern Vault West Fuses",
|
|
"Activate Eastern Vault East Fuse"}, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
regions["Eastern Vault Fortress Gold Door"].connect(
|
|
connecting_region=regions["Eastern Vault Fortress"],
|
|
rule=lambda state: has_ice_grapple_logic(False, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Fortress Grave Path"].connect(
|
|
connecting_region=regions["Fortress Grave Path Dusty Entrance Region"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Fortress Grave Path Dusty Entrance Region"].connect(
|
|
connecting_region=regions["Fortress Grave Path"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Fortress Grave Path"].connect(
|
|
connecting_region=regions["Fortress Hero's Grave Region"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Fortress Hero's Grave Region"].connect(
|
|
connecting_region=regions["Fortress Grave Path"])
|
|
|
|
# nmg: ice grapple from upper grave path to lower
|
|
regions["Fortress Grave Path Upper"].connect(
|
|
connecting_region=regions["Fortress Grave Path"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Fortress Arena"].connect(
|
|
connecting_region=regions["Fortress Arena Portal"],
|
|
rule=lambda state: state.has("Activate Eastern Vault West Fuses", player))
|
|
regions["Fortress Arena Portal"].connect(
|
|
connecting_region=regions["Fortress Arena"])
|
|
|
|
# Quarry
|
|
regions["Lower Mountain"].connect(
|
|
connecting_region=regions["Lower Mountain Stairs"],
|
|
rule=lambda state: has_ability(holy_cross, state, world))
|
|
regions["Lower Mountain Stairs"].connect(
|
|
connecting_region=regions["Lower Mountain"],
|
|
rule=lambda state: has_ability(holy_cross, state, world))
|
|
|
|
regions["Quarry Entry"].connect(
|
|
connecting_region=regions["Quarry Portal"],
|
|
rule=lambda state: state.has("Activate Quarry Fuse", player))
|
|
regions["Quarry Portal"].connect(
|
|
connecting_region=regions["Quarry Entry"])
|
|
|
|
regions["Quarry Entry"].connect(
|
|
connecting_region=regions["Quarry"],
|
|
rule=lambda state: state.has(fire_wand, player) or has_sword(state, player))
|
|
regions["Quarry"].connect(
|
|
connecting_region=regions["Quarry Entry"])
|
|
|
|
regions["Quarry Back"].connect(
|
|
connecting_region=regions["Quarry"],
|
|
rule=lambda state: state.has(fire_wand, player) or has_sword(state, player))
|
|
regions["Quarry"].connect(
|
|
connecting_region=regions["Quarry Back"])
|
|
|
|
regions["Quarry Monastery Entry"].connect(
|
|
connecting_region=regions["Quarry"],
|
|
rule=lambda state: state.has(fire_wand, player) or has_sword(state, player))
|
|
regions["Quarry"].connect(
|
|
connecting_region=regions["Quarry Monastery Entry"])
|
|
|
|
regions["Quarry Monastery Entry"].connect(
|
|
connecting_region=regions["Quarry Back"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Quarry Back"].connect(
|
|
connecting_region=regions["Quarry Monastery Entry"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Monastery Rope"].connect(
|
|
connecting_region=regions["Quarry Back"])
|
|
|
|
regions["Quarry"].connect(
|
|
connecting_region=regions["Lower Quarry"],
|
|
rule=lambda state: has_mask(state, world))
|
|
|
|
# need the ladder, or you can ice grapple down in nmg
|
|
regions["Lower Quarry"].connect(
|
|
connecting_region=regions["Even Lower Quarry"],
|
|
rule=lambda state: has_ladder("Ladders in Lower Quarry", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
# nmg: bring a scav over, then ice grapple through the door, only with ER on to avoid soft lock
|
|
regions["Even Lower Quarry"].connect(
|
|
connecting_region=regions["Lower Quarry Zig Door"],
|
|
rule=lambda state: state.has("Activate Quarry Fuse", player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
|
|
# nmg: use ice grapple to get from the beginning of Quarry to the door without really needing mask only with ER on
|
|
regions["Quarry"].connect(
|
|
connecting_region=regions["Lower Quarry Zig Door"],
|
|
rule=lambda state: has_ice_grapple_logic(True, IceGrappling.option_hard, state, world))
|
|
|
|
regions["Monastery Front"].connect(
|
|
connecting_region=regions["Monastery Back"])
|
|
# laurels through the gate, no setup needed
|
|
regions["Monastery Back"].connect(
|
|
connecting_region=regions["Monastery Front"],
|
|
rule=lambda state: laurels_zip(state, world))
|
|
|
|
regions["Monastery Back"].connect(
|
|
connecting_region=regions["Monastery Hero's Grave Region"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Monastery Hero's Grave Region"].connect(
|
|
connecting_region=regions["Monastery Back"])
|
|
|
|
# Ziggurat
|
|
regions["Rooted Ziggurat Upper Entry"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Upper Front"])
|
|
|
|
regions["Rooted Ziggurat Upper Front"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Upper Back"],
|
|
rule=lambda state: state.has(laurels, player) or has_sword(state, player))
|
|
regions["Rooted Ziggurat Upper Back"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Upper Front"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Rooted Ziggurat Middle Top"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Middle Bottom"])
|
|
|
|
regions["Rooted Ziggurat Lower Front"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Lower Back"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
or (has_sword(state, player) and has_ability(prayer, state, world)))
|
|
# nmg: can ice grapple on the voidlings to the double admin fight, still need to pray at the fuse
|
|
regions["Rooted Ziggurat Lower Back"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Lower Front"],
|
|
rule=lambda state: (state.has(laurels, player)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
and has_ability(prayer, state, world)
|
|
and has_sword(state, player))
|
|
|
|
regions["Rooted Ziggurat Lower Back"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Portal Room Entrance"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Rooted Ziggurat Portal Room Entrance"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Lower Back"])
|
|
|
|
regions["Zig Skip Exit"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Lower Front"])
|
|
|
|
regions["Rooted Ziggurat Portal"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Portal Room Exit"],
|
|
rule=lambda state: state.has("Activate Ziggurat Fuse", player))
|
|
regions["Rooted Ziggurat Portal Room Exit"].connect(
|
|
connecting_region=regions["Rooted Ziggurat Portal"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
|
|
# Swamp and Cathedral
|
|
regions["Swamp Front"].connect(
|
|
connecting_region=regions["Swamp Mid"],
|
|
rule=lambda state: has_ladder("Ladders in Swamp", state, world)
|
|
or state.has(laurels, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
regions["Swamp Mid"].connect(
|
|
connecting_region=regions["Swamp Front"],
|
|
rule=lambda state: has_ladder("Ladders in Swamp", state, world)
|
|
or state.has(laurels, player)
|
|
or has_ice_grapple_logic(False, IceGrappling.option_hard, state, world))
|
|
|
|
swamp_mid_to_cath = regions["Swamp Mid"].connect(
|
|
connecting_region=regions["Swamp to Cathedral Main Entrance Region"],
|
|
rule=lambda state: (has_ability(prayer, state, world)
|
|
and (state.has(laurels, player)
|
|
# blam yourself in the face with a wand shot off the fuse
|
|
or (can_ladder_storage(state, world) and state.has(fire_wand, player)
|
|
and options.ladder_storage >= LadderStorage.option_hard
|
|
and (not options.shuffle_ladders
|
|
or state.has_any({"Ladders in Overworld Town",
|
|
"Ladder to Swamp",
|
|
"Ladders near Weathervane"}, player)
|
|
or (state.has("Ladder to Ruined Atoll", player)
|
|
and state.can_reach_region("Overworld Beach", player)))))
|
|
and (not options.combat_logic
|
|
or has_combat_reqs("Swamp", state, player)))
|
|
or has_ice_grapple_logic(False, IceGrappling.option_medium, state, world))
|
|
|
|
if options.ladder_storage >= LadderStorage.option_hard and options.shuffle_ladders:
|
|
world.multiworld.register_indirect_condition(regions["Overworld Beach"], swamp_mid_to_cath)
|
|
|
|
regions["Swamp to Cathedral Main Entrance Region"].connect(
|
|
connecting_region=regions["Swamp Mid"],
|
|
rule=lambda state: has_ice_grapple_logic(False, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Swamp Mid"].connect(
|
|
connecting_region=regions["Swamp Ledge under Cathedral Door"],
|
|
rule=lambda state: has_ladder("Ladders in Swamp", state, world))
|
|
# ice grapple enemy standing at the door
|
|
regions["Swamp Ledge under Cathedral Door"].connect(
|
|
connecting_region=regions["Swamp Mid"],
|
|
rule=lambda state: has_ladder("Ladders in Swamp", state, world)
|
|
or has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Swamp Ledge under Cathedral Door"].connect(
|
|
connecting_region=regions["Swamp to Cathedral Treasure Room"],
|
|
rule=lambda state: has_ability(holy_cross, state, world))
|
|
regions["Swamp to Cathedral Treasure Room"].connect(
|
|
connecting_region=regions["Swamp Ledge under Cathedral Door"])
|
|
|
|
regions["Back of Swamp"].connect(
|
|
connecting_region=regions["Back of Swamp Laurels Area"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Back of Swamp Laurels Area"].connect(
|
|
connecting_region=regions["Back of Swamp"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
# nmg: can ice grapple down while you're on the pillars
|
|
regions["Back of Swamp Laurels Area"].connect(
|
|
connecting_region=regions["Swamp Mid"],
|
|
rule=lambda state: state.has(laurels, player)
|
|
and has_ice_grapple_logic(True, IceGrappling.option_easy, state, world))
|
|
|
|
regions["Back of Swamp"].connect(
|
|
connecting_region=regions["Swamp Hero's Grave Region"],
|
|
rule=lambda state: has_ability(prayer, state, world))
|
|
regions["Swamp Hero's Grave Region"].connect(
|
|
connecting_region=regions["Back of Swamp"])
|
|
|
|
regions["Cathedral Gauntlet Checkpoint"].connect(
|
|
connecting_region=regions["Cathedral Gauntlet"])
|
|
|
|
regions["Cathedral Gauntlet"].connect(
|
|
connecting_region=regions["Cathedral Gauntlet Exit"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Cathedral Gauntlet Exit"].connect(
|
|
connecting_region=regions["Cathedral Gauntlet"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
# Far Shore
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to Spawn Region"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Far Shore to Spawn Region"].connect(
|
|
connecting_region=regions["Far Shore"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to East Forest Region"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
regions["Far Shore to East Forest Region"].connect(
|
|
connecting_region=regions["Far Shore"],
|
|
rule=lambda state: state.has(laurels, player))
|
|
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to West Garden Region"],
|
|
rule=lambda state: state.has("Activate West Garden Fuse", player))
|
|
regions["Far Shore to West Garden Region"].connect(
|
|
connecting_region=regions["Far Shore"])
|
|
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to Quarry Region"],
|
|
rule=lambda state: state.has("Activate Quarry Fuse", player))
|
|
regions["Far Shore to Quarry Region"].connect(
|
|
connecting_region=regions["Far Shore"])
|
|
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to Fortress Region"],
|
|
rule=lambda state: state.has("Activate Eastern Vault West Fuses", player))
|
|
regions["Far Shore to Fortress Region"].connect(
|
|
connecting_region=regions["Far Shore"])
|
|
|
|
regions["Far Shore"].connect(
|
|
connecting_region=regions["Far Shore to Library Region"],
|
|
rule=lambda state: state.has("Activate Library Fuse", player))
|
|
regions["Far Shore to Library Region"].connect(
|
|
connecting_region=regions["Far Shore"])
|
|
|
|
# Misc
|
|
heir_fight = regions["Spirit Arena"].connect(
|
|
connecting_region=regions["Spirit Arena Victory"],
|
|
rule=lambda state: (state.has(gold_hexagon, player, world.options.hexagon_goal.value) if
|
|
world.options.hexagon_quest else
|
|
(state.has_all({red_hexagon, green_hexagon, blue_hexagon, "Unseal the Heir"}, player)
|
|
and state.has_group_unique("Hero Relics", player, 6)
|
|
and has_sword(state, player))))
|
|
|
|
if options.ladder_storage:
|
|
# connect ls elevation regions to their destinations
|
|
def ls_connect(origin_name: str, portal_sdt: str) -> None:
|
|
p_name, paired_region_name = get_portal_info(portal_sdt)
|
|
ladder_regions[origin_name].connect(
|
|
regions[paired_region_name],
|
|
name=p_name + " (LS) " + origin_name)
|
|
|
|
# get what non-overworld ladder storage connections we want together
|
|
non_ow_ls_list = []
|
|
non_ow_ls_list.extend(easy_ls)
|
|
if options.ladder_storage >= LadderStorage.option_medium:
|
|
non_ow_ls_list.extend(medium_ls)
|
|
if options.ladder_storage >= LadderStorage.option_hard:
|
|
non_ow_ls_list.extend(hard_ls)
|
|
|
|
# create the ls elevation regions
|
|
ladder_regions: Dict[str, Region] = {}
|
|
for name in ow_ladder_groups.keys():
|
|
ladder_regions[name] = Region(name, player, world.multiworld)
|
|
|
|
# connect the ls elevations to each other where applicable
|
|
if options.ladder_storage >= LadderStorage.option_medium:
|
|
for i in range(len(ow_ladder_groups) - 1):
|
|
ladder_regions[f"LS Elev {i}"].connect(ladder_regions[f"LS Elev {i + 1}"])
|
|
|
|
# connect the applicable overworld regions to the ls elevation regions
|
|
for origin_region, ladders in region_ladders.items():
|
|
for ladder_region, region_info in ow_ladder_groups.items():
|
|
# checking if that region has a ladder or ladders for that elevation
|
|
common_ladders: FrozenSet[str] = frozenset(ladders.intersection(region_info.ladders))
|
|
if common_ladders:
|
|
if options.shuffle_ladders:
|
|
regions[origin_region].connect(
|
|
connecting_region=ladder_regions[ladder_region],
|
|
rule=lambda state, lads=common_ladders: state.has_any(lads, player)
|
|
and can_ladder_storage(state, world))
|
|
else:
|
|
regions[origin_region].connect(
|
|
connecting_region=ladder_regions[ladder_region],
|
|
rule=lambda state: can_ladder_storage(state, world))
|
|
|
|
# connect ls elevation regions to the region on the other side of the portals
|
|
for ladder_region, region_info in ow_ladder_groups.items():
|
|
for portal_dest in region_info.portals:
|
|
ls_connect(ladder_region, "Overworld Redux, " + portal_dest)
|
|
|
|
# connect ls elevation regions to regions where you can get an enemy to knock you down, also well rail
|
|
if options.ladder_storage >= LadderStorage.option_medium:
|
|
for ladder_region, region_info in ow_ladder_groups.items():
|
|
for dest_region in region_info.regions:
|
|
ladder_regions[ladder_region].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=ladder_region + " (LS) " + dest_region)
|
|
# well rail, need height off portal pad for one side, and a tiny extra from stairs on the other
|
|
ls_connect("LS Elev 3", "Overworld Redux, Sewer_west_aqueduct")
|
|
ls_connect("LS Elev 3", "Overworld Redux, Furnace_gyro_upper_north")
|
|
|
|
# connect ls elevation regions to portals where you need to get behind the map to enter it
|
|
if options.ladder_storage >= LadderStorage.option_hard:
|
|
ls_connect("LS Elev 1", "Overworld Redux, EastFiligreeCache_")
|
|
ls_connect("LS Elev 2", "Overworld Redux, Town_FiligreeRoom_")
|
|
ls_connect("LS Elev 3", "Overworld Redux, Overworld Interiors_house")
|
|
ls_connect("LS Elev 5", "Overworld Redux, Temple_main")
|
|
|
|
# connect the non-overworld ones
|
|
for ls_info in non_ow_ls_list:
|
|
# for places where the destination is a region (so you have to get knocked down)
|
|
if ls_info.dest_is_region:
|
|
# none of the non-ow ones have multiple ladders that can be used, so don't need has_any
|
|
if options.shuffle_ladders and ls_info.ladders_req:
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[ls_info.destination],
|
|
name=ls_info.destination + " (LS) " + ls_info.origin,
|
|
rule=lambda state, lad=ls_info.ladders_req: can_ladder_storage(state, world)
|
|
and state.has(lad, player))
|
|
else:
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[ls_info.destination],
|
|
name=ls_info.destination + " (LS) " + ls_info.origin,
|
|
rule=lambda state: can_ladder_storage(state, world))
|
|
continue
|
|
|
|
portal_name, dest_region = get_portal_info(ls_info.destination)
|
|
# these two are special cases
|
|
if ls_info.destination == "Atoll Redux, Frog Stairs_mouth":
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=portal_name + " (LS) " + ls_info.origin,
|
|
rule=lambda state: can_ladder_storage(state, world)
|
|
and (state.has("Ladders in South Atoll", player)
|
|
or not options.shuffle_ladders # if ladder shuffle is off, don't gotta worry about ladders
|
|
or state.has(key, player, 2) # can do it from the rope
|
|
or options.ladder_storage >= LadderStorage.option_medium)) # use the little ladder
|
|
# holy cross mid-ls to get in here
|
|
elif ls_info.destination == "Swamp Redux 2, Cathedral Redux_secret":
|
|
if ls_info.origin == "Swamp Mid":
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=portal_name + " (LS) " + ls_info.origin,
|
|
rule=lambda state: can_ladder_storage(state, world) and has_ability(holy_cross, state, world)
|
|
and (state.has("Ladders in Swamp", player) or not options.shuffle_ladders))
|
|
else:
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=portal_name + " (LS) " + ls_info.origin,
|
|
rule=lambda state: can_ladder_storage(state, world) and has_ability(holy_cross, state, world))
|
|
|
|
elif options.shuffle_ladders and ls_info.ladders_req:
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=portal_name + " (LS) " + ls_info.origin,
|
|
rule=lambda state, lad=ls_info.ladders_req: can_ladder_storage(state, world)
|
|
and state.has(lad, player))
|
|
else:
|
|
regions[ls_info.origin].connect(
|
|
connecting_region=regions[dest_region],
|
|
name=portal_name + " (LS) " + ls_info.origin,
|
|
rule=lambda state: can_ladder_storage(state, world))
|
|
|
|
for region in ladder_regions.values():
|
|
world.multiworld.regions.append(region)
|
|
|
|
# for combat logic, easiest to replace or add to existing rules
|
|
if world.options.combat_logic >= CombatLogic.option_bosses_only:
|
|
set_rule(wg_to_after_gk,
|
|
lambda state: state.has(laurels, player)
|
|
or has_combat_reqs("Garden Knight", state, player))
|
|
if not world.options.hexagon_quest:
|
|
add_rule(heir_fight,
|
|
lambda state: has_combat_reqs("The Heir", state, player))
|
|
|
|
if world.options.combat_logic == CombatLogic.option_on:
|
|
# need to fight through the rudelings and turret, or just laurels from near the windmill
|
|
set_rule(ow_to_well_entry,
|
|
lambda state: state.has(laurels, player)
|
|
or has_combat_reqs("East Forest", state, player))
|
|
set_rule(ow_tunnel_beach,
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(atoll_statue,
|
|
lambda state: has_combat_reqs("Ruined Atoll", state, player))
|
|
set_rule(btw_front_main,
|
|
lambda state: state.has(laurels, player) or has_combat_reqs("Beneath the Well", state, player))
|
|
set_rule(btw_back_main,
|
|
lambda state: has_ladder("Ladders in Well", state, world)
|
|
and (state.has(laurels, player) or has_combat_reqs("Beneath the Well", state, player)))
|
|
add_rule(dt_entry_to_upper,
|
|
lambda state: has_combat_reqs("Dark Tomb", state, player))
|
|
add_rule(dt_exit_to_main,
|
|
lambda state: has_combat_reqs("Dark Tomb", state, player))
|
|
|
|
set_rule(wg_before_to_after_terry,
|
|
lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player))
|
|
set_rule(wg_after_to_before_terry,
|
|
lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player))
|
|
# laurels through, probably to the checkpoint, or just fight
|
|
set_rule(wg_checkpoint_to_after_terry,
|
|
lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player))
|
|
set_rule(wg_checkpoint_to_before_boss,
|
|
lambda state: has_combat_reqs("West Garden", state, player))
|
|
|
|
# for spots where you can go into and come out of an entrance to reset enemy aggro
|
|
if world.options.entrance_rando:
|
|
dagger_entry_paired_name, dagger_entry_paired_region = get_paired_portal("Archipelagos Redux, Archipelagos_house_")
|
|
set_rule(wg_checkpoint_to_dagger,
|
|
lambda state: state.has(laurels, player) or has_combat_reqs("West Garden", state, player)
|
|
or state.can_reach_entrance(dagger_entry_paired_name, player))
|
|
world.multiworld.register_indirect_condition(regions["West Garden at Dagger House"], dagger_entry_paired_region)
|
|
|
|
|
|
def set_er_location_rules(world: "TunicWorld") -> None:
|
|
player = world.player
|
|
multiworld = world.multiworld
|
|
|
|
forbid_item(multiworld.get_location("Secret Gathering Place - 20 Fairy Reward", player), fairies, player)
|
|
|
|
# Ability Shuffle Exclusive Rules
|
|
set_rule(multiworld.get_location("East Forest - Dancing Fox Spirit Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Forest Grave Path - Holy Cross Code by Grave", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("East Forest - Golden Obelisk Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Beneath the Well - [Powered Secret Room] Chest", player),
|
|
lambda state: state.has("Activate Furnace Fuse", player))
|
|
set_rule(multiworld.get_location("West Garden - [North] Behind Holy Cross Door", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Library Hall - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Eastern Vault Fortress - [West Wing] Candles Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("West Garden - [Central Highlands] Holy Cross (Blue Lines)", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Quarry - [Back Entrance] Bushes Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Cathedral - Secret Legend Trophy Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] Flowers Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [East] Weathervane Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [Northeast] Flowers Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] Haiku Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [Northwest] Golden Obelisk Page", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
|
|
# Overworld
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] Grapple Chest Over Walkway", player),
|
|
lambda state: state.has_any({grapple, laurels}, player))
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] West Beach Guarded By Turret 2", player),
|
|
lambda state: state.has_any({grapple, laurels}, player))
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] From West Garden", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Overworld - [Southeast] Page on Pillar by Swamp", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Overworld - [Southwest] Fountain Page", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Overworld - [Northwest] Page on Pillar by Dark Tomb", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Old House - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Overworld - [East] Grapple Chest", player),
|
|
lambda state: state.has(grapple, player))
|
|
set_rule(multiworld.get_location("Sealed Temple - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Caustic Light Cave - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Cube Cave - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Old House - Holy Cross Door Page", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Maze Cave - Maze Room Holy Cross", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Old House - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Patrol Cave - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Ruined Passage - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Hourglass Cave - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Secret Gathering Place - Holy Cross Chest", player),
|
|
lambda state: has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("Secret Gathering Place - 10 Fairy Reward", player),
|
|
lambda state: state.has(fairies, player, 10))
|
|
set_rule(multiworld.get_location("Secret Gathering Place - 20 Fairy Reward", player),
|
|
lambda state: state.has(fairies, player, 20))
|
|
set_rule(multiworld.get_location("Coins in the Well - 3 Coins", player),
|
|
lambda state: state.has(coins, player, 3))
|
|
set_rule(multiworld.get_location("Coins in the Well - 6 Coins", player),
|
|
lambda state: state.has(coins, player, 6))
|
|
set_rule(multiworld.get_location("Coins in the Well - 10 Coins", player),
|
|
lambda state: state.has(coins, player, 10))
|
|
set_rule(multiworld.get_location("Coins in the Well - 15 Coins", player),
|
|
lambda state: state.has(coins, player, 15))
|
|
|
|
# East Forest
|
|
set_rule(multiworld.get_location("East Forest - Lower Grapple Chest", player),
|
|
lambda state: state.has(grapple, player))
|
|
set_rule(multiworld.get_location("East Forest - Lower Dash Chest", player),
|
|
lambda state: state.has_all({grapple, laurels}, player))
|
|
set_rule(multiworld.get_location("East Forest - Ice Rod Grapple Chest", player), lambda state: (
|
|
state.has_all({grapple, ice_dagger, fire_wand}, player) and has_ability(icebolt, state, world)))
|
|
|
|
# Dark Tomb
|
|
# added to make combat logic smoother
|
|
set_rule(multiworld.get_location("Dark Tomb - 2nd Laser Room", player),
|
|
lambda state: has_lantern(state, world))
|
|
|
|
# West Garden
|
|
set_rule(multiworld.get_location("West Garden - [North] Across From Page Pickup", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("West Garden - [West] In Flooded Walkway", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("West Garden - [West Lowlands] Tree Holy Cross Chest", player),
|
|
lambda state: state.has(laurels, player) and has_ability(holy_cross, state, world))
|
|
set_rule(multiworld.get_location("West Garden - [East Lowlands] Page Behind Ice Dagger House", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("West Garden - [Central Lowlands] Below Left Walkway", player),
|
|
lambda state: state.has(laurels, player))
|
|
|
|
# Ruined Atoll
|
|
set_rule(multiworld.get_location("Ruined Atoll - [West] Near Kevin Block", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Ruined Atoll - [East] Locked Room Lower Chest", player),
|
|
lambda state: state.has(laurels, player) or state.has(key, player, 2))
|
|
set_rule(multiworld.get_location("Ruined Atoll - [East] Locked Room Upper Chest", player),
|
|
lambda state: state.has(laurels, player) or state.has(key, player, 2))
|
|
|
|
# Frog's Domain
|
|
set_rule(multiworld.get_location("Frog's Domain - Side Room Grapple Secret", player),
|
|
lambda state: state.has_any({grapple, laurels}, player))
|
|
set_rule(multiworld.get_location("Frog's Domain - Grapple Above Hot Tub", player),
|
|
lambda state: state.has_any({grapple, laurels}, player))
|
|
set_rule(multiworld.get_location("Frog's Domain - Escape Chest", player),
|
|
lambda state: state.has_any({grapple, laurels}, player))
|
|
|
|
# Eastern Vault Fortress
|
|
set_rule(multiworld.get_location("Fortress Arena - Hexagon Red", player),
|
|
lambda state: state.has(vault_key, player))
|
|
|
|
# Beneath the Vault
|
|
set_rule(multiworld.get_location("Beneath the Fortress - Bridge", player),
|
|
lambda state: state.has_group("Melee Weapons", player, 1) or state.has_any({laurels, fire_wand}, player))
|
|
|
|
# Quarry
|
|
set_rule(multiworld.get_location("Quarry - [Central] Above Ladder Dash Chest", player),
|
|
lambda state: state.has(laurels, player))
|
|
|
|
# Ziggurat
|
|
# if ER is off, while you can get the chest, you won't be able to actually get through zig
|
|
set_rule(multiworld.get_location("Rooted Ziggurat Upper - Near Bridge Switch", player),
|
|
lambda state: has_sword(state, player) or (state.has(fire_wand, player)
|
|
and (state.has(laurels, player)
|
|
or world.options.entrance_rando)))
|
|
set_rule(multiworld.get_location("Rooted Ziggurat Lower - After Guarded Fuse", player),
|
|
lambda state: has_sword(state, player) and has_ability(prayer, state, world))
|
|
|
|
# Bosses
|
|
set_rule(multiworld.get_location("Fortress Arena - Siege Engine/Vault Key Pickup", player),
|
|
lambda state: has_sword(state, player))
|
|
set_rule(multiworld.get_location("Librarian - Hexagon Green", player),
|
|
lambda state: (has_sword(state, player))
|
|
and has_ladder("Ladders in Library", state, world))
|
|
set_rule(multiworld.get_location("Rooted Ziggurat Lower - Hexagon Blue", player),
|
|
lambda state: has_sword(state, player))
|
|
|
|
# Swamp
|
|
set_rule(multiworld.get_location("Cathedral Gauntlet - Gauntlet Reward", player),
|
|
lambda state: state.has(fire_wand, player) and has_sword(state, player))
|
|
set_rule(multiworld.get_location("Swamp - [Entrance] Above Entryway", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Swamp - [South Graveyard] Upper Walkway Dash Chest", player),
|
|
lambda state: state.has(laurels, player))
|
|
# really hard to do 4 skulls with a big skeleton chasing you around
|
|
set_rule(multiworld.get_location("Swamp - [South Graveyard] 4 Orange Skulls", player),
|
|
lambda state: has_sword(state, player))
|
|
|
|
# Hero's Grave and Far Shore
|
|
set_rule(multiworld.get_location("Hero's Grave - Tooth Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Hero's Grave - Mushroom Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Hero's Grave - Ash Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Hero's Grave - Flowers Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Hero's Grave - Effigy Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Hero's Grave - Feathers Relic", player),
|
|
lambda state: state.has(laurels, player))
|
|
set_rule(multiworld.get_location("Far Shore - Secret Chest", player),
|
|
lambda state: state.has(laurels, player))
|
|
|
|
# Events
|
|
set_rule(multiworld.get_location("Eastern Bell", player),
|
|
lambda state: (has_melee(state, player) or state.has(fire_wand, player)))
|
|
set_rule(multiworld.get_location("Western Bell", player),
|
|
lambda state: (has_melee(state, player) or state.has(fire_wand, player)))
|
|
set_rule(multiworld.get_location("Furnace Fuse", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
set_rule(multiworld.get_location("South and West Fortress Exterior Fuses", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
set_rule(multiworld.get_location("Upper and Central Fortress Exterior Fuses", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
set_rule(multiworld.get_location("Beneath the Vault Fuse", player),
|
|
lambda state: state.has("Activate South and West Fortress Exterior Fuses", player))
|
|
set_rule(multiworld.get_location("Eastern Vault West Fuses", player),
|
|
lambda state: state.has("Activate Beneath the Vault Fuse", player))
|
|
set_rule(multiworld.get_location("Eastern Vault East Fuse", player),
|
|
lambda state: state.has_all({"Activate Upper and Central Fortress Exterior Fuses",
|
|
"Activate South and West Fortress Exterior Fuses"}, player))
|
|
set_rule(multiworld.get_location("Quarry Connector Fuse", player),
|
|
lambda state: has_ability(prayer, state, world) and state.has(grapple, player))
|
|
set_rule(multiworld.get_location("Quarry Fuse", player),
|
|
lambda state: state.has("Activate Quarry Connector Fuse", player))
|
|
set_rule(multiworld.get_location("Ziggurat Fuse", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
set_rule(multiworld.get_location("West Garden Fuse", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
set_rule(multiworld.get_location("Library Fuse", player),
|
|
lambda state: has_ability(prayer, state, world))
|
|
|
|
# Shop
|
|
set_rule(multiworld.get_location("Shop - Potion 1", player),
|
|
lambda state: has_sword(state, player))
|
|
set_rule(multiworld.get_location("Shop - Potion 2", player),
|
|
lambda state: has_sword(state, player))
|
|
set_rule(multiworld.get_location("Shop - Coin 1", player),
|
|
lambda state: has_sword(state, player))
|
|
set_rule(multiworld.get_location("Shop - Coin 2", player),
|
|
lambda state: has_sword(state, player))
|
|
|
|
if world.options.combat_logic >= CombatLogic.option_bosses_only:
|
|
# garden knight is in the regions part above
|
|
set_rule(multiworld.get_location("Fortress Arena - Siege Engine/Vault Key Pickup", player),
|
|
lambda state: has_combat_reqs("Siege Engine", state, player))
|
|
set_rule(multiworld.get_location("Librarian - Hexagon Green", player),
|
|
lambda state: has_combat_reqs("The Librarian", state, player))
|
|
set_rule(multiworld.get_location("Rooted Ziggurat Lower - Hexagon Blue", player),
|
|
lambda state: has_combat_reqs("Boss Scavenger", state, player))
|
|
set_rule(multiworld.get_location("Cathedral Gauntlet - Gauntlet Reward", player),
|
|
lambda state: has_combat_reqs("Gauntlet", state, player))
|
|
|
|
# todo: come back add add dagger to checks that can be reasonably done with dagger
|
|
if world.options.combat_logic == CombatLogic.option_on:
|
|
add_rule(multiworld.get_location("Overworld - [Northeast] Flowers Holy Cross", player),
|
|
lambda state: has_combat_reqs("Garden Knight", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Northwest] Chest Near Quarry Gate", player),
|
|
lambda state: has_combat_reqs("Before Well", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Northeast] Chest Above Patrol Cave", player),
|
|
lambda state: has_combat_reqs("Garden Knight", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] West Beach Guarded By Turret", player),
|
|
lambda state: has_combat_reqs("Overworld", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] West Beach Guarded By Turret 2", player),
|
|
lambda state: has_combat_reqs("Overworld", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] Bombable Wall Near Fountain", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] Bombable Wall Near Fountain", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] Fountain Holy Cross", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] South Chest Near Guard", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Southwest] Tunnel Guarded By Turret", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Overworld - [Northwest] Chest Near Turret", player),
|
|
lambda state: has_combat_reqs("Before Well", state, player))
|
|
|
|
add_rule(multiworld.get_location("Hourglass Cave - Hourglass Chest", player),
|
|
lambda state: has_sword(state, player) and (state.has("Shield", player)
|
|
# kill the turrets through the wall with a longer sword
|
|
or state.has("Sword Upgrade", player, 3)))
|
|
add_rule(multiworld.get_location("Hourglass Cave - Holy Cross Chest", player),
|
|
lambda state: has_sword(state, player) and (state.has("Shield", player)
|
|
or state.has("Sword Upgrade", player, 3)))
|
|
|
|
# the first spider chest they literally do not attack you until you open the chest
|
|
# the second one, you can still just walk past them, but I guess /something/ would be wanted
|
|
add_rule(multiworld.get_location("East Forest - Beneath Spider Chest", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("East Forest - Golden Obelisk Holy Cross", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("East Forest - Dancing Fox Spirit Holy Cross", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("East Forest - From Guardhouse 1 Chest", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("East Forest - Above Save Point", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("East Forest - Above Save Point Obscured", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Forest Grave Path - Above Gate", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
add_rule(multiworld.get_location("Forest Grave Path - Obscured Chest", player),
|
|
lambda state: has_combat_reqs("East Forest", state, player))
|
|
|
|
# most of beneath the well is covered by the region access rule
|
|
add_rule(multiworld.get_location("Beneath the Well - [Entryway] Chest", player),
|
|
lambda state: has_combat_reqs("Beneath the Well", state, player))
|
|
add_rule(multiworld.get_location("Beneath the Well - [Entryway] Obscured Behind Waterfall", player),
|
|
lambda state: has_combat_reqs("Beneath the Well", state, player))
|
|
add_rule(multiworld.get_location("Beneath the Well - [Back Corridor] Left Secret", player),
|
|
lambda state: has_combat_reqs("Beneath the Well", state, player))
|
|
add_rule(multiworld.get_location("Beneath the Well - [Side Room] Chest By Phrends", player),
|
|
lambda state: has_combat_reqs("Overworld", state, player))
|
|
|
|
# laurels past the enemies, then use the wand or gun to take care of the fairies that chased you
|
|
add_rule(multiworld.get_location("West Garden - [West Lowlands] Tree Holy Cross Chest", player),
|
|
lambda state: state.has_any({fire_wand, "Gun"}, player))
|
|
add_rule(multiworld.get_location("West Garden - [Central Lowlands] Chest Beneath Faeries", player),
|
|
lambda state: has_combat_reqs("West Garden", state, player))
|
|
add_rule(multiworld.get_location("West Garden - [Central Lowlands] Chest Beneath Save Point", player),
|
|
lambda state: has_combat_reqs("West Garden", state, player))
|
|
add_rule(multiworld.get_location("West Garden - [West Highlands] Upper Left Walkway", player),
|
|
lambda state: has_combat_reqs("West Garden", state, player))
|
|
|
|
# could add it to the other fuse events but that's just wasteful imo
|
|
add_rule(multiworld.get_location("Eastern Vault West Fuses", player),
|
|
lambda state: has_combat_reqs("Eastern Vault Fortress", state, player))
|
|
add_rule(multiworld.get_location("Eastern Vault East Fuse", player),
|
|
lambda state: has_combat_reqs("Eastern Vault Fortress", state, player))
|
|
|
|
# replace the sword rule with this one
|
|
set_rule(multiworld.get_location("Swamp - [South Graveyard] 4 Orange Skulls", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [South Graveyard] Above Big Skeleton", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
# the tentacles deal with everything else reasonably, so you just have to fight them
|
|
# todo: revisit, should it be fine since this is a knowledge check (get on island to stop tentacles)
|
|
set_rule(multiworld.get_location("Swamp - [South Graveyard] Guarded By Tentacles", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [South Graveyard] Obscured Beneath Telescope", player),
|
|
lambda state: state.has(laurels, player) # can dash from swamp mid to here and grab it
|
|
or has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Central] South Secret Passage", player),
|
|
lambda state: state.has(laurels, player) # can dash from swamp front to here and grab it
|
|
or has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [South Graveyard] Upper Walkway On Pedestal", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Central] Beneath Memorial", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Central] Near Ramps Up", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Upper Graveyard] Near Telescope", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Upper Graveyard] Near Shield Fleemers", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|
|
add_rule(multiworld.get_location("Swamp - [Upper Graveyard] Obscured Behind Hill", player),
|
|
lambda state: has_combat_reqs("Swamp", state, player))
|