mirror/Archipelago
1
0
Fork 1
mirror of https://github.com/ArchipelagoMW/Archipelago.git synced 2026-04-07 22:28:12 -07:00
Code Issues Packages Projects Releases Wiki Activity

Various Worlds: purge world: MultiWorld (#5973)

Browse Source
This commit is contained in:
Silvris
2026-04-07 15:13:31 -05:00
committed by GitHub
parent 36bab6f52a
commit 030cb4b578
33 changed files with 994 additions and 1020 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
worlds/adventure/Regions.py
View File

@@ -3,10 +3,10 @@ from Options import PerGameCommonOptions
from .Locations import location_table, AdventureLocation, dragon_room_to_region
def connect(world: MultiWorld, player: int, source: str, target: str, rule: callable = lambda state: True,
def connect(multiworld: MultiWorld, player: int, source: str, target: str, rule: callable = lambda state: True,
one_way=False, name=None):
source_region = world.get_region(source, player)
target_region = world.get_region(target, player)
source_region = multiworld.get_region(source, player)
target_region = multiworld.get_region(target, player)
if name is None:
name = source + " to " + target
@@ -22,7 +22,7 @@ def connect(world: MultiWorld, player: int, source: str, target: str, rule: call
source_region.exits.append(connection)
connection.connect(target_region)
if not one_way:
connect(world, player, target, source, rule, True)
connect(multiworld, player, target, source, rule, True)
def create_regions(options: PerGameCommonOptions, multiworld: MultiWorld, player: int, dragon_rooms: []) -> None:

50
worlds/adventure/Rules.py
View File

@@ -3,47 +3,47 @@ from worlds.generic.Rules import add_rule, set_rule, forbid_item
def set_rules(self) -> None:
world = self.multiworld
multiworld = self.multiworld
use_bat_logic = self.options.bat_logic.value == BatLogic.option_use_logic
set_rule(world.get_entrance("YellowCastlePort", self.player),
set_rule(multiworld.get_entrance("YellowCastlePort", self.player),
lambda state: state.has("Yellow Key", self.player))
set_rule(world.get_entrance("BlackCastlePort", self.player),
set_rule(multiworld.get_entrance("BlackCastlePort", self.player),
lambda state: state.has("Black Key", self.player))
set_rule(world.get_entrance("WhiteCastlePort", self.player),
set_rule(multiworld.get_entrance("WhiteCastlePort", self.player),
lambda state: state.has("White Key", self.player))
# a future thing would be to make the bat an actual item, or at least allow it to
# be placed in a castle, which would require some additions to the rules when
# use_bat_logic is true
if not use_bat_logic:
set_rule(world.get_entrance("WhiteCastleSecretPassage", self.player),
set_rule(multiworld.get_entrance("WhiteCastleSecretPassage", self.player),
lambda state: state.has("Bridge", self.player))
set_rule(world.get_entrance("WhiteCastlePeekPassage", self.player),
set_rule(multiworld.get_entrance("WhiteCastlePeekPassage", self.player),
lambda state: state.has("Bridge", self.player) or
state.has("Magnet", self.player))
set_rule(world.get_entrance("BlackCastleVaultEntrance", self.player),
set_rule(multiworld.get_entrance("BlackCastleVaultEntrance", self.player),
lambda state: state.has("Bridge", self.player) or
state.has("Magnet", self.player))
dragon_slay_check = self.options.dragon_slay_check.value
if dragon_slay_check:
if self.difficulty_switch_b == DifficultySwitchB.option_hard_with_unlock_item:
set_rule(world.get_location("Slay Yorgle", self.player),
set_rule(multiworld.get_location("Slay Yorgle", self.player),
lambda state: state.has("Sword", self.player) and
state.has("Right Difficulty Switch", self.player))
set_rule(world.get_location("Slay Grundle", self.player),
set_rule(multiworld.get_location("Slay Grundle", self.player),
lambda state: state.has("Sword", self.player) and
state.has("Right Difficulty Switch", self.player))
set_rule(world.get_location("Slay Rhindle", self.player),
set_rule(multiworld.get_location("Slay Rhindle", self.player),
lambda state: state.has("Sword", self.player) and
state.has("Right Difficulty Switch", self.player))
else:
set_rule(world.get_location("Slay Yorgle", self.player),
set_rule(multiworld.get_location("Slay Yorgle", self.player),
lambda state: state.has("Sword", self.player))
set_rule(world.get_location("Slay Grundle", self.player),
set_rule(multiworld.get_location("Slay Grundle", self.player),
lambda state: state.has("Sword", self.player))
set_rule(world.get_location("Slay Rhindle", self.player),
set_rule(multiworld.get_location("Slay Rhindle", self.player),
lambda state: state.has("Sword", self.player))
# really this requires getting the dot item, and having another item or enemy
@@ -51,37 +51,37 @@ def set_rules(self) -> None:
# to actually make randomized, since it is invisible. May add some options
# for how that works in the distant future, but for now, just say you need
# the bridge and black key to get to it, as that simplifies things a lot
set_rule(world.get_entrance("CreditsWall", self.player),
set_rule(multiworld.get_entrance("CreditsWall", self.player),
lambda state: state.has("Bridge", self.player) and
state.has("Black Key", self.player))
if not use_bat_logic:
set_rule(world.get_entrance("CreditsToFarSide", self.player),
set_rule(multiworld.get_entrance("CreditsToFarSide", self.player),
lambda state: state.has("Magnet", self.player))
# bridge literally does not fit in this space, I think. I'll just exclude it
forbid_item(world.get_location("Dungeon Vault", self.player), "Bridge", self.player)
forbid_item(multiworld.get_location("Dungeon Vault", self.player), "Bridge", self.player)
# don't put magnet in locations that can pull in-logic items out of reach unless the bat is in play
if not use_bat_logic:
forbid_item(world.get_location("Dungeon Vault", self.player), "Magnet", self.player)
forbid_item(world.get_location("Red Maze Vault Entrance", self.player), "Magnet", self.player)
forbid_item(world.get_location("Credits Right Side", self.player), "Magnet", self.player)
forbid_item(multiworld.get_location("Dungeon Vault", self.player), "Magnet", self.player)
forbid_item(multiworld.get_location("Red Maze Vault Entrance", self.player), "Magnet", self.player)
forbid_item(multiworld.get_location("Credits Right Side", self.player), "Magnet", self.player)
# and obviously we don't want to start with the game already won
forbid_item(world.get_location("Inside Yellow Castle", self.player), "Chalice", self.player)
overworld = world.get_region("Overworld", self.player)
forbid_item(multiworld.get_location("Inside Yellow Castle", self.player), "Chalice", self.player)
overworld = multiworld.get_region("Overworld", self.player)
for loc in overworld.locations:
forbid_item(loc, "Chalice", self.player)
add_rule(world.get_location("Chalice Home", self.player),
add_rule(multiworld.get_location("Chalice Home", self.player),
lambda state: state.has("Chalice", self.player) and state.has("Yellow Key", self.player))
# world.random.choice(overworld.locations).progress_type = LocationProgressType.PRIORITY
# multiworld.random.choice(overworld.locations).progress_type = LocationProgressType.PRIORITY
# all_locations = world.get_locations(self.player).copy()
# all_locations = multiworld.get_locations(self.player).copy()
# while priority_count < get_num_items():
# loc = world.random.choice(all_locations)
# loc = multiworld.random.choice(all_locations)
# if loc.progress_type == LocationProgressType.DEFAULT:
# loc.progress_type = LocationProgressType.PRIORITY
# priority_count += 1

4
worlds/adventure/__init__.py
View File

@@ -105,8 +105,8 @@ class AdventureWorld(World):
location_name_to_id: ClassVar[Dict[str, int]] = {name: data.location_id for name, data in location_table.items()}
required_client_version: Tuple[int, int, int] = (0, 3, 9)
def __init__(self, world: MultiWorld, player: int):
super().__init__(world, player)
def __init__(self, multiworld: MultiWorld, player: int):
super().__init__(multiworld, player)
self.rom_name: Optional[bytearray] = bytearray("", "utf8" )
self.dragon_rooms: [int] = [0x14, 0x19, 0x4]
self.dragon_slay_check: Optional[int] = 0

210
worlds/cccharles/Regions.py
View File

@@ -16,213 +16,213 @@ from .Locations import (
)
def create_regions(world: MultiWorld, options: CCCharlesOptions, player: int) -> None:
menu_region = Region("Menu", player, world, "Aranearum")
world.regions.append(menu_region)
def create_regions(multiworld: MultiWorld, options: CCCharlesOptions, player: int) -> None:
menu_region = Region("Menu", player, multiworld, "Aranearum")
multiworld.regions.append(menu_region)
start_camp_region = Region("Start Camp", player, world)
start_camp_region = Region("Start Camp", player, multiworld)
start_camp_region.add_locations(loc_start_camp, CCCharlesLocation)
world.regions.append(start_camp_region)
multiworld.regions.append(start_camp_region)
tony_tiddle_mission_region = Region("Tony Tiddle Mission", player, world)
tony_tiddle_mission_region = Region("Tony Tiddle Mission", player, multiworld)
tony_tiddle_mission_region.add_locations(loc_tony_tiddle_mission, CCCharlesLocation)
world.regions.append(tony_tiddle_mission_region)
multiworld.regions.append(tony_tiddle_mission_region)
barn_region = Region("Barn", player, world)
barn_region = Region("Barn", player, multiworld)
barn_region.add_locations(loc_barn, CCCharlesLocation)
world.regions.append(barn_region)
multiworld.regions.append(barn_region)
candice_mission_region = Region("Candice Mission", player, world)
candice_mission_region = Region("Candice Mission", player, multiworld)
candice_mission_region.add_locations(loc_candice_mission, CCCharlesLocation)
world.regions.append(candice_mission_region)
multiworld.regions.append(candice_mission_region)
tutorial_house_region = Region("Tutorial House", player, world)
tutorial_house_region = Region("Tutorial House", player, multiworld)
tutorial_house_region.add_locations(loc_tutorial_house, CCCharlesLocation)
world.regions.append(tutorial_house_region)
multiworld.regions.append(tutorial_house_region)
swamp_edges_region = Region("Swamp Edges", player, world)
swamp_edges_region = Region("Swamp Edges", player, multiworld)
swamp_edges_region.add_locations(loc_swamp_edges, CCCharlesLocation)
world.regions.append(swamp_edges_region)
multiworld.regions.append(swamp_edges_region)
swamp_mission_region = Region("Swamp Mission", player, world)
swamp_mission_region = Region("Swamp Mission", player, multiworld)
swamp_mission_region.add_locations(loc_swamp_mission, CCCharlesLocation)
world.regions.append(swamp_mission_region)
multiworld.regions.append(swamp_mission_region)
junkyard_area_region = Region("Junkyard Area", player, world)
junkyard_area_region = Region("Junkyard Area", player, multiworld)
junkyard_area_region.add_locations(loc_junkyard_area, CCCharlesLocation)
world.regions.append(junkyard_area_region)
multiworld.regions.append(junkyard_area_region)
south_house_region = Region("South House", player, world)
south_house_region = Region("South House", player, multiworld)
south_house_region.add_locations(loc_south_house, CCCharlesLocation)
world.regions.append(south_house_region)
multiworld.regions.append(south_house_region)
junkyard_shed_region = Region("Junkyard Shed", player, world)
junkyard_shed_region = Region("Junkyard Shed", player, multiworld)
junkyard_shed_region.add_locations(loc_junkyard_shed, CCCharlesLocation)
world.regions.append(junkyard_shed_region)
multiworld.regions.append(junkyard_shed_region)
military_base_region = Region("Military Base", player, world)
military_base_region = Region("Military Base", player, multiworld)
military_base_region.add_locations(loc_military_base, CCCharlesLocation)
world.regions.append(military_base_region)
multiworld.regions.append(military_base_region)
south_mine_outside_region = Region("South Mine Outside", player, world)
south_mine_outside_region = Region("South Mine Outside", player, multiworld)
south_mine_outside_region.add_locations(loc_south_mine_outside, CCCharlesLocation)
world.regions.append(south_mine_outside_region)
multiworld.regions.append(south_mine_outside_region)
south_mine_inside_region = Region("South Mine Inside", player, world)
south_mine_inside_region = Region("South Mine Inside", player, multiworld)
south_mine_inside_region.add_locations(loc_south_mine_inside, CCCharlesLocation)
world.regions.append(south_mine_inside_region)
multiworld.regions.append(south_mine_inside_region)
middle_station_region = Region("Middle Station", player, world)
middle_station_region = Region("Middle Station", player, multiworld)
middle_station_region.add_locations(loc_middle_station, CCCharlesLocation)
world.regions.append(middle_station_region)
multiworld.regions.append(middle_station_region)
canyon_region = Region("Canyon", player, world)
canyon_region = Region("Canyon", player, multiworld)
canyon_region.add_locations(loc_canyon, CCCharlesLocation)
world.regions.append(canyon_region)
multiworld.regions.append(canyon_region)
watchtower_region = Region("Watchtower", player, world)
watchtower_region = Region("Watchtower", player, multiworld)
watchtower_region.add_locations(loc_watchtower, CCCharlesLocation)
world.regions.append(watchtower_region)
multiworld.regions.append(watchtower_region)
boulder_field_region = Region("Boulder Field", player, world)
boulder_field_region = Region("Boulder Field", player, multiworld)
boulder_field_region.add_locations(loc_boulder_field, CCCharlesLocation)
world.regions.append(boulder_field_region)
multiworld.regions.append(boulder_field_region)
haunted_house_region = Region("Haunted House", player, world)
haunted_house_region = Region("Haunted House", player, multiworld)
haunted_house_region.add_locations(loc_haunted_house, CCCharlesLocation)
world.regions.append(haunted_house_region)
multiworld.regions.append(haunted_house_region)
santiago_house_region = Region("Santiago House", player, world)
santiago_house_region = Region("Santiago House", player, multiworld)
santiago_house_region.add_locations(loc_santiago_house, CCCharlesLocation)
world.regions.append(santiago_house_region)
multiworld.regions.append(santiago_house_region)
port_region = Region("Port", player, world)
port_region = Region("Port", player, multiworld)
port_region.add_locations(loc_port, CCCharlesLocation)
world.regions.append(port_region)
multiworld.regions.append(port_region)
trench_house_region = Region("Trench House", player, world)
trench_house_region = Region("Trench House", player, multiworld)
trench_house_region.add_locations(loc_trench_house, CCCharlesLocation)
world.regions.append(trench_house_region)
multiworld.regions.append(trench_house_region)
doll_woods_region = Region("Doll Woods", player, world)
doll_woods_region = Region("Doll Woods", player, multiworld)
doll_woods_region.add_locations(loc_doll_woods, CCCharlesLocation)
world.regions.append(doll_woods_region)
multiworld.regions.append(doll_woods_region)
lost_stairs_region = Region("Lost Stairs", player, world)
lost_stairs_region = Region("Lost Stairs", player, multiworld)
lost_stairs_region.add_locations(loc_lost_stairs, CCCharlesLocation)
world.regions.append(lost_stairs_region)
multiworld.regions.append(lost_stairs_region)
east_house_region = Region("East House", player, world)
east_house_region = Region("East House", player, multiworld)
east_house_region.add_locations(loc_east_house, CCCharlesLocation)
world.regions.append(east_house_region)
multiworld.regions.append(east_house_region)
rockets_testing_ground_region = Region("Rockets Testing Ground", player, world)
rockets_testing_ground_region = Region("Rockets Testing Ground", player, multiworld)
rockets_testing_ground_region.add_locations(loc_rockets_testing_ground, CCCharlesLocation)
world.regions.append(rockets_testing_ground_region)
multiworld.regions.append(rockets_testing_ground_region)
rockets_testing_bunker_region = Region("Rockets Testing Bunker", player, world)
rockets_testing_bunker_region = Region("Rockets Testing Bunker", player, multiworld)
rockets_testing_bunker_region.add_locations(loc_rockets_testing_bunker, CCCharlesLocation)
world.regions.append(rockets_testing_bunker_region)
multiworld.regions.append(rockets_testing_bunker_region)
workshop_region = Region("Workshop", player, world)
workshop_region = Region("Workshop", player, multiworld)
workshop_region.add_locations(loc_workshop, CCCharlesLocation)
world.regions.append(workshop_region)
multiworld.regions.append(workshop_region)
east_tower_region = Region("East Tower", player, world)
east_tower_region = Region("East Tower", player, multiworld)
east_tower_region.add_locations(loc_east_tower, CCCharlesLocation)
world.regions.append(east_tower_region)
multiworld.regions.append(east_tower_region)
lighthouse_region = Region("Lighthouse", player, world)
lighthouse_region = Region("Lighthouse", player, multiworld)
lighthouse_region.add_locations(loc_lighthouse, CCCharlesLocation)
world.regions.append(lighthouse_region)
multiworld.regions.append(lighthouse_region)
north_mine_outside_region = Region("North Mine Outside", player, world)
north_mine_outside_region = Region("North Mine Outside", player, multiworld)
north_mine_outside_region.add_locations(loc_north_mine_outside, CCCharlesLocation)
world.regions.append(north_mine_outside_region)
multiworld.regions.append(north_mine_outside_region)
north_mine_inside_region = Region("North Mine Inside", player, world)
north_mine_inside_region = Region("North Mine Inside", player, multiworld)
north_mine_inside_region.add_locations(loc_north_mine_inside, CCCharlesLocation)
world.regions.append(north_mine_inside_region)
multiworld.regions.append(north_mine_inside_region)
wood_bridge_region = Region("Wood Bridge", player, world)
wood_bridge_region = Region("Wood Bridge", player, multiworld)
wood_bridge_region.add_locations(loc_wood_bridge, CCCharlesLocation)
world.regions.append(wood_bridge_region)
multiworld.regions.append(wood_bridge_region)
museum_region = Region("Museum", player, world)
museum_region = Region("Museum", player, multiworld)
museum_region.add_locations(loc_museum, CCCharlesLocation)
world.regions.append(museum_region)
multiworld.regions.append(museum_region)
barbed_shelter_region = Region("Barbed Shelter", player, world)
barbed_shelter_region = Region("Barbed Shelter", player, multiworld)
barbed_shelter_region.add_locations(loc_barbed_shelter, CCCharlesLocation)
world.regions.append(barbed_shelter_region)
multiworld.regions.append(barbed_shelter_region)
west_beach_region = Region("West Beach", player, world)
west_beach_region = Region("West Beach", player, multiworld)
west_beach_region.add_locations(loc_west_beach, CCCharlesLocation)
world.regions.append(west_beach_region)
multiworld.regions.append(west_beach_region)
church_region = Region("Church", player, world)
church_region = Region("Church", player, multiworld)
church_region.add_locations(loc_church, CCCharlesLocation)
world.regions.append(church_region)
multiworld.regions.append(church_region)
west_cottage_region = Region("West Cottage", player, world)
west_cottage_region = Region("West Cottage", player, multiworld)
west_cottage_region.add_locations(loc_west_cottage, CCCharlesLocation)
world.regions.append(west_cottage_region)
multiworld.regions.append(west_cottage_region)
caravan_region = Region("Caravan", player, world)
caravan_region = Region("Caravan", player, multiworld)
caravan_region.add_locations(loc_caravan, CCCharlesLocation)
world.regions.append(caravan_region)
multiworld.regions.append(caravan_region)
trailer_cabin_region = Region("Trailer Cabin", player, world)
trailer_cabin_region = Region("Trailer Cabin", player, multiworld)
trailer_cabin_region.add_locations(loc_trailer_cabin, CCCharlesLocation)
world.regions.append(trailer_cabin_region)
multiworld.regions.append(trailer_cabin_region)
towers_region = Region("Towers", player, world)
towers_region = Region("Towers", player, multiworld)
towers_region.add_locations(loc_towers, CCCharlesLocation)
world.regions.append(towers_region)
multiworld.regions.append(towers_region)
north_beach_region = Region("North beach", player, world)
north_beach_region = Region("North beach", player, multiworld)
north_beach_region.add_locations(loc_north_beach, CCCharlesLocation)
world.regions.append(north_beach_region)
multiworld.regions.append(north_beach_region)
mine_shaft_region = Region("Mine Shaft", player, world)
mine_shaft_region = Region("Mine Shaft", player, multiworld)
mine_shaft_region.add_locations(loc_mine_shaft, CCCharlesLocation)
world.regions.append(mine_shaft_region)
multiworld.regions.append(mine_shaft_region)
mob_camp_region = Region("Mob Camp", player, world)
mob_camp_region = Region("Mob Camp", player, multiworld)
mob_camp_region.add_locations(loc_mob_camp, CCCharlesLocation)
world.regions.append(mob_camp_region)
multiworld.regions.append(mob_camp_region)
mob_camp_locked_room_region = Region("Mob Camp Locked Room", player, world)
mob_camp_locked_room_region = Region("Mob Camp Locked Room", player, multiworld)
mob_camp_locked_room_region.add_locations(loc_mob_camp_locked_room, CCCharlesLocation)
world.regions.append(mob_camp_locked_room_region)
multiworld.regions.append(mob_camp_locked_room_region)
mine_elevator_exit_region = Region("Mine Elevator Exit", player, world)
mine_elevator_exit_region = Region("Mine Elevator Exit", player, multiworld)
mine_elevator_exit_region.add_locations(loc_mine_elevator_exit, CCCharlesLocation)
world.regions.append(mine_elevator_exit_region)
multiworld.regions.append(mine_elevator_exit_region)
mountain_ruin_outside_region = Region("Mountain Ruin Outside", player, world)
mountain_ruin_outside_region = Region("Mountain Ruin Outside", player, multiworld)
mountain_ruin_outside_region.add_locations(loc_mountain_ruin_outside, CCCharlesLocation)
world.regions.append(mountain_ruin_outside_region)
multiworld.regions.append(mountain_ruin_outside_region)
mountain_ruin_inside_region = Region("Mountain Ruin Inside", player, world)
mountain_ruin_inside_region = Region("Mountain Ruin Inside", player, multiworld)
mountain_ruin_inside_region.add_locations(loc_mountain_ruin_inside, CCCharlesLocation)
world.regions.append(mountain_ruin_inside_region)
multiworld.regions.append(mountain_ruin_inside_region)
prism_temple_region = Region("Prism Temple", player, world)
prism_temple_region = Region("Prism Temple", player, multiworld)
prism_temple_region.add_locations(loc_prism_temple, CCCharlesLocation)
world.regions.append(prism_temple_region)
multiworld.regions.append(prism_temple_region)
pickle_val_region = Region("Pickle Val", player, world)
pickle_val_region = Region("Pickle Val", player, multiworld)
pickle_val_region.add_locations(loc_pickle_val, CCCharlesLocation)
world.regions.append(pickle_val_region)
multiworld.regions.append(pickle_val_region)
shrine_near_temple_region = Region("Shrine Near Temple", player, world)
shrine_near_temple_region = Region("Shrine Near Temple", player, multiworld)
shrine_near_temple_region.add_locations(loc_shrine_near_temple, CCCharlesLocation)
world.regions.append(shrine_near_temple_region)
multiworld.regions.append(shrine_near_temple_region)
morse_bunker_region = Region("Morse Bunker", player, world)
morse_bunker_region = Region("Morse Bunker", player, multiworld)
morse_bunker_region.add_locations(loc_morse_bunker, CCCharlesLocation)
world.regions.append(morse_bunker_region)
multiworld.regions.append(morse_bunker_region)
# Place "Victory" event at "Final Boss" location
loc_final_boss = CCCharlesLocation(player, "Final Boss", None, prism_temple_region)

148
worlds/cccharles/Rules.py
View File

@@ -4,212 +4,212 @@ from .Options import CCCharlesOptions
# Go mode: Green Egg + Blue Egg + Red Egg + Temple Key + Bug Spray (+ Remote Explosive x8 but the base game ignores it)
def set_rules(world: MultiWorld, options: CCCharlesOptions, player: int) -> None:
def set_rules(multiworld: MultiWorld, options: CCCharlesOptions, player: int) -> None:
# Tony Tiddle
set_rule(world.get_entrance("Barn Door", player),
set_rule(multiworld.get_entrance("Barn Door", player),
lambda state: state.has("Barn Key", player))
# Candice
set_rule(world.get_entrance("Tutorial House Door", player),
set_rule(multiworld.get_entrance("Tutorial House Door", player),
lambda state: state.has("Candice's Key", player))
# Lizbeth Murkwater
set_rule(world.get_location("Swamp Lizbeth Murkwater Mission End", player),
set_rule(multiworld.get_location("Swamp Lizbeth Murkwater Mission End", player),
lambda state: state.has("Dead Fish", player))
# Daryl
set_rule(world.get_location("Junkyard Area Chest Ancient Tablet", player),
set_rule(multiworld.get_location("Junkyard Area Chest Ancient Tablet", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Junkyard Area Daryl Mission End", player),
set_rule(multiworld.get_location("Junkyard Area Daryl Mission End", player),
lambda state: state.has("Ancient Tablet", player))
# South House
set_rule(world.get_location("South House Chest Scraps 1", player),
set_rule(multiworld.get_location("South House Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("South House Chest Scraps 2", player),
set_rule(multiworld.get_location("South House Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("South House Chest Scraps 3", player),
set_rule(multiworld.get_location("South House Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("South House Chest Scraps 4", player),
set_rule(multiworld.get_location("South House Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("South House Chest Scraps 5", player),
set_rule(multiworld.get_location("South House Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("South House Chest Scraps 6", player),
set_rule(multiworld.get_location("South House Chest Scraps 6", player),
lambda state: state.has("Lockpicks", player))
# South Mine
set_rule(world.get_entrance("South Mine Gate", player),
set_rule(multiworld.get_entrance("South Mine Gate", player),
lambda state: state.has("South Mine Key", player))
set_rule(world.get_location("South Mine Inside Green Paint Can", player),
set_rule(multiworld.get_location("South Mine Inside Green Paint Can", player),
lambda state: state.has("Lockpicks", player))
# Theodore
set_rule(world.get_location("Middle Station Theodore Mission End", player),
set_rule(multiworld.get_location("Middle Station Theodore Mission End", player),
lambda state: state.has("Blue Box", player))
# Watchtower
set_rule(world.get_location("Watchtower Pink Paint Can", player),
set_rule(multiworld.get_location("Watchtower Pink Paint Can", player),
lambda state: state.has("Lockpicks", player))
# Sasha
set_rule(world.get_location("Haunted House Sasha Mission End", player),
set_rule(multiworld.get_location("Haunted House Sasha Mission End", player),
lambda state: state.has("Page Drawing", player, 8))
# Santiago
set_rule(world.get_location("Port Santiago Mission End", player),
set_rule(multiworld.get_location("Port Santiago Mission End", player),
lambda state: state.has("Journal", player))
# Trench House
set_rule(world.get_location("Trench House Chest Scraps 1", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Trench House Chest Scraps 2", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Trench House Chest Scraps 3", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Trench House Chest Scraps 4", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Trench House Chest Scraps 5", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Trench House Chest Scraps 6", player),
set_rule(multiworld.get_location("Trench House Chest Scraps 6", player),
lambda state: state.has("Lockpicks", player))
# East House
set_rule(world.get_location("East House Chest Scraps 1", player),
set_rule(multiworld.get_location("East House Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("East House Chest Scraps 2", player),
set_rule(multiworld.get_location("East House Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("East House Chest Scraps 3", player),
set_rule(multiworld.get_location("East House Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("East House Chest Scraps 4", player),
set_rule(multiworld.get_location("East House Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("East House Chest Scraps 5", player),
set_rule(multiworld.get_location("East House Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
# Rocket Testing Bunker
set_rule(world.get_entrance("Stuck Bunker Door", player),
set_rule(multiworld.get_entrance("Stuck Bunker Door", player),
lambda state: state.has("Timed Dynamite", player))
# John Smith
set_rule(world.get_location("Workshop John Smith Mission End", player),
set_rule(multiworld.get_location("Workshop John Smith Mission End", player),
lambda state: state.has("Box of Rockets", player))
# Claire
set_rule(world.get_location("Lighthouse Claire Mission End", player),
set_rule(multiworld.get_location("Lighthouse Claire Mission End", player),
lambda state: state.has("Breaker", player, 4))
# North Mine
set_rule(world.get_entrance("North Mine Gate", player),
set_rule(multiworld.get_entrance("North Mine Gate", player),
lambda state: state.has("North Mine Key", player))
set_rule(world.get_location("North Mine Inside Blue Paint Can", player),
set_rule(multiworld.get_location("North Mine Inside Blue Paint Can", player),
lambda state: state.has("Lockpicks", player))
# Paul
set_rule(world.get_location("Museum Paul Mission End", player),
set_rule(multiworld.get_location("Museum Paul Mission End", player),
lambda state: state.has("Remote Explosive x8", player))
# lambda state: state.has("Remote Explosive", player, 8)) # TODO: Add an option to split remote explosives
# West Beach
set_rule(world.get_location("West Beach Chest Scraps 1", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("West Beach Chest Scraps 2", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("West Beach Chest Scraps 3", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("West Beach Chest Scraps 4", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("West Beach Chest Scraps 5", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("West Beach Chest Scraps 6", player),
set_rule(multiworld.get_location("West Beach Chest Scraps 6", player),
lambda state: state.has("Lockpicks", player))
# Caravan
set_rule(world.get_location("Caravan Chest Scraps 1", player),
set_rule(multiworld.get_location("Caravan Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Caravan Chest Scraps 2", player),
set_rule(multiworld.get_location("Caravan Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Caravan Chest Scraps 3", player),
set_rule(multiworld.get_location("Caravan Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Caravan Chest Scraps 4", player),
set_rule(multiworld.get_location("Caravan Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Caravan Chest Scraps 5", player),
set_rule(multiworld.get_location("Caravan Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
# Ronny
set_rule(world.get_location("Towers Ronny Mission End", player),
set_rule(multiworld.get_location("Towers Ronny Mission End", player),
lambda state: state.has("Employment Contracts", player))
# North Beach
set_rule(world.get_location("North Beach Chest Scraps 1", player),
set_rule(multiworld.get_location("North Beach Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("North Beach Chest Scraps 2", player),
set_rule(multiworld.get_location("North Beach Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("North Beach Chest Scraps 3", player),
set_rule(multiworld.get_location("North Beach Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("North Beach Chest Scraps 4", player),
set_rule(multiworld.get_location("North Beach Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
# Mine Shaft
set_rule(world.get_location("Mine Shaft Chest Scraps 1", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 2", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 3", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 4", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 5", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 6", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 6", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Mine Shaft Chest Scraps 7", player),
set_rule(multiworld.get_location("Mine Shaft Chest Scraps 7", player),
lambda state: state.has("Lockpicks", player))
# Mob Camp
set_rule(world.get_entrance("Mob Camp Locked Door", player),
set_rule(multiworld.get_entrance("Mob Camp Locked Door", player),
lambda state: state.has("Mob Camp Key", player))
set_rule(world.get_location("Mob Camp Locked Room Stolen Bob", player),
set_rule(multiworld.get_location("Mob Camp Locked Room Stolen Bob", player),
lambda state: state.has("Broken Bob", player))
# Mountain Ruin
set_rule(world.get_entrance("Mountain Ruin Gate", player),
set_rule(multiworld.get_entrance("Mountain Ruin Gate", player),
lambda state: state.has("Mountain Ruin Key", player))
set_rule(world.get_location("Mountain Ruin Inside Red Paint Can", player),
set_rule(multiworld.get_location("Mountain Ruin Inside Red Paint Can", player),
lambda state: state.has("Lockpicks", player))
# Prism Temple
set_rule(world.get_location("Prism Temple Chest Scraps 1", player),
set_rule(multiworld.get_location("Prism Temple Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Prism Temple Chest Scraps 2", player),
set_rule(multiworld.get_location("Prism Temple Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Prism Temple Chest Scraps 3", player),
set_rule(multiworld.get_location("Prism Temple Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
# Pickle Lady
set_rule(world.get_location("Pickle Val Jar of Pickles", player),
set_rule(multiworld.get_location("Pickle Val Jar of Pickles", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Pickle Val Pickle Lady Mission End", player),
set_rule(multiworld.get_location("Pickle Val Pickle Lady Mission End", player),
lambda state: state.has("Jar of Pickles", player))
# Morse Bunker
set_rule(world.get_location("Morse Bunker Chest Scraps 1", player),
set_rule(multiworld.get_location("Morse Bunker Chest Scraps 1", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Morse Bunker Chest Scraps 2", player),
set_rule(multiworld.get_location("Morse Bunker Chest Scraps 2", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Morse Bunker Chest Scraps 3", player),
set_rule(multiworld.get_location("Morse Bunker Chest Scraps 3", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Morse Bunker Chest Scraps 4", player),
set_rule(multiworld.get_location("Morse Bunker Chest Scraps 4", player),
lambda state: state.has("Lockpicks", player))
set_rule(world.get_location("Morse Bunker Chest Scraps 5", player),
set_rule(multiworld.get_location("Morse Bunker Chest Scraps 5", player),
lambda state: state.has("Lockpicks", player))
# Add rules to reach the "Go mode"
set_rule(world.get_location("Final Boss", player),
set_rule(multiworld.get_location("Final Boss", player),
lambda state: state.has("Temple Key", player)
and state.has("Green Egg", player)
and state.has("Blue Egg", player)
and state.has("Red Egg", player))
world.completion_condition[player] = lambda state: state.has("Victory", player)
multiworld.completion_condition[player] = lambda state: state.has("Victory", player)

4
worlds/dkc3/__init__.py
View File

@@ -67,9 +67,9 @@ class DKC3World(World):
active_level_list: typing.List[str]
web = DKC3Web()
def __init__(self, world: MultiWorld, player: int):
def __init__(self, multiworld: MultiWorld, player: int):
self.rom_name_available_event = threading.Event()
super().__init__(world, player)
super().__init__(multiworld, player)
@classmethod
def stage_assert_generate(cls, multiworld: MultiWorld):

58
worlds/dlcquest/Regions.py
View File

@@ -45,35 +45,35 @@ def create_regions(multiworld: MultiWorld, player: int, world_options: Options.D
def create_regions_basic_campaign(has_campaign_basic: bool, region_menu: Region, has_item_shuffle: bool, has_coinsanity: bool,
coin_bundle_size: int, player: int, world: MultiWorld):
coin_bundle_size: int, player: int, multiworld: MultiWorld):
if not has_campaign_basic:
return
region_menu.exits += [Entrance(player, "DLC Quest Basic", region_menu)]
locations_move_right = ["Movement Pack", "Animation Pack", "Audio Pack", "Pause Menu Pack"]
region_move_right = create_region_and_locations_basic("Move Right", locations_move_right, ["Moving"], player, world, 4)
region_move_right = create_region_and_locations_basic("Move Right", locations_move_right, ["Moving"], player, multiworld, 4)
create_coinsanity_locations_dlc_quest(has_coinsanity, coin_bundle_size, player, region_move_right)
locations_movement_pack = ["Time is Money Pack", "Psychological Warfare Pack", "Armor for your Horse Pack", "Shepherd Sheep"]
locations_movement_pack += conditional_location(has_item_shuffle, "Sword")
create_region_and_locations_basic("Movement Pack", locations_movement_pack, ["Tree", "Cloud"], player, world, 46)
create_region_and_locations_basic("Movement Pack", locations_movement_pack, ["Tree", "Cloud"], player, multiworld, 46)
locations_behind_tree = ["Double Jump Pack", "Map Pack", "Between Trees Sheep", "Hole in the Wall Sheep"] + conditional_location(has_item_shuffle, "Gun")
create_region_and_locations_basic("Behind Tree", locations_behind_tree, ["Behind Tree Double Jump", "Forest Entrance"], player, world, 60)
create_region_and_locations_basic("Psychological Warfare", ["West Cave Sheep"], ["Cloud Double Jump"], player, world, 100)
create_region_and_locations_basic("Behind Tree", locations_behind_tree, ["Behind Tree Double Jump", "Forest Entrance"], player, multiworld, 60)
create_region_and_locations_basic("Psychological Warfare", ["West Cave Sheep"], ["Cloud Double Jump"], player, multiworld, 100)
locations_double_jump_left = ["Pet Pack", "Top Hat Pack", "North West Alcove Sheep"]
create_region_and_locations_basic("Double Jump Total Left", locations_double_jump_left, ["Cave Tree", "Cave Roof"], player, world, 50)
create_region_and_locations_basic("Double Jump Total Left Cave", ["Top Hat Sheep"], [], player, world, 9)
create_region_and_locations_basic("Double Jump Total Left Roof", ["North West Ceiling Sheep"], [], player, world, 10)
create_region_and_locations_basic("Double Jump Total Left", locations_double_jump_left, ["Cave Tree", "Cave Roof"], player, multiworld, 50)
create_region_and_locations_basic("Double Jump Total Left Cave", ["Top Hat Sheep"], [], player, multiworld, 9)
create_region_and_locations_basic("Double Jump Total Left Roof", ["North West Ceiling Sheep"], [], player, multiworld, 10)
locations_double_jump_left_ceiling = ["Sexy Outfits Pack", "Double Jump Alcove Sheep", "Sexy Outfits Sheep"]
create_region_and_locations_basic("Double Jump Behind Tree", locations_double_jump_left_ceiling, ["True Double Jump"], player, world, 89)
create_region_and_locations_basic("True Double Jump Behind Tree", ["Double Jump Floating Sheep", "Cutscene Sheep"], [], player, world, 7)
create_region_and_locations_basic("The Forest", ["Gun Pack", "Night Map Pack"], ["Behind Ogre", "Forest Double Jump"], player, world, 171)
create_region_and_locations_basic("The Forest with double Jump", ["The Zombie Pack", "Forest Low Sheep"], ["Forest True Double Jump"], player, world, 76)
create_region_and_locations_basic("The Forest with double Jump Part 2", ["Forest High Sheep"], [], player, world, 203)
region_final_boss_room = create_region_and_locations_basic("The Final Boss Room", ["Finish the Fight Pack"], [], player, world)
create_region_and_locations_basic("Double Jump Behind Tree", locations_double_jump_left_ceiling, ["True Double Jump"], player, multiworld, 89)
create_region_and_locations_basic("True Double Jump Behind Tree", ["Double Jump Floating Sheep", "Cutscene Sheep"], [], player, multiworld, 7)
create_region_and_locations_basic("The Forest", ["Gun Pack", "Night Map Pack"], ["Behind Ogre", "Forest Double Jump"], player, multiworld, 171)
create_region_and_locations_basic("The Forest with double Jump", ["The Zombie Pack", "Forest Low Sheep"], ["Forest True Double Jump"], player, multiworld, 76)
create_region_and_locations_basic("The Forest with double Jump Part 2", ["Forest High Sheep"], [], player, multiworld, 203)
region_final_boss_room = create_region_and_locations_basic("The Final Boss Room", ["Finish the Fight Pack"], [], player, multiworld)
create_victory_event(region_final_boss_room, "Winning Basic", "Victory Basic", player)
connect_entrances_basic(player, world)
connect_entrances_basic(player, multiworld)
def create_regions_lfod_campaign(coin_bundle_size, has_campaign_lfod, has_coinsanity, has_item_shuffle, multiworld, player, region_menu):
@@ -141,20 +141,20 @@ def create_victory_event(region_victory: Region, event_name: str, item_name: str
location_victory.place_locked_item(create_event(player, item_name))
def connect_entrances_basic(player, world):
world.get_entrance("DLC Quest Basic", player).connect(world.get_region("Move Right", player))
world.get_entrance("Moving", player).connect(world.get_region("Movement Pack", player))
world.get_entrance("Tree", player).connect(world.get_region("Behind Tree", player))
world.get_entrance("Cloud", player).connect(world.get_region("Psychological Warfare", player))
world.get_entrance("Cloud Double Jump", player).connect(world.get_region("Double Jump Total Left", player))
world.get_entrance("Cave Tree", player).connect(world.get_region("Double Jump Total Left Cave", player))
world.get_entrance("Cave Roof", player).connect(world.get_region("Double Jump Total Left Roof", player))
world.get_entrance("Forest Entrance", player).connect(world.get_region("The Forest", player))
world.get_entrance("Behind Tree Double Jump", player).connect(world.get_region("Double Jump Behind Tree", player))
world.get_entrance("Behind Ogre", player).connect(world.get_region("The Final Boss Room", player))
world.get_entrance("Forest Double Jump", player).connect(world.get_region("The Forest with double Jump", player))
world.get_entrance("Forest True Double Jump", player).connect(world.get_region("The Forest with double Jump Part 2", player))
world.get_entrance("True Double Jump", player).connect(world.get_region("True Double Jump Behind Tree", player))
def connect_entrances_basic(player, multiworld):
multiworld.get_entrance("DLC Quest Basic", player).connect(multiworld.get_region("Move Right", player))
multiworld.get_entrance("Moving", player).connect(multiworld.get_region("Movement Pack", player))
multiworld.get_entrance("Tree", player).connect(multiworld.get_region("Behind Tree", player))
multiworld.get_entrance("Cloud", player).connect(multiworld.get_region("Psychological Warfare", player))
multiworld.get_entrance("Cloud Double Jump", player).connect(multiworld.get_region("Double Jump Total Left", player))
multiworld.get_entrance("Cave Tree", player).connect(multiworld.get_region("Double Jump Total Left Cave", player))
multiworld.get_entrance("Cave Roof", player).connect(multiworld.get_region("Double Jump Total Left Roof", player))
multiworld.get_entrance("Forest Entrance", player).connect(multiworld.get_region("The Forest", player))
multiworld.get_entrance("Behind Tree Double Jump", player).connect(multiworld.get_region("Double Jump Behind Tree", player))
multiworld.get_entrance("Behind Ogre", player).connect(multiworld.get_region("The Final Boss Room", player))
multiworld.get_entrance("Forest Double Jump", player).connect(multiworld.get_region("The Forest with double Jump", player))
multiworld.get_entrance("Forest True Double Jump", player).connect(multiworld.get_region("The Forest with double Jump Part 2", player))
multiworld.get_entrance("True Double Jump", player).connect(multiworld.get_region("True Double Jump Behind Tree", player))
def connect_entrances_lfod(multiworld, player):

388
worlds/dlcquest/Rules.py
View File

@@ -18,251 +18,251 @@ def has_enough_coin_freemium(player: int, coin: int):
return lambda state: state.prog_items[player][" coins freemium"] >= coin
def set_rules(world, player, world_options: Options.DLCQuestOptions):
set_basic_rules(world_options, player, world)
set_lfod_rules(world_options, player, world)
set_completion_condition(world_options, player, world)
def set_rules(multiworld, player, world_options: Options.DLCQuestOptions):
set_basic_rules(world_options, player, multiworld)
set_lfod_rules(world_options, player, multiworld)
set_completion_condition(world_options, player, multiworld)
def set_basic_rules(world_options, player, world):
def set_basic_rules(world_options, player, multiworld):
if world_options.campaign == Options.Campaign.option_live_freemium_or_die:
return
set_basic_entrance_rules(player, world)
set_basic_self_obtained_items_rules(world_options, player, world)
set_basic_shuffled_items_rules(world_options, player, world)
set_double_jump_glitchless_rules(world_options, player, world)
set_easy_double_jump_glitch_rules(world_options, player, world)
self_basic_coinsanity_funded_purchase_rules(world_options, player, world)
set_basic_self_funded_purchase_rules(world_options, player, world)
self_basic_win_condition(world_options, player, world)
set_basic_entrance_rules(player, multiworld)
set_basic_self_obtained_items_rules(world_options, player, multiworld)
set_basic_shuffled_items_rules(world_options, player, multiworld)
set_double_jump_glitchless_rules(world_options, player, multiworld)
set_easy_double_jump_glitch_rules(world_options, player, multiworld)
self_basic_coinsanity_funded_purchase_rules(world_options, player, multiworld)
set_basic_self_funded_purchase_rules(world_options, player, multiworld)
self_basic_win_condition(world_options, player, multiworld)
def set_basic_entrance_rules(player, world):
set_rule(world.get_entrance("Moving", player),
def set_basic_entrance_rules(player, multiworld):
set_rule(multiworld.get_entrance("Moving", player),
lambda state: state.has("Movement Pack", player))
set_rule(world.get_entrance("Cloud", player),
set_rule(multiworld.get_entrance("Cloud", player),
lambda state: state.has("Psychological Warfare Pack", player))
set_rule(world.get_entrance("Forest Entrance", player),
set_rule(multiworld.get_entrance("Forest Entrance", player),
lambda state: state.has("Map Pack", player))
set_rule(world.get_entrance("Forest True Double Jump", player),
set_rule(multiworld.get_entrance("Forest True Double Jump", player),
lambda state: state.has("Double Jump Pack", player))
def set_basic_self_obtained_items_rules(world_options, player, world):
def set_basic_self_obtained_items_rules(world_options, player, multiworld):
if world_options.item_shuffle != Options.ItemShuffle.option_disabled:
return
set_rule(world.get_entrance("Behind Ogre", player),
set_rule(multiworld.get_entrance("Behind Ogre", player),
lambda state: state.has("Gun Pack", player))
if world_options.time_is_money == Options.TimeIsMoney.option_required:
set_rule(world.get_entrance("Tree", player),
set_rule(multiworld.get_entrance("Tree", player),
lambda state: state.has("Time is Money Pack", player))
set_rule(world.get_entrance("Cave Tree", player),
set_rule(multiworld.get_entrance("Cave Tree", player),
lambda state: state.has("Time is Money Pack", player))
set_rule(world.get_location("Shepherd Sheep", player),
set_rule(multiworld.get_location("Shepherd Sheep", player),
lambda state: state.has("Time is Money Pack", player))
set_rule(world.get_location("North West Ceiling Sheep", player),
set_rule(multiworld.get_location("North West Ceiling Sheep", player),
lambda state: state.has("Time is Money Pack", player))
set_rule(world.get_location("North West Alcove Sheep", player),
set_rule(multiworld.get_location("North West Alcove Sheep", player),
lambda state: state.has("Time is Money Pack", player))
set_rule(world.get_location("West Cave Sheep", player),
set_rule(multiworld.get_location("West Cave Sheep", player),
lambda state: state.has("Time is Money Pack", player))
def set_basic_shuffled_items_rules(world_options, player, world):
def set_basic_shuffled_items_rules(world_options, player, multiworld):
if world_options.item_shuffle != Options.ItemShuffle.option_shuffled:
return
set_rule(world.get_entrance("Behind Ogre", player),
set_rule(multiworld.get_entrance("Behind Ogre", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player, 2))
set_rule(world.get_entrance("Tree", player),
set_rule(multiworld.get_entrance("Tree", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_entrance("Cave Tree", player),
set_rule(multiworld.get_entrance("Cave Tree", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_entrance("True Double Jump", player),
set_rule(multiworld.get_entrance("True Double Jump", player),
lambda state: state.has("Double Jump Pack", player))
set_rule(world.get_location("Shepherd Sheep", player),
set_rule(multiworld.get_location("Shepherd Sheep", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_location("North West Ceiling Sheep", player),
set_rule(multiworld.get_location("North West Ceiling Sheep", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_location("North West Alcove Sheep", player),
set_rule(multiworld.get_location("North West Alcove Sheep", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_location("West Cave Sheep", player),
set_rule(multiworld.get_location("West Cave Sheep", player),
lambda state: state.has("DLC Quest: Progressive Weapon", player))
set_rule(world.get_location("Gun", player),
set_rule(multiworld.get_location("Gun", player),
lambda state: state.has("Gun Pack", player))
if world_options.time_is_money == Options.TimeIsMoney.option_required:
set_rule(world.get_location("Sword", player),
set_rule(multiworld.get_location("Sword", player),
lambda state: state.has("Time is Money Pack", player))
def set_double_jump_glitchless_rules(world_options, player, world):
def set_double_jump_glitchless_rules(world_options, player, multiworld):
if world_options.double_jump_glitch != Options.DoubleJumpGlitch.option_none:
return
set_rule(world.get_entrance("Cloud Double Jump", player),
set_rule(multiworld.get_entrance("Cloud Double Jump", player),
lambda state: state.has("Double Jump Pack", player))
set_rule(world.get_entrance("Forest Double Jump", player),
set_rule(multiworld.get_entrance("Forest Double Jump", player),
lambda state: state.has("Double Jump Pack", player))
def set_easy_double_jump_glitch_rules(world_options, player, world):
def set_easy_double_jump_glitch_rules(world_options, player, multiworld):
if world_options.double_jump_glitch == Options.DoubleJumpGlitch.option_all:
return
set_rule(world.get_entrance("Behind Tree Double Jump", player),
set_rule(multiworld.get_entrance("Behind Tree Double Jump", player),
lambda state: state.has("Double Jump Pack", player))
set_rule(world.get_entrance("Cave Roof", player),
set_rule(multiworld.get_entrance("Cave Roof", player),
lambda state: state.has("Double Jump Pack", player))
def self_basic_coinsanity_funded_purchase_rules(world_options, player, world):
def self_basic_coinsanity_funded_purchase_rules(world_options, player, multiworld):
if world_options.coinsanity != Options.CoinSanity.option_coin:
return
if world_options.coinbundlequantity == -1:
self_basic_coinsanity_piece_rules(player, world)
self_basic_coinsanity_piece_rules(player, multiworld)
return
number_of_bundle = math.floor(825 / world_options.coinbundlequantity)
for i in range(number_of_bundle):
item_coin = f"DLC Quest: {world_options.coinbundlequantity * (i + 1)} Coin"
set_rule(world.get_location(item_coin, player),
set_rule(multiworld.get_location(item_coin, player),
has_enough_coin(player, world_options.coinbundlequantity * (i + 1)))
if 825 % world_options.coinbundlequantity != 0:
set_rule(world.get_location("DLC Quest: 825 Coin", player),
set_rule(multiworld.get_location("DLC Quest: 825 Coin", player),
has_enough_coin(player, 825))
set_rule(world.get_location("Movement Pack", player),
set_rule(multiworld.get_location("Movement Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(4 / world_options.coinbundlequantity)))
set_rule(world.get_location("Animation Pack", player),
set_rule(multiworld.get_location("Animation Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Audio Pack", player),
set_rule(multiworld.get_location("Audio Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Pause Menu Pack", player),
set_rule(multiworld.get_location("Pause Menu Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Time is Money Pack", player),
set_rule(multiworld.get_location("Time is Money Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(20 / world_options.coinbundlequantity)))
set_rule(world.get_location("Double Jump Pack", player),
set_rule(multiworld.get_location("Double Jump Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(100 / world_options.coinbundlequantity)))
set_rule(world.get_location("Pet Pack", player),
set_rule(multiworld.get_location("Pet Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Sexy Outfits Pack", player),
set_rule(multiworld.get_location("Sexy Outfits Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Top Hat Pack", player),
set_rule(multiworld.get_location("Top Hat Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Map Pack", player),
set_rule(multiworld.get_location("Map Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(140 / world_options.coinbundlequantity)))
set_rule(world.get_location("Gun Pack", player),
set_rule(multiworld.get_location("Gun Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(75 / world_options.coinbundlequantity)))
set_rule(world.get_location("The Zombie Pack", player),
set_rule(multiworld.get_location("The Zombie Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Night Map Pack", player),
set_rule(multiworld.get_location("Night Map Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(75 / world_options.coinbundlequantity)))
set_rule(world.get_location("Psychological Warfare Pack", player),
set_rule(multiworld.get_location("Psychological Warfare Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(50 / world_options.coinbundlequantity)))
set_rule(world.get_location("Armor for your Horse Pack", player),
set_rule(multiworld.get_location("Armor for your Horse Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(250 / world_options.coinbundlequantity)))
set_rule(world.get_location("Finish the Fight Pack", player),
set_rule(multiworld.get_location("Finish the Fight Pack", player),
lambda state: state.has("DLC Quest: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
def set_basic_self_funded_purchase_rules(world_options, player, world):
def set_basic_self_funded_purchase_rules(world_options, player, multiworld):
if world_options.coinsanity != Options.CoinSanity.option_none:
return
set_rule(world.get_location("Movement Pack", player),
set_rule(multiworld.get_location("Movement Pack", player),
has_enough_coin(player, 4))
set_rule(world.get_location("Animation Pack", player),
set_rule(multiworld.get_location("Animation Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Audio Pack", player),
set_rule(multiworld.get_location("Audio Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Pause Menu Pack", player),
set_rule(multiworld.get_location("Pause Menu Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Time is Money Pack", player),
set_rule(multiworld.get_location("Time is Money Pack", player),
has_enough_coin(player, 20))
set_rule(world.get_location("Double Jump Pack", player),
set_rule(multiworld.get_location("Double Jump Pack", player),
has_enough_coin(player, 100))
set_rule(world.get_location("Pet Pack", player),
set_rule(multiworld.get_location("Pet Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Sexy Outfits Pack", player),
set_rule(multiworld.get_location("Sexy Outfits Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Top Hat Pack", player),
set_rule(multiworld.get_location("Top Hat Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Map Pack", player),
set_rule(multiworld.get_location("Map Pack", player),
has_enough_coin(player, 140))
set_rule(world.get_location("Gun Pack", player),
set_rule(multiworld.get_location("Gun Pack", player),
has_enough_coin(player, 75))
set_rule(world.get_location("The Zombie Pack", player),
set_rule(multiworld.get_location("The Zombie Pack", player),
has_enough_coin(player, 5))
set_rule(world.get_location("Night Map Pack", player),
set_rule(multiworld.get_location("Night Map Pack", player),
has_enough_coin(player, 75))
set_rule(world.get_location("Psychological Warfare Pack", player),
set_rule(multiworld.get_location("Psychological Warfare Pack", player),
has_enough_coin(player, 50))
set_rule(world.get_location("Armor for your Horse Pack", player),
set_rule(multiworld.get_location("Armor for your Horse Pack", player),
has_enough_coin(player, 250))
set_rule(world.get_location("Finish the Fight Pack", player),
set_rule(multiworld.get_location("Finish the Fight Pack", player),
has_enough_coin(player, 5))
def self_basic_win_condition(world_options, player, world):
def self_basic_win_condition(world_options, player, multiworld):
if world_options.ending_choice == Options.EndingChoice.option_any:
set_rule(world.get_location("Winning Basic", player),
set_rule(multiworld.get_location("Winning Basic", player),
lambda state: state.has("Finish the Fight Pack", player))
if world_options.ending_choice == Options.EndingChoice.option_true:
set_rule(world.get_location("Winning Basic", player),
set_rule(multiworld.get_location("Winning Basic", player),
lambda state: state.has("Armor for your Horse Pack", player) and state.has("Finish the Fight Pack",
player))
def set_lfod_rules(world_options, player, world):
def set_lfod_rules(world_options, player, multiworld):
if world_options.campaign == Options.Campaign.option_basic:
return
set_lfod_entrance_rules(player, world)
set_boss_door_requirements_rules(player, world)
set_lfod_self_obtained_items_rules(world_options, player, world)
set_lfod_shuffled_items_rules(world_options, player, world)
self_lfod_coinsanity_funded_purchase_rules(world_options, player, world)
set_lfod_self_funded_purchase_rules(world_options, has_enough_coin_freemium, player, world)
set_lfod_entrance_rules(player, multiworld)
set_boss_door_requirements_rules(player, multiworld)
set_lfod_self_obtained_items_rules(world_options, player, multiworld)
set_lfod_shuffled_items_rules(world_options, player, multiworld)
self_lfod_coinsanity_funded_purchase_rules(world_options, player, multiworld)
set_lfod_self_funded_purchase_rules(world_options, has_enough_coin_freemium, player, multiworld)
def set_lfod_entrance_rules(player, world):
set_rule(world.get_entrance("Wall Jump Entrance", player),
def set_lfod_entrance_rules(player, multiworld):
set_rule(multiworld.get_entrance("Wall Jump Entrance", player),
lambda state: state.has("Wall Jump Pack", player))
set_rule(world.get_entrance("Harmless Plants", player),
set_rule(multiworld.get_entrance("Harmless Plants", player),
lambda state: state.has("Harmless Plants Pack", player))
set_rule(world.get_entrance("Name Change Entrance", player),
set_rule(multiworld.get_entrance("Name Change Entrance", player),
lambda state: state.has("Name Change Pack", player))
set_rule(world.get_entrance("Cut Content Entrance", player),
set_rule(multiworld.get_entrance("Cut Content Entrance", player),
lambda state: state.has("Cut Content Pack", player))
set_rule(world.get_entrance("Blizzard", player),
set_rule(multiworld.get_entrance("Blizzard", player),
lambda state: state.has("Season Pass", player))
set_rule(world.get_location("I Get That Reference!", player),
set_rule(multiworld.get_location("I Get That Reference!", player),
lambda state: state.has("Death of Comedy Pack", player))
set_rule(world.get_location("Story is Important", player),
set_rule(multiworld.get_location("Story is Important", player),
lambda state: state.has("DLC NPC Pack", player))
def set_boss_door_requirements_rules(player, world):
def set_boss_door_requirements_rules(player, multiworld):
sword_1 = "Big Sword Pack"
sword_2 = "Really Big Sword Pack"
sword_3 = "Unfathomable Sword Pack"
big_sword_location = world.get_location(sword_1, player)
really_big_sword_location = world.get_location(sword_2, player)
unfathomable_sword_location = world.get_location(sword_3, player)
big_sword_location = multiworld.get_location(sword_1, player)
really_big_sword_location = multiworld.get_location(sword_2, player)
unfathomable_sword_location = multiworld.get_location(sword_3, player)
big_sword_valid_locations = [big_sword_location]
really_big_sword_valid_locations = [big_sword_location, really_big_sword_location]
@@ -277,7 +277,7 @@ def set_boss_door_requirements_rules(player, world):
has_3_swords = lambda state: ((state.has(sword_1, player) or big_sword_during_boss_fight) and
(state.has(sword_2, player) or really_big_sword_during_boss_fight) and
(state.has(sword_3, player) or unfathomable_sword_during_boss_fight))
set_rule(world.get_entrance("Boss Door", player), has_3_swords)
set_rule(multiworld.get_entrance("Boss Door", player), has_3_swords)
def set_lfod_self_obtained_items_rules(world_options, player, multiworld):
@@ -295,234 +295,234 @@ def set_lfod_self_obtained_items_rules(world_options, player, multiworld):
multiworld.register_indirect_condition(world.get_region("Cut Content"), world.get_entrance("Pickaxe Hard Cave"))
def set_lfod_shuffled_items_rules(world_options, player, world):
def set_lfod_shuffled_items_rules(world_options, player, multiworld):
if world_options.item_shuffle != Options.ItemShuffle.option_shuffled:
return
set_rule(world.get_entrance("Vines", player),
set_rule(multiworld.get_entrance("Vines", player),
lambda state: state.has("Live Freemium or Die: Progressive Weapon", player))
set_rule(world.get_entrance("Behind Rocks", player),
set_rule(multiworld.get_entrance("Behind Rocks", player),
lambda state: state.has("Live Freemium or Die: Progressive Weapon", player, 2))
set_rule(world.get_entrance("Pickaxe Hard Cave", player),
set_rule(multiworld.get_entrance("Pickaxe Hard Cave", player),
lambda state: state.has("Live Freemium or Die: Progressive Weapon", player, 2))
set_rule(world.get_location("Wooden Sword", player),
set_rule(multiworld.get_location("Wooden Sword", player),
lambda state: state.has("Incredibly Important Pack", player))
set_rule(world.get_location("Pickaxe", player),
set_rule(multiworld.get_location("Pickaxe", player),
lambda state: state.has("Humble Indie Bindle", player))
set_rule(world.get_location("Humble Indie Bindle", player),
set_rule(multiworld.get_location("Humble Indie Bindle", player),
lambda state: state.has("Box of Various Supplies", player) and
state.can_reach("Cut Content", 'region', player))
set_rule(world.get_location("Box of Various Supplies", player),
set_rule(multiworld.get_location("Box of Various Supplies", player),
lambda state: state.can_reach("Cut Content", 'region', player))
def self_lfod_coinsanity_funded_purchase_rules(world_options, player, world):
def self_lfod_coinsanity_funded_purchase_rules(world_options, player, multiworld):
if world_options.coinsanity != Options.CoinSanity.option_coin:
return
if world_options.coinbundlequantity == -1:
self_lfod_coinsanity_piece_rules(player, world)
self_lfod_coinsanity_piece_rules(player, multiworld)
return
number_of_bundle = math.floor(889 / world_options.coinbundlequantity)
for i in range(number_of_bundle):
item_coin_freemium = f"Live Freemium or Die: {world_options.coinbundlequantity * (i + 1)} Coin"
set_rule(world.get_location(item_coin_freemium, player),
set_rule(multiworld.get_location(item_coin_freemium, player),
has_enough_coin_freemium(player, world_options.coinbundlequantity * (i + 1)))
if 889 % world_options.coinbundlequantity != 0:
set_rule(world.get_location("Live Freemium or Die: 889 Coin", player),
set_rule(multiworld.get_location("Live Freemium or Die: 889 Coin", player),
has_enough_coin_freemium(player, 889))
add_rule(world.get_entrance("Boss Door", player),
add_rule(multiworld.get_entrance("Boss Door", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(200 / world_options.coinbundlequantity)))
set_rule(world.get_location("Particles Pack", player),
set_rule(multiworld.get_location("Particles Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Day One Patch Pack", player),
set_rule(multiworld.get_location("Day One Patch Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Checkpoint Pack", player),
set_rule(multiworld.get_location("Checkpoint Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Incredibly Important Pack", player),
set_rule(multiworld.get_location("Incredibly Important Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(15 / world_options.coinbundlequantity)))
set_rule(world.get_location("Wall Jump Pack", player),
set_rule(multiworld.get_location("Wall Jump Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(35 / world_options.coinbundlequantity)))
set_rule(world.get_location("Health Bar Pack", player),
set_rule(multiworld.get_location("Health Bar Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Parallax Pack", player),
set_rule(multiworld.get_location("Parallax Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(5 / world_options.coinbundlequantity)))
set_rule(world.get_location("Harmless Plants Pack", player),
set_rule(multiworld.get_location("Harmless Plants Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(130 / world_options.coinbundlequantity)))
set_rule(world.get_location("Death of Comedy Pack", player),
set_rule(multiworld.get_location("Death of Comedy Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(15 / world_options.coinbundlequantity)))
set_rule(world.get_location("Canadian Dialog Pack", player),
set_rule(multiworld.get_location("Canadian Dialog Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(10 / world_options.coinbundlequantity)))
set_rule(world.get_location("DLC NPC Pack", player),
set_rule(multiworld.get_location("DLC NPC Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(15 / world_options.coinbundlequantity)))
set_rule(world.get_location("Cut Content Pack", player),
set_rule(multiworld.get_location("Cut Content Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(40 / world_options.coinbundlequantity)))
set_rule(world.get_location("Name Change Pack", player),
set_rule(multiworld.get_location("Name Change Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(150 / world_options.coinbundlequantity)))
set_rule(world.get_location("Season Pass", player),
set_rule(multiworld.get_location("Season Pass", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(199 / world_options.coinbundlequantity)))
set_rule(world.get_location("High Definition Next Gen Pack", player),
set_rule(multiworld.get_location("High Definition Next Gen Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(20 / world_options.coinbundlequantity)))
set_rule(world.get_location("Increased HP Pack", player),
set_rule(multiworld.get_location("Increased HP Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(10 / world_options.coinbundlequantity)))
set_rule(world.get_location("Remove Ads Pack", player),
set_rule(multiworld.get_location("Remove Ads Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Bundle", player,
math.ceil(25 / world_options.coinbundlequantity)))
def set_lfod_self_funded_purchase_rules(world_options, has_enough_coin_freemium, player, world):
def set_lfod_self_funded_purchase_rules(world_options, has_enough_coin_freemium, player, multiworld):
if world_options.coinsanity != Options.CoinSanity.option_none:
return
add_rule(world.get_entrance("Boss Door", player),
add_rule(multiworld.get_entrance("Boss Door", player),
has_enough_coin_freemium(player, 200))
set_rule(world.get_location("Particles Pack", player),
set_rule(multiworld.get_location("Particles Pack", player),
has_enough_coin_freemium(player, 5))
set_rule(world.get_location("Day One Patch Pack", player),
set_rule(multiworld.get_location("Day One Patch Pack", player),
has_enough_coin_freemium(player, 5))
set_rule(world.get_location("Checkpoint Pack", player),
set_rule(multiworld.get_location("Checkpoint Pack", player),
has_enough_coin_freemium(player, 5))
set_rule(world.get_location("Incredibly Important Pack", player),
set_rule(multiworld.get_location("Incredibly Important Pack", player),
has_enough_coin_freemium(player, 15))
set_rule(world.get_location("Wall Jump Pack", player),
set_rule(multiworld.get_location("Wall Jump Pack", player),
has_enough_coin_freemium(player, 35))
set_rule(world.get_location("Health Bar Pack", player),
set_rule(multiworld.get_location("Health Bar Pack", player),
has_enough_coin_freemium(player, 5))
set_rule(world.get_location("Parallax Pack", player),
set_rule(multiworld.get_location("Parallax Pack", player),
has_enough_coin_freemium(player, 5))
set_rule(world.get_location("Harmless Plants Pack", player),
set_rule(multiworld.get_location("Harmless Plants Pack", player),
has_enough_coin_freemium(player, 130))
set_rule(world.get_location("Death of Comedy Pack", player),
set_rule(multiworld.get_location("Death of Comedy Pack", player),
has_enough_coin_freemium(player, 15))
set_rule(world.get_location("Canadian Dialog Pack", player),
set_rule(multiworld.get_location("Canadian Dialog Pack", player),
has_enough_coin_freemium(player, 10))
set_rule(world.get_location("DLC NPC Pack", player),
set_rule(multiworld.get_location("DLC NPC Pack", player),
has_enough_coin_freemium(player, 15))
set_rule(world.get_location("Cut Content Pack", player),
set_rule(multiworld.get_location("Cut Content Pack", player),
has_enough_coin_freemium(player, 40))
set_rule(world.get_location("Name Change Pack", player),
set_rule(multiworld.get_location("Name Change Pack", player),
has_enough_coin_freemium(player, 150))
set_rule(world.get_location("Season Pass", player),
set_rule(multiworld.get_location("Season Pass", player),
has_enough_coin_freemium(player, 199))
set_rule(world.get_location("High Definition Next Gen Pack", player),
set_rule(multiworld.get_location("High Definition Next Gen Pack", player),
has_enough_coin_freemium(player, 20))
set_rule(world.get_location("Increased HP Pack", player),
set_rule(multiworld.get_location("Increased HP Pack", player),
has_enough_coin_freemium(player, 10))
set_rule(world.get_location("Remove Ads Pack", player),
set_rule(multiworld.get_location("Remove Ads Pack", player),
has_enough_coin_freemium(player, 25))
def set_completion_condition(world_options, player, world):
def set_completion_condition(world_options, player, multiworld):
if world_options.campaign == Options.Campaign.option_basic:
world.completion_condition[player] = lambda state: state.has("Victory Basic", player)
multiworld.completion_condition[player] = lambda state: state.has("Victory Basic", player)
if world_options.campaign == Options.Campaign.option_live_freemium_or_die:
world.completion_condition[player] = lambda state: state.has("Victory Freemium", player)
multiworld.completion_condition[player] = lambda state: state.has("Victory Freemium", player)
if world_options.campaign == Options.Campaign.option_both:
world.completion_condition[player] = lambda state: state.has("Victory Basic", player) and state.has(
multiworld.completion_condition[player] = lambda state: state.has("Victory Basic", player) and state.has(
"Victory Freemium", player)
def self_basic_coinsanity_piece_rules(player, world):
def self_basic_coinsanity_piece_rules(player, multiworld):
for i in range(1,8251):
item_coin = f"DLC Quest: {i} Coin Piece"
set_rule(world.get_location(item_coin, player),
set_rule(multiworld.get_location(item_coin, player),
has_enough_coin(player, math.ceil(i / 10)))
set_rule(world.get_location("Movement Pack", player),
set_rule(multiworld.get_location("Movement Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 40))
set_rule(world.get_location("Animation Pack", player),
set_rule(multiworld.get_location("Animation Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Audio Pack", player),
set_rule(multiworld.get_location("Audio Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Pause Menu Pack", player),
set_rule(multiworld.get_location("Pause Menu Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Time is Money Pack", player),
set_rule(multiworld.get_location("Time is Money Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 200))
set_rule(world.get_location("Double Jump Pack", player),
set_rule(multiworld.get_location("Double Jump Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 100))
set_rule(world.get_location("Pet Pack", player),
set_rule(multiworld.get_location("Pet Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Sexy Outfits Pack", player),
set_rule(multiworld.get_location("Sexy Outfits Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Top Hat Pack", player),
set_rule(multiworld.get_location("Top Hat Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Map Pack", player),
set_rule(multiworld.get_location("Map Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 1400))
set_rule(world.get_location("Gun Pack", player),
set_rule(multiworld.get_location("Gun Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 750))
set_rule(world.get_location("The Zombie Pack", player),
set_rule(multiworld.get_location("The Zombie Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
set_rule(world.get_location("Night Map Pack", player),
set_rule(multiworld.get_location("Night Map Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 750))
set_rule(world.get_location("Psychological Warfare Pack", player),
set_rule(multiworld.get_location("Psychological Warfare Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 500))
set_rule(world.get_location("Armor for your Horse Pack", player),
set_rule(multiworld.get_location("Armor for your Horse Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 2500))
set_rule(world.get_location("Finish the Fight Pack", player),
set_rule(multiworld.get_location("Finish the Fight Pack", player),
lambda state: state.has("DLC Quest: Coin Piece", player, 50))
def self_lfod_coinsanity_piece_rules(player, world):
def self_lfod_coinsanity_piece_rules(player, multiworld):
for i in range(1, 8891):
item_coin_freemium = f"Live Freemium or Die: {i} Coin Piece"
set_rule(world.get_location(item_coin_freemium, player),
set_rule(multiworld.get_location(item_coin_freemium, player),
has_enough_coin_freemium(player, math.ceil(i / 10)))
add_rule(world.get_entrance("Boss Door", player),
add_rule(multiworld.get_entrance("Boss Door", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 2000))
set_rule(world.get_location("Particles Pack", player),
set_rule(multiworld.get_location("Particles Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 50))
set_rule(world.get_location("Day One Patch Pack", player),
set_rule(multiworld.get_location("Day One Patch Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 50))
set_rule(world.get_location("Checkpoint Pack", player),
set_rule(multiworld.get_location("Checkpoint Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 50))
set_rule(world.get_location("Incredibly Important Pack", player),
set_rule(multiworld.get_location("Incredibly Important Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 150))
set_rule(world.get_location("Wall Jump Pack", player),
set_rule(multiworld.get_location("Wall Jump Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 350))
set_rule(world.get_location("Health Bar Pack", player),
set_rule(multiworld.get_location("Health Bar Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 50))
set_rule(world.get_location("Parallax Pack", player),
set_rule(multiworld.get_location("Parallax Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 50))
set_rule(world.get_location("Harmless Plants Pack", player),
set_rule(multiworld.get_location("Harmless Plants Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 1300))
set_rule(world.get_location("Death of Comedy Pack", player),
set_rule(multiworld.get_location("Death of Comedy Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 150))
set_rule(world.get_location("Canadian Dialog Pack", player),
set_rule(multiworld.get_location("Canadian Dialog Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 100))
set_rule(world.get_location("DLC NPC Pack", player),
set_rule(multiworld.get_location("DLC NPC Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 150))
set_rule(world.get_location("Cut Content Pack", player),
set_rule(multiworld.get_location("Cut Content Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 400))
set_rule(world.get_location("Name Change Pack", player),
set_rule(multiworld.get_location("Name Change Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 1500))
set_rule(world.get_location("Season Pass", player),
set_rule(multiworld.get_location("Season Pass", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 199))
set_rule(world.get_location("High Definition Next Gen Pack", player),
set_rule(multiworld.get_location("High Definition Next Gen Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 20))
set_rule(world.get_location("Increased HP Pack", player),
set_rule(multiworld.get_location("Increased HP Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 100))
set_rule(world.get_location("Remove Ads Pack", player),
set_rule(multiworld.get_location("Remove Ads Pack", player),
lambda state: state.has("Live Freemium or Die: Coin Piece", player, 250))

4
worlds/faxanadu/__init__.py
View File

@@ -43,7 +43,7 @@ class FaxanaduWorld(World):
item_name_to_item = {item.name: item for item in Items.items}
location_name_to_id = {loc.name: loc.id for loc in Locations.locations if loc.id is not None}
def __init__(self, world: MultiWorld, player: int):
def __init__(self, multiworld: MultiWorld, player: int):
self.filler_ratios: Dict[str, int] = {
item.name: item.count
for item in Items.items
@@ -51,7 +51,7 @@ class FaxanaduWorld(World):
}
# Remove poison by default to respect itemlinking
self.filler_ratios["Poison"] = 0
super().__init__(world, player)
super().__init__(multiworld, player)
def create_regions(self):
Regions.create_regions(self)

4
worlds/ff1/Locations.py
View File

@@ -41,8 +41,8 @@ class FF1Locations:
@staticmethod
def create_menu_region(player: int, locations: Dict[str, int],
rules: Dict[str, List[List[str]]], world: MultiWorld) -> Region:
menu_region = Region("Menu", player, world)
rules: Dict[str, List[List[str]]], multiworld: MultiWorld) -> Region:
menu_region = Region("Menu", player, multiworld)
for name, address in locations.items():
location = Location(player, name, address, menu_region)
## TODO REMOVE WHEN LOGIC FOR TOFR IS CORRECT

4
worlds/ff1/__init__.py
View File

@@ -50,8 +50,8 @@ class FF1World(World):
web = FF1Web()
def __init__(self, world: MultiWorld, player: int):
super().__init__(world, player)
def __init__(self, multiworld: MultiWorld, player: int):
super().__init__(multiworld, player)
self.locked_items = []
self.locked_locations = []

4
worlds/ffmq/Regions.py
View File

@@ -33,10 +33,10 @@ def process_rules(spot, access):
add_rule(spot, lambda state: state.has_all(access, spot.player))
def create_region(world: MultiWorld, player: int, name: str, room_id=None, locations=None, links=None):
def create_region(multiworld: MultiWorld, player: int, name: str, room_id=None, locations=None, links=None):
if links is None:
links = []
ret = Region(name, player, world)
ret = Region(name, player, multiworld)
if locations:
for location in locations:
location.parent_region = ret

25
worlds/hk/Regions.py
View File

@@ -1,25 +0,0 @@
from .ExtractedData import region_names, exits, connectors
def create_regions(world, player: int):
from . import create_region, HKLocation, HKItem
world.regions.append(create_region(world, player, 'Menu', None, ['Hollow Nest S&Q']))
for region in region_names:
world.regions.append(create_region(world, player, region, [],
exits.get(region, [])))
for entrance_name, exit_name in connectors.items():
if exit_name:
target_region = world.get_entrance(exit_name, player).parent_region
world.get_entrance(entrance_name, player).connect(target_region)
if not entrance_name.endswith("_R"):
# a traversable entrance puts the name of the target door "into logic".
loc = HKLocation(player, exit_name, None, target_region)
loc.place_locked_item(HKItem(exit_name,
not exit_name.startswith("White_Palace_"),
None, "Event", player))
target_region.locations.append(loc)
else:
ent = world.get_entrance(entrance_name, player)
ent.parent_region.exits.remove(ent)

288
worlds/hylics2/Rules.py
View File

@@ -126,7 +126,7 @@ def enter_hylemxylem(state: CollectionState, player: int) -> bool:
def set_rules(hylics2world):
world = hylics2world.multiworld
multiworld = hylics2world.multiworld
player = hylics2world.player
extra = hylics2world.options.extra_items_in_logic
@@ -135,23 +135,23 @@ def set_rules(hylics2world):
start_location = hylics2world.options.start_location
# Afterlife
add_rule(world.get_location("Afterlife: TV", player),
add_rule(multiworld.get_location("Afterlife: TV", player),
lambda state: cave_key(state, player))
# New Muldul
add_rule(world.get_location("New Muldul: Underground Chest", player),
add_rule(multiworld.get_location("New Muldul: Underground Chest", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("New Muldul: TV", player),
add_rule(multiworld.get_location("New Muldul: TV", player),
lambda state: house_key(state, player))
add_rule(world.get_location("New Muldul: Upper House Chest 1", player),
add_rule(multiworld.get_location("New Muldul: Upper House Chest 1", player),
lambda state: upper_house_key(state, player))
add_rule(world.get_location("New Muldul: Upper House Chest 2", player),
add_rule(multiworld.get_location("New Muldul: Upper House Chest 2", player),
lambda state: upper_house_key(state, player))
add_rule(world.get_location("New Muldul: Pot above Vault", player),
add_rule(multiworld.get_location("New Muldul: Pot above Vault", player),
lambda state: air_dash(state, player))
# New Muldul Vault
add_rule(world.get_location("New Muldul: Rescued Blerol 1", player),
add_rule(multiworld.get_location("New Muldul: Rescued Blerol 1", player),
lambda state: (
(
(
@@ -165,7 +165,7 @@ def set_rules(hylics2world):
)
or enter_hylemxylem(state, player)
))
add_rule(world.get_location("New Muldul: Rescued Blerol 2", player),
add_rule(multiworld.get_location("New Muldul: Rescued Blerol 2", player),
lambda state: (
(
(
@@ -179,194 +179,194 @@ def set_rules(hylics2world):
)
or enter_hylemxylem(state, player)
))
add_rule(world.get_location("New Muldul: Vault Left Chest", player),
add_rule(multiworld.get_location("New Muldul: Vault Left Chest", player),
lambda state: enter_hylemxylem(state, player))
add_rule(world.get_location("New Muldul: Vault Right Chest", player),
add_rule(multiworld.get_location("New Muldul: Vault Right Chest", player),
lambda state: enter_hylemxylem(state, player))
add_rule(world.get_location("New Muldul: Vault Bomb", player),
add_rule(multiworld.get_location("New Muldul: Vault Bomb", player),
lambda state: enter_hylemxylem(state, player))
# Viewax's Edifice
add_rule(world.get_location("Viewax's Edifice: Canopic Jar", player),
add_rule(multiworld.get_location("Viewax's Edifice: Canopic Jar", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Cave Sarcophagus", player),
add_rule(multiworld.get_location("Viewax's Edifice: Cave Sarcophagus", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Shielded Key", player),
add_rule(multiworld.get_location("Viewax's Edifice: Shielded Key", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Shielded Key", player),
add_rule(multiworld.get_location("Viewax's Edifice: Shielded Key", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Tower Pot", player),
add_rule(multiworld.get_location("Viewax's Edifice: Tower Pot", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Tower Jar", player),
add_rule(multiworld.get_location("Viewax's Edifice: Tower Jar", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Tower Chest", player),
add_rule(multiworld.get_location("Viewax's Edifice: Tower Chest", player),
lambda state: (
paddle(state, player)
and tower_key(state, player)
))
add_rule(world.get_location("Viewax's Edifice: Viewax Pot", player),
add_rule(multiworld.get_location("Viewax's Edifice: Viewax Pot", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Defeat Viewax", player),
add_rule(multiworld.get_location("Viewax's Edifice: Defeat Viewax", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: TV", player),
add_rule(multiworld.get_location("Viewax's Edifice: TV", player),
lambda state: (
paddle(state, player)
and jail_key(state, player)
))
add_rule(world.get_location("Viewax's Edifice: Sage Fridge", player),
add_rule(multiworld.get_location("Viewax's Edifice: Sage Fridge", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Viewax's Edifice: Sage Item 1", player),
add_rule(multiworld.get_location("Viewax's Edifice: Sage Item 1", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Viewax's Edifice: Sage Item 2", player),
add_rule(multiworld.get_location("Viewax's Edifice: Sage Item 2", player),
lambda state: air_dash(state, player))
# Arcade 1
add_rule(world.get_location("Arcade 1: Key", player),
add_rule(multiworld.get_location("Arcade 1: Key", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Coin Dash", player),
add_rule(multiworld.get_location("Arcade 1: Coin Dash", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Burrito Alcove 1", player),
add_rule(multiworld.get_location("Arcade 1: Burrito Alcove 1", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Burrito Alcove 2", player),
add_rule(multiworld.get_location("Arcade 1: Burrito Alcove 2", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Behind Spikes Banana", player),
add_rule(multiworld.get_location("Arcade 1: Behind Spikes Banana", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Pyramid Banana", player),
add_rule(multiworld.get_location("Arcade 1: Pyramid Banana", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Moving Platforms Muscle Applique", player),
add_rule(multiworld.get_location("Arcade 1: Moving Platforms Muscle Applique", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Bed Banana", player),
add_rule(multiworld.get_location("Arcade 1: Bed Banana", player),
lambda state: paddle(state, player))
# Airship
add_rule(world.get_location("Airship: Talk to Somsnosa", player),
add_rule(multiworld.get_location("Airship: Talk to Somsnosa", player),
lambda state: worm_room_key(state, player))
# Foglast
add_rule(world.get_location("Foglast: Underground Sarcophagus", player),
add_rule(multiworld.get_location("Foglast: Underground Sarcophagus", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: Shielded Key", player),
add_rule(multiworld.get_location("Foglast: Shielded Key", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: TV", player),
add_rule(multiworld.get_location("Foglast: TV", player),
lambda state: (
air_dash(state, player)
and clicker(state, player)
))
add_rule(world.get_location("Foglast: Buy Clicker", player),
add_rule(multiworld.get_location("Foglast: Buy Clicker", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: Shielded Chest", player),
add_rule(multiworld.get_location("Foglast: Shielded Chest", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: Cave Fridge", player),
add_rule(multiworld.get_location("Foglast: Cave Fridge", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: Roof Sarcophagus", player),
add_rule(multiworld.get_location("Foglast: Roof Sarcophagus", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Under Lair Sarcophagus 1", player),
add_rule(multiworld.get_location("Foglast: Under Lair Sarcophagus 1", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Under Lair Sarcophagus 2", player),
add_rule(multiworld.get_location("Foglast: Under Lair Sarcophagus 2", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Under Lair Sarcophagus 3", player),
add_rule(multiworld.get_location("Foglast: Under Lair Sarcophagus 3", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Sage Sarcophagus", player),
add_rule(multiworld.get_location("Foglast: Sage Sarcophagus", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Sage Item 1", player),
add_rule(multiworld.get_location("Foglast: Sage Item 1", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
add_rule(world.get_location("Foglast: Sage Item 2", player),
add_rule(multiworld.get_location("Foglast: Sage Item 2", player),
lambda state: (
air_dash(state, player)
and bridge_key(state, player)
))
# Drill Castle
add_rule(world.get_location("Drill Castle: Island Banana", player),
add_rule(multiworld.get_location("Drill Castle: Island Banana", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Drill Castle: Island Pot", player),
add_rule(multiworld.get_location("Drill Castle: Island Pot", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Drill Castle: Cave Sarcophagus", player),
add_rule(multiworld.get_location("Drill Castle: Cave Sarcophagus", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Drill Castle: TV", player),
add_rule(multiworld.get_location("Drill Castle: TV", player),
lambda state: air_dash(state, player))
# Sage Labyrinth
add_rule(world.get_location("Sage Labyrinth: Sage Item 1", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Item 1", player),
lambda state: deep_key(state, player))
add_rule(world.get_location("Sage Labyrinth: Sage Item 2", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Item 2", player),
lambda state: deep_key(state, player))
add_rule(world.get_location("Sage Labyrinth: Sage Left Arm", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Left Arm", player),
lambda state: deep_key(state, player))
add_rule(world.get_location("Sage Labyrinth: Sage Right Arm", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Right Arm", player),
lambda state: deep_key(state, player))
add_rule(world.get_location("Sage Labyrinth: Sage Left Leg", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Left Leg", player),
lambda state: deep_key(state, player))
add_rule(world.get_location("Sage Labyrinth: Sage Right Leg", player),
add_rule(multiworld.get_location("Sage Labyrinth: Sage Right Leg", player),
lambda state: deep_key(state, player))
# Sage Airship
add_rule(world.get_location("Sage Airship: TV", player),
add_rule(multiworld.get_location("Sage Airship: TV", player),
lambda state: all_tokens(state, player))
# Hylemxylem
add_rule(world.get_location("Hylemxylem: Upper Chamber Banana", player),
add_rule(multiworld.get_location("Hylemxylem: Upper Chamber Banana", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Across Upper Reservoir Chest", player),
add_rule(multiworld.get_location("Hylemxylem: Across Upper Reservoir Chest", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Lower Reservoir Chest", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Lower Reservoir Chest", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Lower Reservoir Burrito 1", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Lower Reservoir Burrito 1", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Lower Reservoir Burrito 2", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Lower Reservoir Burrito 2", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Lower Reservoir Hole Pot 1", player),
add_rule(multiworld.get_location("Hylemxylem: Lower Reservoir Hole Pot 1", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Lower Reservoir Hole Pot 2", player),
add_rule(multiworld.get_location("Hylemxylem: Lower Reservoir Hole Pot 2", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Lower Reservoir Hole Pot 3", player),
add_rule(multiworld.get_location("Hylemxylem: Lower Reservoir Hole Pot 3", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Lower Reservoir Hole Sarcophagus", player),
add_rule(multiworld.get_location("Hylemxylem: Lower Reservoir Hole Sarcophagus", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Upper Reservoir Burrito 1", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Upper Reservoir Burrito 1", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Upper Reservoir Burrito 2", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Upper Reservoir Burrito 2", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Drained Upper Reservoir Burrito 3", player),
add_rule(multiworld.get_location("Hylemxylem: Drained Upper Reservoir Burrito 3", player),
lambda state: upper_chamber_key(state, player))
add_rule(world.get_location("Hylemxylem: Upper Reservoir Hole Key", player),
add_rule(multiworld.get_location("Hylemxylem: Upper Reservoir Hole Key", player),
lambda state: upper_chamber_key(state, player))
# extra rules if Extra Items in Logic is enabled
if extra:
for i in world.get_region("Foglast", player).entrances:
for i in multiworld.get_region("Foglast", player).entrances:
add_rule(i, lambda state: charge_up(state, player))
for i in world.get_region("Sage Airship", player).entrances:
for i in multiworld.get_region("Sage Airship", player).entrances:
add_rule(i, lambda state: (
charge_up(state, player)
and paper_cup(state, player)
and worm_room_key(state, player)
))
for i in world.get_region("Hylemxylem", player).entrances:
for i in multiworld.get_region("Hylemxylem", player).entrances:
add_rule(i, lambda state: (
charge_up(state, player)
and paper_cup(state, player)
))
add_rule(world.get_location("Sage Labyrinth: Motor Hunter Sarcophagus", player),
add_rule(multiworld.get_location("Sage Labyrinth: Motor Hunter Sarcophagus", player),
lambda state: (
charge_up(state, player)
and paper_cup(state, player)
@@ -374,9 +374,9 @@ def set_rules(hylics2world):
# extra rules if Shuffle Party Members is enabled
if party:
for i in world.get_region("Arcade Island", player).entrances:
for i in multiworld.get_region("Arcade Island", player).entrances:
add_rule(i, lambda state: party_3(state, player))
for i in world.get_region("Foglast", player).entrances:
for i in multiworld.get_region("Foglast", player).entrances:
add_rule(i, lambda state: (
party_3(state, player)
or (
@@ -384,197 +384,197 @@ def set_rules(hylics2world):
and jail_key(state, player)
)
))
for i in world.get_region("Sage Airship", player).entrances:
for i in multiworld.get_region("Sage Airship", player).entrances:
add_rule(i, lambda state: party_3(state, player))
for i in world.get_region("Hylemxylem", player).entrances:
for i in multiworld.get_region("Hylemxylem", player).entrances:
add_rule(i, lambda state: party_3(state, player))
add_rule(world.get_location("Viewax's Edifice: Defeat Viewax", player),
add_rule(multiworld.get_location("Viewax's Edifice: Defeat Viewax", player),
lambda state: party_2(state, player))
add_rule(world.get_location("New Muldul: Rescued Blerol 1", player),
add_rule(multiworld.get_location("New Muldul: Rescued Blerol 1", player),
lambda state: party_2(state, player))
add_rule(world.get_location("New Muldul: Rescued Blerol 2", player),
add_rule(multiworld.get_location("New Muldul: Rescued Blerol 2", player),
lambda state: party_2(state, player))
add_rule(world.get_location("New Muldul: Vault Left Chest", player),
add_rule(multiworld.get_location("New Muldul: Vault Left Chest", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Right Chest", player),
add_rule(multiworld.get_location("New Muldul: Vault Right Chest", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Bomb", player),
add_rule(multiworld.get_location("New Muldul: Vault Bomb", player),
lambda state: party_3(state, player))
add_rule(world.get_location("Juice Ranch: Battle with Somsnosa", player),
add_rule(multiworld.get_location("Juice Ranch: Battle with Somsnosa", player),
lambda state: party_2(state, player))
add_rule(world.get_location("Juice Ranch: Somsnosa Joins", player),
add_rule(multiworld.get_location("Juice Ranch: Somsnosa Joins", player),
lambda state: party_2(state, player))
add_rule(world.get_location("Airship: Talk to Somsnosa", player),
add_rule(multiworld.get_location("Airship: Talk to Somsnosa", player),
lambda state: party_3(state, player))
add_rule(world.get_location("Sage Labyrinth: Motor Hunter Sarcophagus", player),
add_rule(multiworld.get_location("Sage Labyrinth: Motor Hunter Sarcophagus", player),
lambda state: party_3(state, player))
# extra rules if Shuffle Red Medallions is enabled
if medallion:
add_rule(world.get_location("New Muldul: Upper House Medallion", player),
add_rule(multiworld.get_location("New Muldul: Upper House Medallion", player),
lambda state: upper_house_key(state, player))
add_rule(world.get_location("New Muldul: Vault Rear Left Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Rear Left Medallion", player),
lambda state: (
enter_foglast(state, player)
and bridge_key(state, player)
and air_dash(state, player)
))
add_rule(world.get_location("New Muldul: Vault Rear Right Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Rear Right Medallion", player),
lambda state: (
enter_foglast(state, player)
and bridge_key(state, player)
and air_dash(state, player)
))
add_rule(world.get_location("New Muldul: Vault Center Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Center Medallion", player),
lambda state: (
enter_foglast(state, player)
and bridge_key(state, player)
and air_dash(state, player)
))
add_rule(world.get_location("New Muldul: Vault Front Left Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Front Left Medallion", player),
lambda state: (
enter_foglast(state, player)
and bridge_key(state, player)
and air_dash(state, player)
))
add_rule(world.get_location("New Muldul: Vault Front Right Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Front Right Medallion", player),
lambda state: (
enter_foglast(state, player)
and bridge_key(state, player)
and air_dash(state, player)
))
add_rule(world.get_location("Viewax's Edifice: Fort Wall Medallion", player),
add_rule(multiworld.get_location("Viewax's Edifice: Fort Wall Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Jar Medallion", player),
add_rule(multiworld.get_location("Viewax's Edifice: Jar Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Viewax's Edifice: Sage Chair Medallion", player),
add_rule(multiworld.get_location("Viewax's Edifice: Sage Chair Medallion", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Arcade 1: Lonely Medallion", player),
add_rule(multiworld.get_location("Arcade 1: Lonely Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Alcove Medallion", player),
add_rule(multiworld.get_location("Arcade 1: Alcove Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Arcade 1: Lava Medallion", player),
add_rule(multiworld.get_location("Arcade 1: Lava Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Foglast: Under Lair Medallion", player),
add_rule(multiworld.get_location("Foglast: Under Lair Medallion", player),
lambda state: bridge_key(state, player))
add_rule(world.get_location("Foglast: Mid-Air Medallion", player),
add_rule(multiworld.get_location("Foglast: Mid-Air Medallion", player),
lambda state: air_dash(state, player))
add_rule(world.get_location("Foglast: Top of Tower Medallion", player),
add_rule(multiworld.get_location("Foglast: Top of Tower Medallion", player),
lambda state: paddle(state, player))
add_rule(world.get_location("Hylemxylem: Lower Reservoir Hole Medallion", player),
add_rule(multiworld.get_location("Hylemxylem: Lower Reservoir Hole Medallion", player),
lambda state: upper_chamber_key(state, player))
# extra rules if Shuffle Red Medallions and Party Shuffle are enabled
if party and medallion:
add_rule(world.get_location("New Muldul: Vault Rear Left Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Rear Left Medallion", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Rear Right Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Rear Right Medallion", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Center Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Center Medallion", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Front Left Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Front Left Medallion", player),
lambda state: party_3(state, player))
add_rule(world.get_location("New Muldul: Vault Front Right Medallion", player),
add_rule(multiworld.get_location("New Muldul: Vault Front Right Medallion", player),
lambda state: party_3(state, player))
# entrances
for i in world.get_region("Airship", player).entrances:
for i in multiworld.get_region("Airship", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Arcade Island", player).entrances:
for i in multiworld.get_region("Arcade Island", player).entrances:
add_rule(i, lambda state: (
airship(state, player)
and air_dash(state, player)
))
for i in world.get_region("Worm Pod", player).entrances:
for i in multiworld.get_region("Worm Pod", player).entrances:
add_rule(i, lambda state: enter_wormpod(state, player))
for i in world.get_region("Foglast", player).entrances:
for i in multiworld.get_region("Foglast", player).entrances:
add_rule(i, lambda state: enter_foglast(state, player))
for i in world.get_region("Sage Labyrinth", player).entrances:
for i in multiworld.get_region("Sage Labyrinth", player).entrances:
add_rule(i, lambda state: skull_bomb(state, player))
for i in world.get_region("Sage Airship", player).entrances:
for i in multiworld.get_region("Sage Airship", player).entrances:
add_rule(i, lambda state: enter_sageship(state, player))
for i in world.get_region("Hylemxylem", player).entrances:
for i in multiworld.get_region("Hylemxylem", player).entrances:
add_rule(i, lambda state: enter_hylemxylem(state, player))
# random start logic (default)
if start_location == "waynehouse":
# entrances
for i in world.get_region("Viewax", player).entrances:
for i in multiworld.get_region("Viewax", player).entrances:
add_rule(i, lambda state: (
air_dash(state, player)
and airship(state, player)
))
for i in world.get_region("TV Island", player).entrances:
for i in multiworld.get_region("TV Island", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Shield Facility", player).entrances:
for i in multiworld.get_region("Shield Facility", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Juice Ranch", player).entrances:
for i in multiworld.get_region("Juice Ranch", player).entrances:
add_rule(i, lambda state: airship(state, player))
# random start logic (Viewax's Edifice)
elif start_location == "viewaxs_edifice":
for i in world.get_region("Waynehouse", player).entrances:
for i in multiworld.get_region("Waynehouse", player).entrances:
add_rule(i, lambda state: (
air_dash(state, player)
or airship(state, player)
))
for i in world.get_region("New Muldul", player).entrances:
for i in multiworld.get_region("New Muldul", player).entrances:
add_rule(i, lambda state: (
air_dash(state, player)
or airship(state, player)
))
for i in world.get_region("New Muldul Vault", player).entrances:
for i in multiworld.get_region("New Muldul Vault", player).entrances:
add_rule(i, lambda state: (
air_dash(state, player)
or airship(state, player)
))
for i in world.get_region("Drill Castle", player).entrances:
for i in multiworld.get_region("Drill Castle", player).entrances:
add_rule(i, lambda state: (
air_dash(state, player)
or airship(state, player)
))
for i in world.get_region("TV Island", player).entrances:
for i in multiworld.get_region("TV Island", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Shield Facility", player).entrances:
for i in multiworld.get_region("Shield Facility", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Juice Ranch", player).entrances:
for i in multiworld.get_region("Juice Ranch", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Sage Labyrinth", player).entrances:
for i in multiworld.get_region("Sage Labyrinth", player).entrances:
add_rule(i, lambda state: airship(state, player))
# start logic (TV Island)
elif start_location == "tv_island":
for i in world.get_region("Waynehouse", player).entrances:
for i in multiworld.get_region("Waynehouse", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("New Muldul", player).entrances:
for i in multiworld.get_region("New Muldul", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("New Muldul Vault", player).entrances:
for i in multiworld.get_region("New Muldul Vault", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Drill Castle", player).entrances:
for i in multiworld.get_region("Drill Castle", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Viewax", player).entrances:
for i in multiworld.get_region("Viewax", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Shield Facility", player).entrances:
for i in multiworld.get_region("Shield Facility", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Juice Ranch", player).entrances:
for i in multiworld.get_region("Juice Ranch", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Sage Labyrinth", player).entrances:
for i in multiworld.get_region("Sage Labyrinth", player).entrances:
add_rule(i, lambda state: airship(state, player))
# start logic (Shield Facility)
elif start_location == "shield_facility":
for i in world.get_region("Waynehouse", player).entrances:
for i in multiworld.get_region("Waynehouse", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("New Muldul", player).entrances:
for i in multiworld.get_region("New Muldul", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("New Muldul Vault", player).entrances:
for i in multiworld.get_region("New Muldul Vault", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Drill Castle", player).entrances:
for i in multiworld.get_region("Drill Castle", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Viewax", player).entrances:
for i in multiworld.get_region("Viewax", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("TV Island", player).entrances:
for i in multiworld.get_region("TV Island", player).entrances:
add_rule(i, lambda state: airship(state, player))
for i in world.get_region("Sage Labyrinth", player).entrances:
for i in multiworld.get_region("Sage Labyrinth", player).entrances:
add_rule(i, lambda state: airship(state, player))

4
worlds/mm3/__init__.py
View File

@@ -95,10 +95,10 @@ class MM3World(World):
web = MM3WebWorld()
rom_name: bytearray
def __init__(self, world: MultiWorld, player: int):
def __init__(self, multiworld: MultiWorld, player: int):
self.rom_name = bytearray()
self.rom_name_available_event = threading.Event()
super().__init__(world, player)
super().__init__(multiworld, player)
self.weapon_damage = deepcopy(weapon_damage)
self.wily_4_weapons: dict[int, list[int]] = {}

8
worlds/mmbn3/__init__.py
View File

@@ -463,13 +463,13 @@ class MMBN3World(World):
rompath: str = ""
try:
world = self.multiworld
multiworld = self.multiworld
player = self.player
rom = LocalRom(get_base_rom_path())
for location_name in location_table.keys():
location = world.get_location(location_name, player)
location = multiworld.get_location(location_name, player)
ap_item = location.item
item_id = ap_item.code
if item_id is not None:
@@ -511,7 +511,7 @@ class MMBN3World(World):
rom.insert_hint_text(location_data, item_name_text, long_item_text)
rom.inject_name(world.player_name[player])
rom.inject_name(self.player_name)
rompath = os.path.join(output_directory, f"{self.multiworld.get_out_file_name_base(self.player)}.gba")
@@ -519,7 +519,7 @@ class MMBN3World(World):
rom.write_to_file(rompath)
patch = MMBN3DeltaPatch(os.path.splitext(rompath)[0]+MMBN3DeltaPatch.patch_file_ending, player=player,
player_name=world.player_name[player], patched_path=rompath)
player_name=self.player_name, patched_path=rompath)
patch.write()
except:
raise

6
worlds/oot/EntranceShuffle.py
View File

@@ -8,9 +8,9 @@ from .Hints import get_hint_area, HintAreaNotFound
from .Regions import TimeOfDay
def set_all_entrances_data(world, player):
def set_all_entrances_data(multiworld, player):
for type, forward_entry, *return_entry in entrance_shuffle_table:
forward_entrance = world.get_entrance(forward_entry[0], player)
forward_entrance = multiworld.get_entrance(forward_entry[0], player)
forward_entrance.data = forward_entry[1]
forward_entrance.type = type
forward_entrance.primary = True
@@ -18,7 +18,7 @@ def set_all_entrances_data(world, player):
forward_entrance.data['index'] = 0x1000 + forward_entrance.data['grotto_id']
if return_entry:
return_entry = return_entry[0]
return_entrance = world.get_entrance(return_entry[0], player)
return_entrance = multiworld.get_entrance(return_entry[0], player)
return_entrance.data = return_entry[1]
return_entrance.type = type
forward_entrance.bind_two_way(return_entrance)

6
worlds/oot/ItemPool.py
View File

@@ -336,10 +336,10 @@ def replace_max_item(items, item, max, rand):
def generate_itempool(ootworld):
world = ootworld.multiworld
multiworld = ootworld.multiworld
player = ootworld.player
global random
random = world.random
random = multiworld.random
junk_pool = get_junk_pool(ootworld)
@@ -347,7 +347,7 @@ def generate_itempool(ootworld):
(pool, placed_items) = get_pool_core(ootworld)
ootworld.itempool = [ootworld.create_item(item) for item in pool]
for (location_name, item) in placed_items.items():
location = world.get_location(location_name, player)
location = multiworld.get_location(location_name, player)
location.place_locked_item(ootworld.create_item(item, allow_arbitrary_name=True))

4
worlds/overcooked2/test/TestOvercooked2.py
View File

@@ -199,8 +199,8 @@ class Overcooked2Test(unittest.TestCase):
self.assertIn("Overcooked! 2", AutoWorldRegister.world_types.keys())
world_type = AutoWorldRegister.world_types["Overcooked! 2"]
world = setup_solo_multiworld(world_type)
state = world.get_all_state(False)
multiworld = setup_solo_multiworld(world_type)
state = multiworld.get_all_state(False)
# Test region logic
for logic in overworld_region_logic.values():

4
worlds/raft/__init__.py
View File

@@ -236,8 +236,8 @@ class RaftWorld(World):
"DeathLink": bool(self.options.death_link)
}
def create_region(world: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, world)
def create_region(multiworld: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, multiworld)
if locations:
for location in locations:
loc_id = locations_lookup_name_to_id.get(location, 0)

20
worlds/sm/__init__.py
View File

@@ -116,10 +116,10 @@ class SMWorld(World):
Logic.factory('vanilla')
def __init__(self, world: MultiWorld, player: int):
def __init__(self, multiworld: MultiWorld, player: int):
self.rom_name_available_event = threading.Event()
self.locations = {}
super().__init__(world, player)
super().__init__(multiworld, player)
def generate_early(self):
Logic.factory('vanilla')
@@ -233,8 +233,8 @@ class SMWorld(World):
for key, value1 in accessPoint.intraTransitions.items():
set_entrance_rule(self.multiworld.get_entrance(accessPoint.Name + "->" + key, self.player), self.player, value1)
def create_region(self, world: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, world)
def create_region(self, multiworld: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, multiworld)
if locations:
for loc in locations:
location = self.locations[loc]
@@ -420,10 +420,10 @@ class SMWorld(World):
self.variaRando.randoExec.postProcessItemLocs(self.itemLocs, self.variaRando.args.hideItems)
@classmethod
def stage_post_fill(cls, world):
new_state = CollectionState(world)
def stage_post_fill(cls, multiworld):
new_state = CollectionState(multiworld)
progitempool = []
for item in world.itempool:
for item in multiworld.itempool:
if item.game == "Super Metroid" and item.advancement:
progitempool.append(item)
@@ -431,10 +431,10 @@ class SMWorld(World):
new_state.collect(item, True)
bossesLoc = ['Draygon', 'Kraid', 'Ridley', 'Phantoon', 'Mother Brain']
for player in world.get_game_players("Super Metroid"):
for player in multiworld.get_game_players("Super Metroid"):
for bossLoc in bossesLoc:
if not world.get_location(bossLoc, player).can_reach(new_state):
world.state.smbm[player].onlyBossLeft = True
if not multiworld.get_location(bossLoc, player).can_reach(new_state):
multiworld.state.smbm[player].onlyBossLeft = True
break
def getWordArray(self, w: int) -> List[int]:

78
worlds/sm64ex/Regions.py
View File

@@ -79,12 +79,12 @@ sm64_secrets_to_level = {secret: level for (level,secret) in sm64_level_to_secre
sm64_entrances_to_level = {**sm64_paintings_to_level, **sm64_secrets_to_level }
sm64_level_to_entrances = {**sm64_level_to_paintings, **sm64_level_to_secrets }
def create_regions(world: MultiWorld, options: SM64Options, player: int):
regSS = Region("Menu", player, world, "Castle Area")
def create_regions(multiworld: MultiWorld, options: SM64Options, player: int):
regSS = Region("Menu", player, multiworld, "Castle Area")
create_default_locs(regSS, locSS_table)
world.regions.append(regSS)
multiworld.regions.append(regSS)
regBoB = create_region("Bob-omb Battlefield", player, world)
regBoB = create_region("Bob-omb Battlefield", player, multiworld)
create_locs(regBoB, "BoB: Big Bob-Omb on the Summit", "BoB: Footrace with Koopa The Quick",
"BoB: Mario Wings to the Sky", "BoB: Behind Chain Chomp's Gate", "BoB: Bob-omb Buddy")
bob_island = create_subregion(regBoB, "BoB: Island", "BoB: Shoot to the Island in the Sky", "BoB: Find the 8 Red Coins")
@@ -92,7 +92,7 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(regBoB, "BoB: 100 Coins")
regWhomp = create_region("Whomp's Fortress", player, world)
regWhomp = create_region("Whomp's Fortress", player, multiworld)
create_locs(regWhomp, "WF: Chip Off Whomp's Block", "WF: Shoot into the Wild Blue", "WF: Red Coins on the Floating Isle",
"WF: Fall onto the Caged Island", "WF: Blast Away the Wall")
wf_tower = create_subregion(regWhomp, "WF: Tower", "WF: To the Top of the Fortress", "WF: Bob-omb Buddy")
@@ -100,8 +100,8 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(regWhomp, "WF: 100 Coins")
regJRBDoor = create_region("Jolly Roger Bay Door", player, world)
regJRB = create_region("Jolly Roger Bay", player, world)
regJRBDoor = create_region("Jolly Roger Bay Door", player, multiworld)
regJRB = create_region("Jolly Roger Bay", player, multiworld)
create_locs(regJRB, "JRB: Plunder in the Sunken Ship", "JRB: Can the Eel Come Out to Play?", "JRB: Treasure of the Ocean Cave",
"JRB: Blast to the Stone Pillar", "JRB: Through the Jet Stream", "JRB: Bob-omb Buddy")
jrb_upper = create_subregion(regJRB, 'JRB: Upper', "JRB: Red Coins on the Ship Afloat")
@@ -109,12 +109,12 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(jrb_upper, "JRB: 100 Coins")
regCCM = create_region("Cool, Cool Mountain", player, world)
regCCM = create_region("Cool, Cool Mountain", player, multiworld)
create_default_locs(regCCM, locCCM_table)
if options.enable_coin_stars:
create_locs(regCCM, "CCM: 100 Coins")
regBBH = create_region("Big Boo's Haunt", player, world)
regBBH = create_region("Big Boo's Haunt", player, multiworld)
create_locs(regBBH, "BBH: Go on a Ghost Hunt", "BBH: Ride Big Boo's Merry-Go-Round",
"BBH: Secret of the Haunted Books", "BBH: Seek the 8 Red Coins")
bbh_third_floor = create_subregion(regBBH, "BBH: Third Floor", "BBH: Eye to Eye in the Secret Room")
@@ -123,21 +123,21 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(regBBH, "BBH: 100 Coins")
regPSS = create_region("The Princess's Secret Slide", player, world)
regPSS = create_region("The Princess's Secret Slide", player, multiworld)
create_default_locs(regPSS, locPSS_table)
regSA = create_region("The Secret Aquarium", player, world)
regSA = create_region("The Secret Aquarium", player, multiworld)
create_default_locs(regSA, locSA_table)
regTotWC = create_region("Tower of the Wing Cap", player, world)
regTotWC = create_region("Tower of the Wing Cap", player, multiworld)
create_default_locs(regTotWC, locTotWC_table)
regBitDW = create_region("Bowser in the Dark World", player, world)
regBitDW = create_region("Bowser in the Dark World", player, multiworld)
create_default_locs(regBitDW, locBitDW_table)
create_region("Basement", player, world)
create_region("Basement", player, multiworld)
regHMC = create_region("Hazy Maze Cave", player, world)
regHMC = create_region("Hazy Maze Cave", player, multiworld)
create_locs(regHMC, "HMC: Swimming Beast in the Cavern", "HMC: Metal-Head Mario Can Move!",
"HMC: Watch for Rolling Rocks", "HMC: Navigating the Toxic Maze","HMC: 1Up Block Past Rolling Rocks")
hmc_red_coin_area = create_subregion(regHMC, "HMC: Red Coin Area", "HMC: Elevate for 8 Red Coins")
@@ -146,7 +146,7 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(hmc_red_coin_area, "HMC: 100 Coins")
regLLL = create_region("Lethal Lava Land", player, world)
regLLL = create_region("Lethal Lava Land", player, multiworld)
create_locs(regLLL, "LLL: Boil the Big Bully", "LLL: Bully the Bullies",
"LLL: 8-Coin Puzzle with 15 Pieces", "LLL: Red-Hot Log Rolling")
lll_upper_volcano = create_subregion(regLLL, "LLL: Upper Volcano", "LLL: Hot-Foot-It into the Volcano", "LLL: Elevator Tour in the Volcano")
@@ -154,7 +154,7 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(regLLL, "LLL: 100 Coins")
regSSL = create_region("Shifting Sand Land", player, world)
regSSL = create_region("Shifting Sand Land", player, multiworld)
create_locs(regSSL, "SSL: In the Talons of the Big Bird", "SSL: Shining Atop the Pyramid",
"SSL: Free Flying for 8 Red Coins", "SSL: Bob-omb Buddy",
"SSL: 1Up Block Outside Pyramid", "SSL: 1Up Block Pyramid Left Path", "SSL: 1Up Block Pyramid Back")
@@ -164,30 +164,30 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(regSSL, "SSL: 100 Coins")
regDDD = create_region("Dire, Dire Docks", player, world)
regDDD = create_region("Dire, Dire Docks", player, multiworld)
create_locs(regDDD, "DDD: Board Bowser's Sub", "DDD: Chests in the Current", "DDD: Through the Jet Stream",
"DDD: The Manta Ray's Reward", "DDD: Collect the Caps...", "DDD: Pole-Jumping for Red Coins")
if options.enable_coin_stars:
create_locs(regDDD, "DDD: 100 Coins")
regCotMC = create_region("Cavern of the Metal Cap", player, world)
regCotMC = create_region("Cavern of the Metal Cap", player, multiworld)
create_default_locs(regCotMC, locCotMC_table)
regVCutM = create_region("Vanish Cap under the Moat", player, world)
regVCutM = create_region("Vanish Cap under the Moat", player, multiworld)
create_default_locs(regVCutM, locVCutM_table)
regBitFS = create_region("Bowser in the Fire Sea", player, world)
regBitFS = create_region("Bowser in the Fire Sea", player, multiworld)
bitfs_upper = create_subregion(regBitFS, "BitFS: Upper", *locBitFS_table.keys())
regBitFS.subregions = [bitfs_upper]
create_region("Second Floor", player, world)
create_region("Second Floor", player, multiworld)
regSL = create_region("Snowman's Land", player, world)
regSL = create_region("Snowman's Land", player, multiworld)
create_default_locs(regSL, locSL_table)
if options.enable_coin_stars:
create_locs(regSL, "SL: 100 Coins")
regWDW = create_region("Wet-Dry World", player, world)
regWDW = create_region("Wet-Dry World", player, multiworld)
create_locs(regWDW, "WDW: Express Elevator--Hurry Up!")
wdw_top = create_subregion(regWDW, "WDW: Top", "WDW: Shocking Arrow Lifts!", "WDW: Top o' the Town",
"WDW: Secrets in the Shallows & Sky", "WDW: Bob-omb Buddy")
@@ -196,7 +196,7 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(wdw_top, "WDW: 100 Coins")
regTTM = create_region("Tall, Tall Mountain", player, world)
regTTM = create_region("Tall, Tall Mountain", player, multiworld)
ttm_middle = create_subregion(regTTM, "TTM: Middle", "TTM: Scary 'Shrooms, Red Coins", "TTM: Blast to the Lonely Mushroom",
"TTM: Bob-omb Buddy", "TTM: 1Up Block on Red Mushroom")
ttm_top = create_subregion(ttm_middle, "TTM: Top", "TTM: Scale the Mountain", "TTM: Mystery of the Monkey Cage",
@@ -205,9 +205,9 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(ttm_top, "TTM: 100 Coins")
create_region("Tiny-Huge Island (Huge)", player, world)
create_region("Tiny-Huge Island (Tiny)", player, world)
regTHI = create_region("Tiny-Huge Island", player, world)
create_region("Tiny-Huge Island (Huge)", player, multiworld)
create_region("Tiny-Huge Island (Tiny)", player, multiworld)
regTHI = create_region("Tiny-Huge Island", player, multiworld)
create_locs(regTHI, "THI: 1Up Block THI Small near Start")
thi_pipes = create_subregion(regTHI, "THI: Pipes", "THI: The Tip Top of the Huge Island", "THI: Pluck the Piranha Flower", "THI: Rematch with Koopa the Quick",
"THI: Five Itty Bitty Secrets", "THI: Wiggler's Red Coins", "THI: Bob-omb Buddy",
@@ -217,9 +217,9 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(thi_large_top, "THI: 100 Coins")
regFloor3 = create_region("Third Floor", player, world)
regFloor3 = create_region("Third Floor", player, multiworld)
regTTC = create_region("Tick Tock Clock", player, world)
regTTC = create_region("Tick Tock Clock", player, multiworld)
create_locs(regTTC, "TTC: Stop Time for Red Coins")
ttc_lower = create_subregion(regTTC, "TTC: Lower", "TTC: Roll into the Cage", "TTC: Get a Hand")
ttc_upper = create_subregion(ttc_lower, "TTC: Upper", "TTC: Timed Jumps on Moving Bars", "TTC: The Pit and the Pendulums")
@@ -228,7 +228,7 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(ttc_top, "TTC: 100 Coins")
regRR = create_region("Rainbow Ride", player, world)
regRR = create_region("Rainbow Ride", player, multiworld)
create_locs(regRR, "RR: Swingin' in the Breeze", "RR: Tricky Triangles!",
"RR: 1Up Block Top of Red Coin Maze", "RR: 1Up Block Under Fly Guy", "RR: Bob-omb Buddy")
rr_maze = create_subregion(regRR, "RR: Maze", "RR: Coins Amassed in a Maze")
@@ -238,24 +238,24 @@ def create_regions(world: MultiWorld, options: SM64Options, player: int):
if options.enable_coin_stars:
create_locs(rr_maze, "RR: 100 Coins")
regWMotR = create_region("Wing Mario over the Rainbow", player, world)
regWMotR = create_region("Wing Mario over the Rainbow", player, multiworld)
create_default_locs(regWMotR, locWMotR_table)
regBitS = create_region("Bowser in the Sky", player, world)
regBitS = create_region("Bowser in the Sky", player, multiworld)
create_locs(regBitS, "Bowser in the Sky 1Up Block")
bits_top = create_subregion(regBitS, "BitS: Top", "Bowser in the Sky Red Coins")
regBitS.subregions = [bits_top]
def connect_regions(world: MultiWorld, player: int, source: str, target: str, rule=None) -> Entrance:
sourceRegion = world.get_region(source, player)
targetRegion = world.get_region(target, player)
def connect_regions(multiworld: MultiWorld, player: int, source: str, target: str, rule=None) -> Entrance:
sourceRegion = multiworld.get_region(source, player)
targetRegion = multiworld.get_region(target, player)
return sourceRegion.connect(targetRegion, rule=rule)
def create_region(name: str, player: int, world: MultiWorld) -> SM64Region:
region = SM64Region(name, player, world)
world.regions.append(region)
def create_region(name: str, player: int, multiworld: MultiWorld) -> SM64Region:
region = SM64Region(name, player, multiworld)
multiworld.regions.append(region)
return region

122
worlds/sm64ex/Rules.py
View File

@@ -8,24 +8,24 @@ from .Regions import connect_regions, SM64Levels, sm64_level_to_paintings, sm64_
sm64_level_to_secrets, sm64_secrets_to_level, sm64_entrances_to_level, sm64_level_to_entrances
from .Items import action_item_data_table
def shuffle_dict_keys(world, dictionary: dict) -> dict:
def shuffle_dict_keys(multiworld: MultiWorld, dictionary: dict) -> dict:
keys = list(dictionary.keys())
values = list(dictionary.values())
world.random.shuffle(keys)
multiworld.random.shuffle(keys)
return dict(zip(keys, values))
def fix_reg(entrance_map: Dict[SM64Levels, str], entrance: SM64Levels, invalid_regions: Set[str],
swapdict: Dict[SM64Levels, str], world):
swapdict: Dict[SM64Levels, str], multiworld: MultiWorld):
if entrance_map[entrance] in invalid_regions: # Unlucky :C
replacement_regions = [(rand_entrance, rand_region) for rand_entrance, rand_region in swapdict.items()
if rand_region not in invalid_regions]
rand_entrance, rand_region = world.random.choice(replacement_regions)
rand_entrance, rand_region = multiworld.random.choice(replacement_regions)
old_dest = entrance_map[entrance]
entrance_map[entrance], entrance_map[rand_entrance] = rand_region, old_dest
swapdict[entrance], swapdict[rand_entrance] = rand_region, old_dest
swapdict.pop(entrance)
def set_rules(world, options: SM64Options, player: int, area_connections: dict, star_costs: dict, move_rando_bitvec: int):
def set_rules(multiworld: MultiWorld, options: SM64Options, player: int, area_connections: dict, star_costs: dict, move_rando_bitvec: int):
randomized_level_to_paintings = sm64_level_to_paintings.copy()
randomized_level_to_secrets = sm64_level_to_secrets.copy()
valid_move_randomizer_start_courses = [
@@ -34,100 +34,100 @@ def set_rules(world, options: SM64Options, player: int, area_connections: dict,
"Dire, Dire Docks", "Snowman's Land"
] # Excluding WF, HMC, WDW, TTM, THI, TTC, and RR
if options.area_rando >= 1: # Some randomization is happening, randomize Courses
randomized_level_to_paintings = shuffle_dict_keys(world,sm64_level_to_paintings)
randomized_level_to_paintings = shuffle_dict_keys(multiworld,sm64_level_to_paintings)
# If not shuffling later, ensure a valid start course on move randomizer
if options.area_rando < 3 and move_rando_bitvec > 0:
swapdict = randomized_level_to_paintings.copy()
invalid_start_courses = {course for course in randomized_level_to_paintings.values() if course not in valid_move_randomizer_start_courses}
fix_reg(randomized_level_to_paintings, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, world)
fix_reg(randomized_level_to_paintings, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, world)
fix_reg(randomized_level_to_paintings, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, multiworld)
fix_reg(randomized_level_to_paintings, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, multiworld)
if options.area_rando == 2: # Randomize Secrets as well
randomized_level_to_secrets = shuffle_dict_keys(world,sm64_level_to_secrets)
randomized_level_to_secrets = shuffle_dict_keys(multiworld, sm64_level_to_secrets)
randomized_entrances = {**randomized_level_to_paintings, **randomized_level_to_secrets}
if options.area_rando == 3: # Randomize Courses and Secrets in one pool
randomized_entrances = shuffle_dict_keys(world, randomized_entrances)
randomized_entrances = shuffle_dict_keys(multiworld, randomized_entrances)
# Guarantee first entrance is a course
swapdict = randomized_entrances.copy()
if move_rando_bitvec == 0:
fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, sm64_secrets_to_level.keys(), swapdict, world)
fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, sm64_secrets_to_level.keys(), swapdict, multiworld)
else:
invalid_start_courses = {course for course in randomized_entrances.values() if course not in valid_move_randomizer_start_courses}
fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, world)
fix_reg(randomized_entrances, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, world)
fix_reg(randomized_entrances, SM64Levels.BOB_OMB_BATTLEFIELD, invalid_start_courses, swapdict, multiworld)
fix_reg(randomized_entrances, SM64Levels.WHOMPS_FORTRESS, invalid_start_courses, swapdict, multiworld)
# Guarantee BITFS is not mapped to DDD
fix_reg(randomized_entrances, SM64Levels.BOWSER_IN_THE_FIRE_SEA, {"Dire, Dire Docks"}, swapdict, world)
fix_reg(randomized_entrances, SM64Levels.BOWSER_IN_THE_FIRE_SEA, {"Dire, Dire Docks"}, swapdict, multiworld)
# Guarantee COTMC is not mapped to HMC, cuz thats impossible. If BitFS -> HMC, also no COTMC -> DDD.
if randomized_entrances[SM64Levels.BOWSER_IN_THE_FIRE_SEA] == "Hazy Maze Cave":
fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave", "Dire, Dire Docks"}, swapdict, world)
fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave", "Dire, Dire Docks"}, swapdict, multiworld)
else:
fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave"}, swapdict, world)
fix_reg(randomized_entrances, SM64Levels.CAVERN_OF_THE_METAL_CAP, {"Hazy Maze Cave"}, swapdict, multiworld)
# Destination Format: LVL | AREA with LVL = LEVEL_x, AREA = Area as used in sm64 code
# Cast to int to not rely on availability of SM64Levels enum. Will cause crash in MultiServer otherwise
area_connections.update({int(entrance_lvl): int(sm64_entrances_to_level[destination]) for (entrance_lvl,destination) in randomized_entrances.items()})
randomized_entrances_s = {sm64_level_to_entrances[entrance_lvl]: destination for (entrance_lvl,destination) in randomized_entrances.items()}
rf = RuleFactory(world, options, player, move_rando_bitvec)
rf = RuleFactory(multiworld, options, player, move_rando_bitvec)
connect_regions(world, player, "Menu", randomized_entrances_s["Bob-omb Battlefield"])
connect_regions(world, player, "Menu", randomized_entrances_s["Whomp's Fortress"],
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Bob-omb Battlefield"])
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Whomp's Fortress"],
rf.build_rule("", painting_lvl_name="WF", star_num_req=1))
# JRB door is separated from JRB itself because the secret aquarium can be accessed without entering the painting
connect_regions(world, player, "Menu", "Jolly Roger Bay Door", rf.build_rule("", star_num_req=3))
connect_regions(world, player, "Jolly Roger Bay Door", randomized_entrances_s["Jolly Roger Bay"],
connect_regions(multiworld, player, "Menu", "Jolly Roger Bay Door", rf.build_rule("", star_num_req=3))
connect_regions(multiworld, player, "Jolly Roger Bay Door", randomized_entrances_s["Jolly Roger Bay"],
rf.build_rule("", painting_lvl_name="JRB"))
connect_regions(world, player, "Menu", randomized_entrances_s["Cool, Cool Mountain"],
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Cool, Cool Mountain"],
rf.build_rule("", painting_lvl_name="CCM", star_num_req=3))
connect_regions(world, player, "Menu", randomized_entrances_s["Big Boo's Haunt"], lambda state: state.has("Power Star", player, 12))
connect_regions(world, player, "Menu", randomized_entrances_s["The Princess's Secret Slide"], lambda state: state.has("Power Star", player, 1))
connect_regions(world, player, "Jolly Roger Bay Door", randomized_entrances_s["The Secret Aquarium"],
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Big Boo's Haunt"], lambda state: state.has("Power Star", player, 12))
connect_regions(multiworld, player, "Menu", randomized_entrances_s["The Princess's Secret Slide"], lambda state: state.has("Power Star", player, 1))
connect_regions(multiworld, player, "Jolly Roger Bay Door", randomized_entrances_s["The Secret Aquarium"],
rf.build_rule("SF/BF | TJ & LG | MOVELESS & TJ"))
connect_regions(world, player, "Menu", randomized_entrances_s["Tower of the Wing Cap"], lambda state: state.has("Power Star", player, 10))
connect_regions(world, player, "Menu", randomized_entrances_s["Bowser in the Dark World"],
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Tower of the Wing Cap"], lambda state: state.has("Power Star", player, 10))
connect_regions(multiworld, player, "Menu", randomized_entrances_s["Bowser in the Dark World"],
lambda state: state.has("Power Star", player, star_costs["FirstBowserDoorCost"]))
connect_regions(world, player, "Menu", "Basement", lambda state: state.has("Basement Key", player) or state.has("Progressive Key", player, 1))
connect_regions(multiworld, player, "Menu", "Basement", lambda state: state.has("Basement Key", player) or state.has("Progressive Key", player, 1))
connect_regions(world, player, "Basement", randomized_entrances_s["Hazy Maze Cave"])
connect_regions(world, player, "Basement", randomized_entrances_s["Lethal Lava Land"],
connect_regions(multiworld, player, "Basement", randomized_entrances_s["Hazy Maze Cave"])
connect_regions(multiworld, player, "Basement", randomized_entrances_s["Lethal Lava Land"],
rf.build_rule("", painting_lvl_name="LLL"))
connect_regions(world, player, "Basement", randomized_entrances_s["Shifting Sand Land"],
connect_regions(multiworld, player, "Basement", randomized_entrances_s["Shifting Sand Land"],
rf.build_rule("", painting_lvl_name="SSL"))
connect_regions(world, player, "Basement", randomized_entrances_s["Dire, Dire Docks"],
connect_regions(multiworld, player, "Basement", randomized_entrances_s["Dire, Dire Docks"],
rf.build_rule("", painting_lvl_name="DDD", star_num_req=star_costs["BasementDoorCost"]))
connect_regions(world, player, "Hazy Maze Cave", randomized_entrances_s["Cavern of the Metal Cap"])
connect_regions(world, player, "Basement", randomized_entrances_s["Vanish Cap under the Moat"],
connect_regions(multiworld, player, "Hazy Maze Cave", randomized_entrances_s["Cavern of the Metal Cap"])
connect_regions(multiworld, player, "Basement", randomized_entrances_s["Vanish Cap under the Moat"],
rf.build_rule("GP"))
entrance = connect_regions(world, player, "Basement", randomized_entrances_s["Bowser in the Fire Sea"],
entrance = connect_regions(multiworld, player, "Basement", randomized_entrances_s["Bowser in the Fire Sea"],
lambda state: state.has("Power Star", player, star_costs["BasementDoorCost"]) and
state.can_reach("DDD: Board Bowser's Sub", 'Location', player))
# Access to "DDD: Board Bowser's Sub" does not require access to other locations or regions, so the only region that
# needs to be registered is its parent region.
world.register_indirect_condition(world.get_location("DDD: Board Bowser's Sub", player).parent_region, entrance)
multiworld.register_indirect_condition(multiworld.get_location("DDD: Board Bowser's Sub", player).parent_region, entrance)
connect_regions(world, player, "Menu", "Second Floor", lambda state: state.has("Second Floor Key", player) or state.has("Progressive Key", player, 2))
connect_regions(multiworld, player, "Menu", "Second Floor", lambda state: state.has("Second Floor Key", player) or state.has("Progressive Key", player, 2))
connect_regions(world, player, "Second Floor", randomized_entrances_s["Snowman's Land"],
connect_regions(multiworld, player, "Second Floor", randomized_entrances_s["Snowman's Land"],
rf.build_rule("", painting_lvl_name="SL"))
connect_regions(world, player, "Second Floor", randomized_entrances_s["Wet-Dry World"],
connect_regions(multiworld, player, "Second Floor", randomized_entrances_s["Wet-Dry World"],
rf.build_rule("", painting_lvl_name="WDW"))
connect_regions(world, player, "Second Floor", randomized_entrances_s["Tall, Tall Mountain"],
connect_regions(multiworld, player, "Second Floor", randomized_entrances_s["Tall, Tall Mountain"],
rf.build_rule("", painting_lvl_name="TTM"))
connect_regions(world, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Tiny)"],
connect_regions(multiworld, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Tiny)"],
rf.build_rule("", painting_lvl_name="THI"))
connect_regions(world, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Huge)"],
connect_regions(multiworld, player, "Second Floor", randomized_entrances_s["Tiny-Huge Island (Huge)"],
rf.build_rule("", painting_lvl_name="THI"))
connect_regions(world, player, "Tiny-Huge Island (Tiny)", "Tiny-Huge Island")
connect_regions(world, player, "Tiny-Huge Island (Huge)", "Tiny-Huge Island")
connect_regions(multiworld, player, "Tiny-Huge Island (Tiny)", "Tiny-Huge Island")
connect_regions(multiworld, player, "Tiny-Huge Island (Huge)", "Tiny-Huge Island")
connect_regions(world, player, "Second Floor", "Third Floor", lambda state: state.has("Power Star", player, star_costs["SecondFloorDoorCost"]))
connect_regions(multiworld, player, "Second Floor", "Third Floor", lambda state: state.has("Power Star", player, star_costs["SecondFloorDoorCost"]))
connect_regions(world, player, "Third Floor", randomized_entrances_s["Tick Tock Clock"],
connect_regions(multiworld, player, "Third Floor", randomized_entrances_s["Tick Tock Clock"],
rf.build_rule("LG/TJ/SF/BF/WK", painting_lvl_name="TTC"))
connect_regions(world, player, "Third Floor", randomized_entrances_s["Rainbow Ride"], rf.build_rule("TJ/SF/BF"))
connect_regions(world, player, "Third Floor", randomized_entrances_s["Wing Mario over the Rainbow"], rf.build_rule("TJ/SF/BF"))
connect_regions(world, player, "Third Floor", "Bowser in the Sky", lambda state: state.has("Power Star", player, star_costs["StarsToFinish"]))
connect_regions(multiworld, player, "Third Floor", randomized_entrances_s["Rainbow Ride"], rf.build_rule("TJ/SF/BF"))
connect_regions(multiworld, player, "Third Floor", randomized_entrances_s["Wing Mario over the Rainbow"], rf.build_rule("TJ/SF/BF"))
connect_regions(multiworld, player, "Third Floor", "Bowser in the Sky", lambda state: state.has("Power Star", player, star_costs["StarsToFinish"]))
# Course Rules
# Bob-omb Battlefield
@@ -229,30 +229,30 @@ def set_rules(world, options: SM64Options, player: int, area_connections: dict,
rf.assign_rule("THI: 100 Coins", "GP")
rf.assign_rule("RR: 100 Coins", "GP & WK")
# Castle Stars
add_rule(world.get_location("Toad (Basement)", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, 12))
add_rule(world.get_location("Toad (Second Floor)", player), lambda state: state.can_reach("Second Floor", 'Region', player) and state.has("Power Star", player, 25))
add_rule(world.get_location("Toad (Third Floor)", player), lambda state: state.can_reach("Third Floor", 'Region', player) and state.has("Power Star", player, 35))
add_rule(multiworld.get_location("Toad (Basement)", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, 12))
add_rule(multiworld.get_location("Toad (Second Floor)", player), lambda state: state.can_reach("Second Floor", 'Region', player) and state.has("Power Star", player, 25))
add_rule(multiworld.get_location("Toad (Third Floor)", player), lambda state: state.can_reach("Third Floor", 'Region', player) and state.has("Power Star", player, 35))
if star_costs["MIPS1Cost"] > star_costs["MIPS2Cost"]:
(star_costs["MIPS2Cost"], star_costs["MIPS1Cost"]) = (star_costs["MIPS1Cost"], star_costs["MIPS2Cost"])
rf.assign_rule("MIPS 1", "DV | MOVELESS")
rf.assign_rule("MIPS 2", "DV | MOVELESS")
add_rule(world.get_location("MIPS 1", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS1Cost"]))
add_rule(world.get_location("MIPS 2", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS2Cost"]))
add_rule(multiworld.get_location("MIPS 1", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS1Cost"]))
add_rule(multiworld.get_location("MIPS 2", player), lambda state: state.can_reach("Basement", 'Region', player) and state.has("Power Star", player, star_costs["MIPS2Cost"]))
world.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player)
multiworld.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player)
if options.completion_type == "last_bowser_stage":
world.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player)
multiworld.completion_condition[player] = lambda state: state.can_reach("BitS: Top", 'Region', player)
elif options.completion_type == "all_bowser_stages":
world.completion_condition[player] = lambda state: state.can_reach("Bowser in the Dark World", 'Region', player) and \
multiworld.completion_condition[player] = lambda state: state.can_reach("Bowser in the Dark World", 'Region', player) and \
state.can_reach("BitFS: Upper", 'Region', player) and \
state.can_reach("BitS: Top", 'Region', player)
class RuleFactory:
world: MultiWorld
multiworld: MultiWorld
player: int
move_rando_bitvec: bool
area_randomizer: bool
@@ -280,8 +280,8 @@ class RuleFactory:
class SM64LogicException(Exception):
pass
def __init__(self, world, options: SM64Options, player: int, move_rando_bitvec: int):
self.world = world
def __init__(self, multiworld, options: SM64Options, player: int, move_rando_bitvec: int):
self.multiworld = multiworld
self.player = player
self.move_rando_bitvec = move_rando_bitvec
self.area_randomizer = options.area_rando > 0
@@ -291,7 +291,7 @@ class RuleFactory:
self.moveless = not options.strict_move_requirements
def assign_rule(self, target_name: str, rule_expr: str):
target = self.world.get_location(target_name, self.player) if target_name in location_table else self.world.get_entrance(target_name, self.player)
target = self.multiworld.get_location(target_name, self.player) if target_name in location_table else self.multiworld.get_entrance(target_name, self.player)
cannon_name = "Cannon Unlock " + target_name.split(':')[0]
try:
rule = self.build_rule(rule_expr, cannon_name)

8
worlds/smz3/__init__.py
View File

@@ -83,7 +83,7 @@ class SMZ3World(World):
# optimized message queues for 0.4.4
required_client_version = (0, 4, 4)
def __init__(self, world: MultiWorld, player: int):
def __init__(self, multiworld: MultiWorld, player: int):
self.rom_name_available_event = threading.Event()
self.locations: Dict[str, Location] = {}
self.unreachable = []
@@ -101,7 +101,7 @@ class SMZ3World(World):
ItemType.Super,
ItemType.PowerBomb
]]
super().__init__(world, player)
super().__init__(multiworld, player)
@classmethod
def isProgression(cls, itemType):
@@ -672,8 +672,8 @@ class SMZ3World(World):
self.locations[name] = newLoc
self.smz3World.locationLookup[name].APLocation = newLoc
def create_region(self, world: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, world)
def create_region(self, multiworld: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, multiworld)
if locations:
for loc in locations:
location = self.locations[loc]

376
worlds/timespinner/Regions.py
View File

@@ -6,200 +6,200 @@ from .PreCalculatedWeights import PreCalculatedWeights
from .LogicExtensions import TimespinnerLogic
def create_regions_and_locations(world: MultiWorld, player: int, options: TimespinnerOptions,
def create_regions_and_locations(multiworld: MultiWorld, player: int, options: TimespinnerOptions,
precalculated_weights: PreCalculatedWeights):
locations_per_region: Dict[str, List[LocationData]] = split_location_datas_per_region(
get_location_datas(player, options, precalculated_weights))
regions = [
create_region(world, player, locations_per_region, 'Menu'),
create_region(world, player, locations_per_region, 'Tutorial'),
create_region(world, player, locations_per_region, 'Lake desolation'),
create_region(world, player, locations_per_region, 'Upper lake desolation'),
create_region(world, player, locations_per_region, 'Lower lake desolation'),
create_region(world, player, locations_per_region, 'Eastern lake desolation'),
create_region(world, player, locations_per_region, 'Library'),
create_region(world, player, locations_per_region, 'Library top'),
create_region(world, player, locations_per_region, 'Varndagroth tower left'),
create_region(world, player, locations_per_region, 'Varndagroth tower right (upper)'),
create_region(world, player, locations_per_region, 'Varndagroth tower right (lower)'),
create_region(world, player, locations_per_region, 'Varndagroth tower right (elevator)'),
create_region(world, player, locations_per_region, 'Sealed Caves (Sirens)'),
create_region(world, player, locations_per_region, 'Military Fortress'),
create_region(world, player, locations_per_region, 'Military Fortress (hangar)'),
create_region(world, player, locations_per_region, 'Lab Entrance'),
create_region(world, player, locations_per_region, 'Main Lab'),
create_region(world, player, locations_per_region, 'Lab Research'),
create_region(world, player, locations_per_region, 'The lab (upper)'),
create_region(world, player, locations_per_region, 'Emperors tower (courtyard)'),
create_region(world, player, locations_per_region, 'Emperors tower'),
create_region(world, player, locations_per_region, 'Skeleton Shaft'),
create_region(world, player, locations_per_region, 'Sealed Caves (Xarion)'),
create_region(world, player, locations_per_region, 'Refugee Camp'),
create_region(world, player, locations_per_region, 'Forest'),
create_region(world, player, locations_per_region, 'Left Side forest Caves'),
create_region(world, player, locations_per_region, 'Upper Lake Serene'),
create_region(world, player, locations_per_region, 'Lower Lake Serene'),
create_region(world, player, locations_per_region, 'Caves of Banishment (upper)'),
create_region(world, player, locations_per_region, 'Caves of Banishment (Maw)'),
create_region(world, player, locations_per_region, 'Caves of Banishment (Flooded)'),
create_region(world, player, locations_per_region, 'Caves of Banishment (Sirens)'),
create_region(world, player, locations_per_region, 'Castle Ramparts'),
create_region(world, player, locations_per_region, 'Castle Keep'),
create_region(world, player, locations_per_region, 'Castle Basement'),
create_region(world, player, locations_per_region, 'Royal towers (lower)'),
create_region(world, player, locations_per_region, 'Royal towers'),
create_region(world, player, locations_per_region, 'Royal towers (upper)'),
create_region(world, player, locations_per_region, 'Temporal Gyre'),
create_region(world, player, locations_per_region, 'Ancient Pyramid (entrance)'),
create_region(world, player, locations_per_region, 'Ancient Pyramid (left)'),
create_region(world, player, locations_per_region, 'Ancient Pyramid (right)'),
create_region(world, player, locations_per_region, 'Space time continuum')
create_region(multiworld, player, locations_per_region, 'Menu'),
create_region(multiworld, player, locations_per_region, 'Tutorial'),
create_region(multiworld, player, locations_per_region, 'Lake desolation'),
create_region(multiworld, player, locations_per_region, 'Upper lake desolation'),
create_region(multiworld, player, locations_per_region, 'Lower lake desolation'),
create_region(multiworld, player, locations_per_region, 'Eastern lake desolation'),
create_region(multiworld, player, locations_per_region, 'Library'),
create_region(multiworld, player, locations_per_region, 'Library top'),
create_region(multiworld, player, locations_per_region, 'Varndagroth tower left'),
create_region(multiworld, player, locations_per_region, 'Varndagroth tower right (upper)'),
create_region(multiworld, player, locations_per_region, 'Varndagroth tower right (lower)'),
create_region(multiworld, player, locations_per_region, 'Varndagroth tower right (elevator)'),
create_region(multiworld, player, locations_per_region, 'Sealed Caves (Sirens)'),
create_region(multiworld, player, locations_per_region, 'Military Fortress'),
create_region(multiworld, player, locations_per_region, 'Military Fortress (hangar)'),
create_region(multiworld, player, locations_per_region, 'Lab Entrance'),
create_region(multiworld, player, locations_per_region, 'Main Lab'),
create_region(multiworld, player, locations_per_region, 'Lab Research'),
create_region(multiworld, player, locations_per_region, 'The lab (upper)'),
create_region(multiworld, player, locations_per_region, 'Emperors tower (courtyard)'),
create_region(multiworld, player, locations_per_region, 'Emperors tower'),
create_region(multiworld, player, locations_per_region, 'Skeleton Shaft'),
create_region(multiworld, player, locations_per_region, 'Sealed Caves (Xarion)'),
create_region(multiworld, player, locations_per_region, 'Refugee Camp'),
create_region(multiworld, player, locations_per_region, 'Forest'),
create_region(multiworld, player, locations_per_region, 'Left Side forest Caves'),
create_region(multiworld, player, locations_per_region, 'Upper Lake Serene'),
create_region(multiworld, player, locations_per_region, 'Lower Lake Serene'),
create_region(multiworld, player, locations_per_region, 'Caves of Banishment (upper)'),
create_region(multiworld, player, locations_per_region, 'Caves of Banishment (Maw)'),
create_region(multiworld, player, locations_per_region, 'Caves of Banishment (Flooded)'),
create_region(multiworld, player, locations_per_region, 'Caves of Banishment (Sirens)'),
create_region(multiworld, player, locations_per_region, 'Castle Ramparts'),
create_region(multiworld, player, locations_per_region, 'Castle Keep'),
create_region(multiworld, player, locations_per_region, 'Castle Basement'),
create_region(multiworld, player, locations_per_region, 'Royal towers (lower)'),
create_region(multiworld, player, locations_per_region, 'Royal towers'),
create_region(multiworld, player, locations_per_region, 'Royal towers (upper)'),
create_region(multiworld, player, locations_per_region, 'Temporal Gyre'),
create_region(multiworld, player, locations_per_region, 'Ancient Pyramid (entrance)'),
create_region(multiworld, player, locations_per_region, 'Ancient Pyramid (left)'),
create_region(multiworld, player, locations_per_region, 'Ancient Pyramid (right)'),
create_region(multiworld, player, locations_per_region, 'Space time continuum')
]
if options.gyre_archives:
regions.extend([
create_region(world, player, locations_per_region, 'Ravenlord\'s Lair'),
create_region(world, player, locations_per_region, 'Ifrit\'s Lair'),
create_region(multiworld, player, locations_per_region, 'Ravenlord\'s Lair'),
create_region(multiworld, player, locations_per_region, 'Ifrit\'s Lair'),
])
if __debug__:
throwIfAnyLocationIsNotAssignedToARegion(regions, locations_per_region.keys())
world.regions += regions
multiworld.regions += regions
connectStartingRegion(world, player, options)
connectStartingRegion(multiworld, player, options)
flooded: PreCalculatedWeights = precalculated_weights
logic = TimespinnerLogic(player, options, precalculated_weights)
connect(world, player, 'Lake desolation', 'Lower lake desolation', lambda state: flooded.flood_lake_desolation or logic.has_timestop(state) or state.has('Talaria Attachment', player))
connect(world, player, 'Lake desolation', 'Upper lake desolation', lambda state: logic.has_fire(state) and state.can_reach('Upper Lake Serene', 'Region', player), "Upper Lake Serene")
connect(world, player, 'Lake desolation', 'Skeleton Shaft', lambda state: flooded.flood_lake_desolation or logic.has_doublejump(state))
connect(world, player, 'Lake desolation', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Upper lake desolation', 'Lake desolation')
connect(world, player, 'Upper lake desolation', 'Eastern lake desolation')
connect(world, player, 'Lower lake desolation', 'Lake desolation')
connect(world, player, 'Lower lake desolation', 'Eastern lake desolation')
connect(world, player, 'Eastern lake desolation', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Eastern lake desolation', 'Library')
connect(world, player, 'Eastern lake desolation', 'Lower lake desolation')
connect(world, player, 'Eastern lake desolation', 'Upper lake desolation', lambda state: logic.has_fire(state) and state.can_reach('Upper Lake Serene', 'Region', player), "Upper Lake Serene")
connect(world, player, 'Library', 'Eastern lake desolation')
connect(world, player, 'Library', 'Library top', lambda state: logic.has_doublejump(state) or state.has('Talaria Attachment', player))
connect(world, player, 'Library', 'Varndagroth tower left', logic.has_keycard_D)
connect(world, player, 'Library', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Library top', 'Library')
connect(world, player, 'Varndagroth tower left', 'Library')
connect(world, player, 'Varndagroth tower left', 'Varndagroth tower right (upper)', logic.has_keycard_C)
connect(world, player, 'Varndagroth tower left', 'Varndagroth tower right (lower)', logic.has_keycard_B)
connect(world, player, 'Varndagroth tower left', 'Sealed Caves (Sirens)', lambda state: logic.has_keycard_B(state) and state.has('Elevator Keycard', player))
connect(world, player, 'Varndagroth tower left', 'Refugee Camp', lambda state: state.has('Timespinner Wheel', player) and state.has('Timespinner Spindle', player))
connect(world, player, 'Varndagroth tower right (upper)', 'Varndagroth tower left')
connect(world, player, 'Varndagroth tower right (upper)', 'Varndagroth tower right (elevator)', lambda state: state.has('Elevator Keycard', player))
connect(world, player, 'Varndagroth tower right (elevator)', 'Varndagroth tower right (upper)')
connect(world, player, 'Varndagroth tower right (elevator)', 'Varndagroth tower right (lower)')
connect(world, player, 'Varndagroth tower right (lower)', 'Varndagroth tower left', logic.has_keycard_B)
connect(world, player, 'Varndagroth tower right (lower)', 'Varndagroth tower right (elevator)', lambda state: state.has('Elevator Keycard', player))
connect(world, player, 'Varndagroth tower right (lower)', 'Sealed Caves (Sirens)', lambda state: logic.has_keycard_B(state) and state.has('Elevator Keycard', player))
connect(world, player, 'Varndagroth tower right (lower)', 'Military Fortress', logic.can_kill_all_3_bosses)
connect(world, player, 'Varndagroth tower right (lower)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Sealed Caves (Sirens)', 'Varndagroth tower left', lambda state: state.has('Elevator Keycard', player))
connect(world, player, 'Sealed Caves (Sirens)', 'Varndagroth tower right (lower)', lambda state: state.has('Elevator Keycard', player))
connect(world, player, 'Sealed Caves (Sirens)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Military Fortress', 'Varndagroth tower right (lower)', logic.can_kill_all_3_bosses)
connect(world, player, 'Military Fortress', 'Temporal Gyre', lambda state: state.has('Timespinner Wheel', player) and logic.can_kill_all_3_bosses(state))
connect(world, player, 'Military Fortress', 'Military Fortress (hangar)', logic.has_doublejump)
connect(world, player, 'Military Fortress (hangar)', 'Military Fortress')
connect(world, player, 'Military Fortress (hangar)', 'Lab Entrance', lambda state: state.has('Water Mask', player) if flooded.flood_lab else logic.has_doublejump(state))
connect(world, player, 'Lab Entrance', 'Main Lab', lambda state: logic.has_keycard_B(state))
connect(world, player, 'Main Lab', 'Lab Entrance')
connect(world, player, 'Lab Entrance', 'Military Fortress (hangar)')
connect(world, player, 'Temporal Gyre', 'Military Fortress')
connect(world, player, 'Main Lab', 'Lab Research', lambda state: state.has('Lab Access Research', player) if options.lock_key_amadeus else logic.has_doublejump_of_npc(state))
connect(world, player, 'Main Lab', 'The lab (upper)', lambda state: logic.has_forwarddash_doublejump(state) and ((not options.lock_key_amadeus) or state.has('Lab Access Genza', player)))
connect(world, player, 'The lab (upper)', 'Main Lab', lambda state: options.lock_key_amadeus and state.has('Lab Access Genza', player))
connect(world, player, 'The lab (upper)', 'Emperors tower (courtyard)', logic.has_forwarddash_doublejump)
connect(world, player, 'The lab (upper)', 'Ancient Pyramid (entrance)', lambda state: state.has_all({'Timespinner Wheel', 'Timespinner Spindle', 'Timespinner Gear 1', 'Timespinner Gear 2', 'Timespinner Gear 3'}, player))
connect(world, player, 'Emperors tower (courtyard)', 'The lab (upper)')
connect(world, player, 'Emperors tower (courtyard)', 'Emperors tower', logic.has_doublejump)
connect(world, player, 'Emperors tower', 'Emperors tower (courtyard)')
connect(world, player, 'Skeleton Shaft', 'Lake desolation')
connect(world, player, 'Skeleton Shaft', 'Sealed Caves (Xarion)', logic.has_keycard_A)
connect(world, player, 'Skeleton Shaft', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Sealed Caves (Xarion)', 'Skeleton Shaft')
connect(world, player, 'Sealed Caves (Xarion)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Refugee Camp', 'Forest')
connect(world, player, 'Refugee Camp', 'Library', lambda state: (options.pyramid_start or options.inverted) and options.back_to_the_future and state.has_all({'Timespinner Wheel', 'Timespinner Spindle'}, player))
connect(world, player, 'Refugee Camp', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Forest', 'Refugee Camp')
connect(world, player, 'Forest', 'Left Side forest Caves', lambda state: flooded.flood_lake_serene_bridge or state.has('Talaria Attachment', player) or logic.has_timestop(state))
connect(world, player, 'Forest', 'Caves of Banishment (Sirens)')
connect(world, player, 'Forest', 'Castle Ramparts', lambda state: not options.gate_keep or state.has('Drawbridge Key', player) or logic.has_upwarddash(state))
connect(world, player, 'Left Side forest Caves', 'Forest')
connect(world, player, 'Left Side forest Caves', 'Upper Lake Serene', logic.has_timestop)
connect(world, player, 'Left Side forest Caves', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(world, player, 'Left Side forest Caves', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Upper Lake Serene', 'Left Side forest Caves')
connect(world, player, 'Upper Lake Serene', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(world, player, 'Lower Lake Serene', 'Upper Lake Serene')
connect(world, player, 'Lower Lake Serene', 'Left Side forest Caves')
connect(world, player, 'Lower Lake Serene', 'Caves of Banishment (upper)', lambda state: flooded.flood_lake_serene or logic.has_doublejump(state))
connect(world, player, 'Caves of Banishment (upper)', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(world, player, 'Caves of Banishment (upper)', 'Caves of Banishment (Maw)', lambda state: not flooded.flood_maw or state.has('Water Mask', player))
connect(world, player, 'Caves of Banishment (upper)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (upper)', lambda state: logic.has_doublejump(state) if not flooded.flood_maw else state.has('Water Mask', player))
connect(world, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (Sirens)', lambda state: state.has_any({'Gas Mask', 'Talaria Attachment'}, player) )
connect(world, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (Flooded)', lambda state: flooded.flood_maw or state.has('Water Mask', player))
connect(world, player, 'Caves of Banishment (Maw)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Caves of Banishment (Sirens)', 'Forest')
connect(world, player, 'Castle Ramparts', 'Forest')
connect(world, player, 'Castle Ramparts', 'Castle Keep')
connect(world, player, 'Castle Ramparts', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Castle Keep', 'Castle Ramparts')
connect(world, player, 'Castle Keep', 'Castle Basement', lambda state: not flooded.flood_basement or state.has('Water Mask', player))
connect(world, player, 'Castle Keep', 'Royal towers (lower)', lambda state: logic.has_doublejump(state) and (not options.royal_roadblock or logic.has_pink(state)))
connect(world, player, 'Castle Keep', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Royal towers (lower)', 'Castle Keep')
connect(world, player, 'Royal towers (lower)', 'Royal towers', lambda state: state.has('Timespinner Wheel', player) or logic.has_forwarddash_doublejump(state))
connect(world, player, 'Royal towers (lower)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Royal towers', 'Royal towers (lower)')
connect(world, player, 'Royal towers', 'Royal towers (upper)', logic.has_doublejump)
connect(world, player, 'Royal towers (upper)', 'Royal towers')
#connect(world, player, 'Ancient Pyramid (entrance)', 'The lab (upper)', lambda state: not is_option_enabled(world, player, "EnterSandman"))
connect(world, player, 'Ancient Pyramid (entrance)', 'Ancient Pyramid (left)', logic.has_doublejump)
connect(world, player, 'Ancient Pyramid (entrance)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Ancient Pyramid (left)', 'Ancient Pyramid (entrance)')
connect(world, player, 'Ancient Pyramid (left)', 'Ancient Pyramid (right)', lambda state: flooded.flood_pyramid_shaft or logic.has_upwarddash(state))
connect(world, player, 'Ancient Pyramid (left)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Ancient Pyramid (right)', 'Ancient Pyramid (left)', lambda state: flooded.flood_pyramid_shaft or logic.has_upwarddash(state))
connect(world, player, 'Ancient Pyramid (right)', 'Space time continuum', logic.has_teleport)
connect(world, player, 'Space time continuum', 'Lake desolation', lambda state: logic.can_teleport_to(state, "Present", "GateLakeDesolation"))
connect(world, player, 'Space time continuum', 'Lower lake desolation', lambda state: logic.can_teleport_to(state, "Present", "GateKittyBoss"))
connect(world, player, 'Space time continuum', 'Library', lambda state: logic.can_teleport_to(state, "Present", "GateLeftLibrary"))
connect(world, player, 'Space time continuum', 'Varndagroth tower right (lower)', lambda state: logic.can_teleport_to(state, "Present", "GateMilitaryGate"))
connect(world, player, 'Space time continuum', 'Skeleton Shaft', lambda state: logic.can_teleport_to(state, "Present", "GateSealedCaves"))
connect(world, player, 'Space time continuum', 'Sealed Caves (Sirens)', lambda state: logic.can_teleport_to(state, "Present", "GateSealedSirensCave"))
connect(world, player, 'Space time continuum', 'Sealed Caves (Xarion)', lambda state: logic.can_teleport_to(state, "Present", "GateXarion"))
connect(world, player, 'Space time continuum', 'Upper Lake Serene', lambda state: logic.can_teleport_to(state, "Past", "GateLakeSereneLeft"))
connect(world, player, 'Space time continuum', 'Left Side forest Caves', lambda state: logic.can_teleport_to(state, "Past", "GateLakeSereneRight"))
connect(world, player, 'Space time continuum', 'Refugee Camp', lambda state: logic.can_teleport_to(state, "Past", "GateAccessToPast"))
connect(world, player, 'Space time continuum', 'Forest', lambda state: logic.can_teleport_to(state, "Past", "GateCastleRamparts"))
connect(world, player, 'Space time continuum', 'Castle Keep', lambda state: logic.can_teleport_to(state, "Past", "GateCastleKeep"))
connect(world, player, 'Space time continuum', 'Royal towers (lower)', lambda state: logic.can_teleport_to(state, "Past", "GateRoyalTowers"))
connect(world, player, 'Space time continuum', 'Caves of Banishment (Maw)', lambda state: logic.can_teleport_to(state, "Past", "GateMaw"))
connect(world, player, 'Space time continuum', 'Caves of Banishment (upper)', lambda state: logic.can_teleport_to(state, "Past", "GateCavesOfBanishment"))
connect(world, player, 'Space time continuum', 'Military Fortress (hangar)', lambda state: logic.can_teleport_to(state, "Present", "GateLabEntrance"))
connect(world, player, 'Space time continuum', 'The lab (upper)', lambda state: logic.can_teleport_to(state, "Present", "GateDadsTower"))
connect(world, player, 'Space time continuum', 'Ancient Pyramid (entrance)', lambda state: logic.can_teleport_to(state, "Time", "GateGyre") or logic.can_teleport_to(state, "Time", "GateLeftPyramid") or (not options.unchained_keys and options.enter_sandman))
connect(world, player, 'Space time continuum', 'Ancient Pyramid (right)', lambda state: logic.can_teleport_to(state, "Time", "GateRightPyramid"))
connect(multiworld, player, 'Lake desolation', 'Lower lake desolation', lambda state: flooded.flood_lake_desolation or logic.has_timestop(state) or state.has('Talaria Attachment', player))
connect(multiworld, player, 'Lake desolation', 'Upper lake desolation', lambda state: logic.has_fire(state) and state.can_reach('Upper Lake Serene', 'Region', player), "Upper Lake Serene")
connect(multiworld, player, 'Lake desolation', 'Skeleton Shaft', lambda state: flooded.flood_lake_desolation or logic.has_doublejump(state))
connect(multiworld, player, 'Lake desolation', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Upper lake desolation', 'Lake desolation')
connect(multiworld, player, 'Upper lake desolation', 'Eastern lake desolation')
connect(multiworld, player, 'Lower lake desolation', 'Lake desolation')
connect(multiworld, player, 'Lower lake desolation', 'Eastern lake desolation')
connect(multiworld, player, 'Eastern lake desolation', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Eastern lake desolation', 'Library')
connect(multiworld, player, 'Eastern lake desolation', 'Lower lake desolation')
connect(multiworld, player, 'Eastern lake desolation', 'Upper lake desolation', lambda state: logic.has_fire(state) and state.can_reach('Upper Lake Serene', 'Region', player), "Upper Lake Serene")
connect(multiworld, player, 'Library', 'Eastern lake desolation')
connect(multiworld, player, 'Library', 'Library top', lambda state: logic.has_doublejump(state) or state.has('Talaria Attachment', player))
connect(multiworld, player, 'Library', 'Varndagroth tower left', logic.has_keycard_D)
connect(multiworld, player, 'Library', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Library top', 'Library')
connect(multiworld, player, 'Varndagroth tower left', 'Library')
connect(multiworld, player, 'Varndagroth tower left', 'Varndagroth tower right (upper)', logic.has_keycard_C)
connect(multiworld, player, 'Varndagroth tower left', 'Varndagroth tower right (lower)', logic.has_keycard_B)
connect(multiworld, player, 'Varndagroth tower left', 'Sealed Caves (Sirens)', lambda state: logic.has_keycard_B(state) and state.has('Elevator Keycard', player))
connect(multiworld, player, 'Varndagroth tower left', 'Refugee Camp', lambda state: state.has('Timespinner Wheel', player) and state.has('Timespinner Spindle', player))
connect(multiworld, player, 'Varndagroth tower right (upper)', 'Varndagroth tower left')
connect(multiworld, player, 'Varndagroth tower right (upper)', 'Varndagroth tower right (elevator)', lambda state: state.has('Elevator Keycard', player))
connect(multiworld, player, 'Varndagroth tower right (elevator)', 'Varndagroth tower right (upper)')
connect(multiworld, player, 'Varndagroth tower right (elevator)', 'Varndagroth tower right (lower)')
connect(multiworld, player, 'Varndagroth tower right (lower)', 'Varndagroth tower left', logic.has_keycard_B)
connect(multiworld, player, 'Varndagroth tower right (lower)', 'Varndagroth tower right (elevator)', lambda state: state.has('Elevator Keycard', player))
connect(multiworld, player, 'Varndagroth tower right (lower)', 'Sealed Caves (Sirens)', lambda state: logic.has_keycard_B(state) and state.has('Elevator Keycard', player))
connect(multiworld, player, 'Varndagroth tower right (lower)', 'Military Fortress', logic.can_kill_all_3_bosses)
connect(multiworld, player, 'Varndagroth tower right (lower)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Sealed Caves (Sirens)', 'Varndagroth tower left', lambda state: state.has('Elevator Keycard', player))
connect(multiworld, player, 'Sealed Caves (Sirens)', 'Varndagroth tower right (lower)', lambda state: state.has('Elevator Keycard', player))
connect(multiworld, player, 'Sealed Caves (Sirens)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Military Fortress', 'Varndagroth tower right (lower)', logic.can_kill_all_3_bosses)
connect(multiworld, player, 'Military Fortress', 'Temporal Gyre', lambda state: state.has('Timespinner Wheel', player) and logic.can_kill_all_3_bosses(state))
connect(multiworld, player, 'Military Fortress', 'Military Fortress (hangar)', logic.has_doublejump)
connect(multiworld, player, 'Military Fortress (hangar)', 'Military Fortress')
connect(multiworld, player, 'Military Fortress (hangar)', 'Lab Entrance', lambda state: state.has('Water Mask', player) if flooded.flood_lab else logic.has_doublejump(state))
connect(multiworld, player, 'Lab Entrance', 'Main Lab', lambda state: logic.has_keycard_B(state))
connect(multiworld, player, 'Main Lab', 'Lab Entrance')
connect(multiworld, player, 'Lab Entrance', 'Military Fortress (hangar)')
connect(multiworld, player, 'Temporal Gyre', 'Military Fortress')
connect(multiworld, player, 'Main Lab', 'Lab Research', lambda state: state.has('Lab Access Research', player) if options.lock_key_amadeus else logic.has_doublejump_of_npc(state))
connect(multiworld, player, 'Main Lab', 'The lab (upper)', lambda state: logic.has_forwarddash_doublejump(state) and ((not options.lock_key_amadeus) or state.has('Lab Access Genza', player)))
connect(multiworld, player, 'The lab (upper)', 'Main Lab', lambda state: options.lock_key_amadeus and state.has('Lab Access Genza', player))
connect(multiworld, player, 'The lab (upper)', 'Emperors tower (courtyard)', logic.has_forwarddash_doublejump)
connect(multiworld, player, 'The lab (upper)', 'Ancient Pyramid (entrance)', lambda state: state.has_all({'Timespinner Wheel', 'Timespinner Spindle', 'Timespinner Gear 1', 'Timespinner Gear 2', 'Timespinner Gear 3'}, player))
connect(multiworld, player, 'Emperors tower (courtyard)', 'The lab (upper)')
connect(multiworld, player, 'Emperors tower (courtyard)', 'Emperors tower', logic.has_doublejump)
connect(multiworld, player, 'Emperors tower', 'Emperors tower (courtyard)')
connect(multiworld, player, 'Skeleton Shaft', 'Lake desolation')
connect(multiworld, player, 'Skeleton Shaft', 'Sealed Caves (Xarion)', logic.has_keycard_A)
connect(multiworld, player, 'Skeleton Shaft', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Sealed Caves (Xarion)', 'Skeleton Shaft')
connect(multiworld, player, 'Sealed Caves (Xarion)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Refugee Camp', 'Forest')
connect(multiworld, player, 'Refugee Camp', 'Library', lambda state: (options.pyramid_start or options.inverted) and options.back_to_the_future and state.has_all({'Timespinner Wheel', 'Timespinner Spindle'}, player))
connect(multiworld, player, 'Refugee Camp', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Forest', 'Refugee Camp')
connect(multiworld, player, 'Forest', 'Left Side forest Caves', lambda state: flooded.flood_lake_serene_bridge or state.has('Talaria Attachment', player) or logic.has_timestop(state))
connect(multiworld, player, 'Forest', 'Caves of Banishment (Sirens)')
connect(multiworld, player, 'Forest', 'Castle Ramparts', lambda state: not options.gate_keep or state.has('Drawbridge Key', player) or logic.has_upwarddash(state))
connect(multiworld, player, 'Left Side forest Caves', 'Forest')
connect(multiworld, player, 'Left Side forest Caves', 'Upper Lake Serene', logic.has_timestop)
connect(multiworld, player, 'Left Side forest Caves', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(multiworld, player, 'Left Side forest Caves', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Upper Lake Serene', 'Left Side forest Caves')
connect(multiworld, player, 'Upper Lake Serene', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(multiworld, player, 'Lower Lake Serene', 'Upper Lake Serene')
connect(multiworld, player, 'Lower Lake Serene', 'Left Side forest Caves')
connect(multiworld, player, 'Lower Lake Serene', 'Caves of Banishment (upper)', lambda state: flooded.flood_lake_serene or logic.has_doublejump(state))
connect(multiworld, player, 'Caves of Banishment (upper)', 'Lower Lake Serene', lambda state: not flooded.flood_lake_serene or state.has('Water Mask', player))
connect(multiworld, player, 'Caves of Banishment (upper)', 'Caves of Banishment (Maw)', lambda state: not flooded.flood_maw or state.has('Water Mask', player))
connect(multiworld, player, 'Caves of Banishment (upper)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (upper)', lambda state: logic.has_doublejump(state) if not flooded.flood_maw else state.has('Water Mask', player))
connect(multiworld, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (Sirens)', lambda state: state.has_any({'Gas Mask', 'Talaria Attachment'}, player) )
connect(multiworld, player, 'Caves of Banishment (Maw)', 'Caves of Banishment (Flooded)', lambda state: flooded.flood_maw or state.has('Water Mask', player))
connect(multiworld, player, 'Caves of Banishment (Maw)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Caves of Banishment (Sirens)', 'Forest')
connect(multiworld, player, 'Castle Ramparts', 'Forest')
connect(multiworld, player, 'Castle Ramparts', 'Castle Keep')
connect(multiworld, player, 'Castle Ramparts', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Castle Keep', 'Castle Ramparts')
connect(multiworld, player, 'Castle Keep', 'Castle Basement', lambda state: not flooded.flood_basement or state.has('Water Mask', player))
connect(multiworld, player, 'Castle Keep', 'Royal towers (lower)', lambda state: logic.has_doublejump(state) and (not options.royal_roadblock or logic.has_pink(state)))
connect(multiworld, player, 'Castle Keep', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Royal towers (lower)', 'Castle Keep')
connect(multiworld, player, 'Royal towers (lower)', 'Royal towers', lambda state: state.has('Timespinner Wheel', player) or logic.has_forwarddash_doublejump(state))
connect(multiworld, player, 'Royal towers (lower)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Royal towers', 'Royal towers (lower)')
connect(multiworld, player, 'Royal towers', 'Royal towers (upper)', logic.has_doublejump)
connect(multiworld, player, 'Royal towers (upper)', 'Royal towers')
#connect(multiworld, player, 'Ancient Pyramid (entrance)', 'The lab (upper)', lambda state: not is_option_enabled(multiworld, player, "EnterSandman"))
connect(multiworld, player, 'Ancient Pyramid (entrance)', 'Ancient Pyramid (left)', logic.has_doublejump)
connect(multiworld, player, 'Ancient Pyramid (entrance)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Ancient Pyramid (left)', 'Ancient Pyramid (entrance)')
connect(multiworld, player, 'Ancient Pyramid (left)', 'Ancient Pyramid (right)', lambda state: flooded.flood_pyramid_shaft or logic.has_upwarddash(state))
connect(multiworld, player, 'Ancient Pyramid (left)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Ancient Pyramid (right)', 'Ancient Pyramid (left)', lambda state: flooded.flood_pyramid_shaft or logic.has_upwarddash(state))
connect(multiworld, player, 'Ancient Pyramid (right)', 'Space time continuum', logic.has_teleport)
connect(multiworld, player, 'Space time continuum', 'Lake desolation', lambda state: logic.can_teleport_to(state, "Present", "GateLakeDesolation"))
connect(multiworld, player, 'Space time continuum', 'Lower lake desolation', lambda state: logic.can_teleport_to(state, "Present", "GateKittyBoss"))
connect(multiworld, player, 'Space time continuum', 'Library', lambda state: logic.can_teleport_to(state, "Present", "GateLeftLibrary"))
connect(multiworld, player, 'Space time continuum', 'Varndagroth tower right (lower)', lambda state: logic.can_teleport_to(state, "Present", "GateMilitaryGate"))
connect(multiworld, player, 'Space time continuum', 'Skeleton Shaft', lambda state: logic.can_teleport_to(state, "Present", "GateSealedCaves"))
connect(multiworld, player, 'Space time continuum', 'Sealed Caves (Sirens)', lambda state: logic.can_teleport_to(state, "Present", "GateSealedSirensCave"))
connect(multiworld, player, 'Space time continuum', 'Sealed Caves (Xarion)', lambda state: logic.can_teleport_to(state, "Present", "GateXarion"))
connect(multiworld, player, 'Space time continuum', 'Upper Lake Serene', lambda state: logic.can_teleport_to(state, "Past", "GateLakeSereneLeft"))
connect(multiworld, player, 'Space time continuum', 'Left Side forest Caves', lambda state: logic.can_teleport_to(state, "Past", "GateLakeSereneRight"))
connect(multiworld, player, 'Space time continuum', 'Refugee Camp', lambda state: logic.can_teleport_to(state, "Past", "GateAccessToPast"))
connect(multiworld, player, 'Space time continuum', 'Forest', lambda state: logic.can_teleport_to(state, "Past", "GateCastleRamparts"))
connect(multiworld, player, 'Space time continuum', 'Castle Keep', lambda state: logic.can_teleport_to(state, "Past", "GateCastleKeep"))
connect(multiworld, player, 'Space time continuum', 'Royal towers (lower)', lambda state: logic.can_teleport_to(state, "Past", "GateRoyalTowers"))
connect(multiworld, player, 'Space time continuum', 'Caves of Banishment (Maw)', lambda state: logic.can_teleport_to(state, "Past", "GateMaw"))
connect(multiworld, player, 'Space time continuum', 'Caves of Banishment (upper)', lambda state: logic.can_teleport_to(state, "Past", "GateCavesOfBanishment"))
connect(multiworld, player, 'Space time continuum', 'Military Fortress (hangar)', lambda state: logic.can_teleport_to(state, "Present", "GateLabEntrance"))
connect(multiworld, player, 'Space time continuum', 'The lab (upper)', lambda state: logic.can_teleport_to(state, "Present", "GateDadsTower"))
connect(multiworld, player, 'Space time continuum', 'Ancient Pyramid (entrance)', lambda state: logic.can_teleport_to(state, "Time", "GateGyre") or logic.can_teleport_to(state, "Time", "GateLeftPyramid") or (not options.unchained_keys and options.enter_sandman))
connect(multiworld, player, 'Space time continuum', 'Ancient Pyramid (right)', lambda state: logic.can_teleport_to(state, "Time", "GateRightPyramid"))
if options.gyre_archives:
connect(world, player, 'The lab (upper)', 'Ravenlord\'s Lair', lambda state: state.has('Merchant Crow', player))
connect(world, player, 'Ravenlord\'s Lair', 'The lab (upper)')
connect(world, player, 'Library top', 'Ifrit\'s Lair', lambda state: state.has('Kobo', player) and state.can_reach('Refugee Camp', 'Region', player), "Refugee Camp")
connect(world, player, 'Ifrit\'s Lair', 'Library top')
connect(multiworld, player, 'The lab (upper)', 'Ravenlord\'s Lair', lambda state: state.has('Merchant Crow', player))
connect(multiworld, player, 'Ravenlord\'s Lair', 'The lab (upper)')
connect(multiworld, player, 'Library top', 'Ifrit\'s Lair', lambda state: state.has('Kobo', player) and state.can_reach('Refugee Camp', 'Region', player), "Refugee Camp")
connect(multiworld, player, 'Ifrit\'s Lair', 'Library top')
def throwIfAnyLocationIsNotAssignedToARegion(regions: List[Region], regionNames: Set[str]):
@@ -223,8 +223,8 @@ def create_location(player: int, location_data: LocationData, region: Region) ->
return location
def create_region(world: MultiWorld, player: int, locations_per_region: Dict[str, List[LocationData]], name: str) -> Region:
region = Region(name, player, world)
def create_region(multiworld: MultiWorld, player: int, locations_per_region: Dict[str, List[LocationData]], name: str) -> Region:
region = Region(name, player, multiworld)
if name in locations_per_region:
for location_data in locations_per_region[name]:
@@ -233,17 +233,17 @@ def create_region(world: MultiWorld, player: int, locations_per_region: Dict[str
return region
def connectStartingRegion(world: MultiWorld, player: int, options: TimespinnerOptions):
menu = world.get_region('Menu', player)
tutorial = world.get_region('Tutorial', player)
space_time_continuum = world.get_region('Space time continuum', player)
def connectStartingRegion(multiworld: MultiWorld, player: int, options: TimespinnerOptions):
menu = multiworld.get_region('Menu', player)
tutorial = multiworld.get_region('Tutorial', player)
space_time_continuum = multiworld.get_region('Space time continuum', player)
if options.pyramid_start:
starting_region = world.get_region('Ancient Pyramid (entrance)', player)
starting_region = multiworld.get_region('Ancient Pyramid (entrance)', player)
elif options.inverted:
starting_region = world.get_region('Refugee Camp', player)
starting_region = multiworld.get_region('Refugee Camp', player)
else:
starting_region = world.get_region('Lake desolation', player)
starting_region = multiworld.get_region('Lake desolation', player)
menu_to_tutorial = Entrance(player, 'Tutorial', menu)
menu_to_tutorial.connect(tutorial)
@@ -256,20 +256,20 @@ def connectStartingRegion(world: MultiWorld, player: int, options: TimespinnerOp
space_time_continuum.exits.append(teleport_back_to_start)
def connect(world: MultiWorld, player: int, source: str, target: str,
def connect(multiworld: MultiWorld, player: int, source: str, target: str,
rule: Optional[Callable[[CollectionState], bool]] = None,
indirect: str = ""):
sourceRegion = world.get_region(source, player)
targetRegion = world.get_region(target, player)
sourceRegion = multiworld.get_region(source, player)
targetRegion = multiworld.get_region(target, player)
entrance = sourceRegion.connect(targetRegion, rule=rule)
if indirect:
indirectRegion = world.get_region(indirect, player)
if indirectRegion in world.indirect_connections:
world.indirect_connections[indirectRegion].add(entrance)
indirectRegion = multiworld.get_region(indirect, player)
if indirectRegion in multiworld.indirect_connections:
multiworld.indirect_connections[indirectRegion].add(entrance)
else:
world.indirect_connections[indirectRegion] = {entrance}
multiworld.indirect_connections[indirectRegion] = {entrance}
def split_location_datas_per_region(locations: List[LocationData]) -> Dict[str, List[LocationData]]:

4
worlds/undertale/Regions.py
View File

@@ -1,9 +1,9 @@
from BaseClasses import MultiWorld
def link_undertale_areas(world: MultiWorld, player: int):
def link_undertale_areas(multiworld: MultiWorld, player: int):
for (exit, region) in mandatory_connections:
world.get_entrance(exit, player).connect(world.get_region(region, player))
multiworld.get_entrance(exit, player).connect(multiworld.get_region(region, player))
# (Region name, list of exits)

22
worlds/v6/Regions.py
View File

@@ -5,29 +5,29 @@ from .Locations import V6Location, location_table
v6areas = ["Laboratory", "The Tower", "Space Station 2", "Warp Zone"]
def create_regions(world: MultiWorld, player: int):
regOvr = Region("Menu", player, world, "Dimension VVVVVV")
def create_regions(multiworld: MultiWorld, player: int):
regOvr = Region("Menu", player, multiworld, "Dimension VVVVVV")
locOvr_names = ["Overworld (Pipe-shaped Segment)", "Overworld (Left of Ship)", "Overworld (Square Room)", "Overworld (Sad Elephant)",
"It's a Secret to Nobody", "Trench Warfare", "NPC Trinket", "V"]
regOvr.locations += [V6Location(player, loc_name, location_table[loc_name], regOvr) for loc_name in locOvr_names]
world.regions.append(regOvr)
multiworld.regions.append(regOvr)
regLab = Region("Laboratory", player, world)
regLab = Region("Laboratory", player, multiworld)
locLab_names = ["Young Man, It's Worth the Challenge", "Overworld (Outside Entanglement Generator)", "The Tantalizing Trinket", "Purest Unobtainium"]
regLab.locations += [V6Location(player, loc_name, location_table[loc_name], regLab) for loc_name in locLab_names]
world.regions.append(regLab)
multiworld.regions.append(regLab)
regTow = Region("The Tower", player, world)
regTow = Region("The Tower", player, multiworld)
locTow_names = ["The Tower 1", "The Tower 2"]
regTow.locations += [V6Location(player, loc_name, location_table[loc_name], regTow) for loc_name in locTow_names]
world.regions.append(regTow)
multiworld.regions.append(regTow)
regSp2 = Region("Space Station 2", player, world)
regSp2 = Region("Space Station 2", player, multiworld)
locSp2_names = ["One Way Room", "You Just Keep Coming Back", "Clarion Call", "Prize for the Reckless", "Doing things the hard way"]
regSp2.locations += [V6Location(player, loc_name, location_table[loc_name], regSp2) for loc_name in locSp2_names]
world.regions.append(regSp2)
multiworld.regions.append(regSp2)
regWrp = Region("Warp Zone", player, world)
regWrp = Region("Warp Zone", player, multiworld)
locWrp_names = ["Edge Games"]
regWrp.locations += [V6Location(player, loc_name, location_table[loc_name], regWrp) for loc_name in locWrp_names]
world.regions.append(regWrp)
multiworld.regions.append(regWrp)

130
worlds/wargroove/Rules.py
View File

@@ -16,139 +16,139 @@ class WargrooveLogic(LogicMixin):
return self.can_reach(region, 'Region', player) and self.has(item, player)
def set_rules(world: MultiWorld, player: int):
def set_rules(multiworld: MultiWorld, player: int):
# Final Level
set_rule(world.get_location('Wargroove Finale: Victory', player),
set_rule(multiworld.get_location('Wargroove Finale: Victory', player),
lambda state: state._wargroove_has_item(player, "Final Bridges") and
state._wargroove_has_item(player, "Final Walls") and
state._wargroove_has_item(player, "Final Sickle"))
# Level 1
set_rule(world.get_location('Humble Beginnings: Caesar', player), lambda state: True)
set_rule(world.get_location('Humble Beginnings: Chest 1', player), lambda state: True)
set_rule(world.get_location('Humble Beginnings: Chest 2', player), lambda state: True)
set_rule(world.get_location('Humble Beginnings: Victory', player), lambda state: True)
set_region_exit_rules(world.get_region('Humble Beginnings', player),
[world.get_location('Humble Beginnings: Victory', player)])
set_rule(multiworld.get_location('Humble Beginnings: Caesar', player), lambda state: True)
set_rule(multiworld.get_location('Humble Beginnings: Chest 1', player), lambda state: True)
set_rule(multiworld.get_location('Humble Beginnings: Chest 2', player), lambda state: True)
set_rule(multiworld.get_location('Humble Beginnings: Victory', player), lambda state: True)
set_region_exit_rules(multiworld.get_region('Humble Beginnings', player),
[multiworld.get_location('Humble Beginnings: Victory', player)])
# Levels 2A-2C
set_rule(world.get_location('Best Friendssss: Find Sedge', player), lambda state: True)
set_rule(world.get_location('Best Friendssss: Victory', player), lambda state: True)
set_region_exit_rules(world.get_region('Best Friendssss', player),
[world.get_location('Best Friendssss: Victory', player)])
set_rule(multiworld.get_location('Best Friendssss: Find Sedge', player), lambda state: True)
set_rule(multiworld.get_location('Best Friendssss: Victory', player), lambda state: True)
set_region_exit_rules(multiworld.get_region('Best Friendssss', player),
[multiworld.get_location('Best Friendssss: Victory', player)])
set_rule(world.get_location('A Knight\'s Folly: Caesar', player), lambda state: True)
set_rule(world.get_location('A Knight\'s Folly: Victory', player), lambda state: True)
set_region_exit_rules(world.get_region('A Knight\'s Folly', player),
[world.get_location('A Knight\'s Folly: Victory', player)])
set_rule(multiworld.get_location('A Knight\'s Folly: Caesar', player), lambda state: True)
set_rule(multiworld.get_location('A Knight\'s Folly: Victory', player), lambda state: True)
set_region_exit_rules(multiworld.get_region('A Knight\'s Folly', player),
[multiworld.get_location('A Knight\'s Folly: Victory', player)])
set_rule(world.get_location('Denrunaway: Chest', player), lambda state: True)
set_rule(world.get_location('Denrunaway: Victory', player), lambda state: True)
set_region_exit_rules(world.get_region('Denrunaway', player), [world.get_location('Denrunaway: Victory', player)])
set_rule(multiworld.get_location('Denrunaway: Chest', player), lambda state: True)
set_rule(multiworld.get_location('Denrunaway: Victory', player), lambda state: True)
set_region_exit_rules(multiworld.get_region('Denrunaway', player), [multiworld.get_location('Denrunaway: Victory', player)])
# Levels 3AA-3AC
set_rule(world.get_location('Dragon Freeway: Victory', player),
set_rule(multiworld.get_location('Dragon Freeway: Victory', player),
lambda state: state._wargroove_has_item(player, 'Mage'))
set_region_exit_rules(world.get_region('Dragon Freeway', player),
[world.get_location('Dragon Freeway: Victory', player)])
set_region_exit_rules(multiworld.get_region('Dragon Freeway', player),
[multiworld.get_location('Dragon Freeway: Victory', player)])
set_rule(world.get_location('Deep Thicket: Find Sedge', player),
set_rule(multiworld.get_location('Deep Thicket: Find Sedge', player),
lambda state: state._wargroove_has_item(player, 'Mage'))
set_rule(world.get_location('Deep Thicket: Victory', player),
set_rule(multiworld.get_location('Deep Thicket: Victory', player),
lambda state: state._wargroove_has_item(player, 'Mage'))
set_region_exit_rules(world.get_region('Deep Thicket', player),
[world.get_location('Deep Thicket: Victory', player)])
set_region_exit_rules(multiworld.get_region('Deep Thicket', player),
[multiworld.get_location('Deep Thicket: Victory', player)])
set_rule(world.get_location('Corrupted Inlet: Victory', player),
set_rule(multiworld.get_location('Corrupted Inlet: Victory', player),
lambda state: state._wargroove_has_item(player, 'Barge') or
state._wargroove_has_item(player, 'Merfolk') or
state._wargroove_has_item(player, 'Warship'))
set_region_exit_rules(world.get_region('Corrupted Inlet', player),
[world.get_location('Corrupted Inlet: Victory', player)])
set_region_exit_rules(multiworld.get_region('Corrupted Inlet', player),
[multiworld.get_location('Corrupted Inlet: Victory', player)])
# Levels 3BA-3BC
set_rule(world.get_location('Mage Mayhem: Caesar', player),
set_rule(multiworld.get_location('Mage Mayhem: Caesar', player),
lambda state: state._wargroove_has_item(player, 'Harpy') or state._wargroove_has_item(player, 'Dragon'))
set_rule(world.get_location('Mage Mayhem: Victory', player),
set_rule(multiworld.get_location('Mage Mayhem: Victory', player),
lambda state: state._wargroove_has_item(player, 'Harpy') or state._wargroove_has_item(player, 'Dragon'))
set_region_exit_rules(world.get_region('Mage Mayhem', player), [world.get_location('Mage Mayhem: Victory', player)])
set_region_exit_rules(multiworld.get_region('Mage Mayhem', player), [multiworld.get_location('Mage Mayhem: Victory', player)])
set_rule(world.get_location('Endless Knight: Victory', player),
set_rule(multiworld.get_location('Endless Knight: Victory', player),
lambda state: state._wargroove_has_item(player, 'Eastern Bridges') and (
state._wargroove_has_item(player, 'Spearman') or
state._wargroove_has_item(player, 'Harpy') or
state._wargroove_has_item(player, 'Dragon')))
set_region_exit_rules(world.get_region('Endless Knight', player),
[world.get_location('Endless Knight: Victory', player)])
set_region_exit_rules(multiworld.get_region('Endless Knight', player),
[multiworld.get_location('Endless Knight: Victory', player)])
set_rule(world.get_location('Ambushed in the Middle: Victory (Blue)', player),
set_rule(multiworld.get_location('Ambushed in the Middle: Victory (Blue)', player),
lambda state: state._wargroove_has_item(player, 'Spearman'))
set_rule(world.get_location('Ambushed in the Middle: Victory (Green)', player),
set_rule(multiworld.get_location('Ambushed in the Middle: Victory (Green)', player),
lambda state: state._wargroove_has_item(player, 'Spearman'))
set_region_exit_rules(world.get_region('Ambushed in the Middle', player),
[world.get_location('Ambushed in the Middle: Victory (Blue)', player),
world.get_location('Ambushed in the Middle: Victory (Green)', player)])
set_region_exit_rules(multiworld.get_region('Ambushed in the Middle', player),
[multiworld.get_location('Ambushed in the Middle: Victory (Blue)', player),
multiworld.get_location('Ambushed in the Middle: Victory (Green)', player)])
# Levels 3CA-3CC
set_rule(world.get_location('The Churning Sea: Victory', player),
set_rule(multiworld.get_location('The Churning Sea: Victory', player),
lambda state: (state._wargroove_has_item(player, 'Merfolk') or state._wargroove_has_item(player, 'Turtle'))
and state._wargroove_has_item(player, 'Harpoon Ship'))
set_region_exit_rules(world.get_region('The Churning Sea', player),
[world.get_location('The Churning Sea: Victory', player)])
set_region_exit_rules(multiworld.get_region('The Churning Sea', player),
[multiworld.get_location('The Churning Sea: Victory', player)])
set_rule(world.get_location('Frigid Archery: Light the Torch', player),
set_rule(multiworld.get_location('Frigid Archery: Light the Torch', player),
lambda state: state._wargroove_has_item(player, 'Archer') and
state._wargroove_has_item(player, 'Southern Walls'))
set_rule(world.get_location('Frigid Archery: Victory', player),
set_rule(multiworld.get_location('Frigid Archery: Victory', player),
lambda state: state._wargroove_has_item(player, 'Archer'))
set_region_exit_rules(world.get_region('Frigid Archery', player),
[world.get_location('Frigid Archery: Victory', player)])
set_region_exit_rules(multiworld.get_region('Frigid Archery', player),
[multiworld.get_location('Frigid Archery: Victory', player)])
set_rule(world.get_location('Archery Lessons: Chest', player),
set_rule(multiworld.get_location('Archery Lessons: Chest', player),
lambda state: state._wargroove_has_item(player, 'Knight') and
state._wargroove_has_item(player, 'Southern Walls'))
set_rule(world.get_location('Archery Lessons: Victory', player),
set_rule(multiworld.get_location('Archery Lessons: Victory', player),
lambda state: state._wargroove_has_item(player, 'Knight') and
state._wargroove_has_item(player, 'Southern Walls'))
set_region_exit_rules(world.get_region('Archery Lessons', player),
[world.get_location('Archery Lessons: Victory', player)])
set_region_exit_rules(multiworld.get_region('Archery Lessons', player),
[multiworld.get_location('Archery Lessons: Victory', player)])
# Levels 4AA-4AC
set_rule(world.get_location('Surrounded: Caesar', player),
set_rule(multiworld.get_location('Surrounded: Caesar', player),
lambda state: state._wargroove_has_item_and_region(player, 'Knight', 'Surrounded'))
set_rule(world.get_location('Surrounded: Victory', player),
set_rule(multiworld.get_location('Surrounded: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Knight', 'Surrounded'))
set_rule(world.get_location('Darkest Knight: Victory', player),
set_rule(multiworld.get_location('Darkest Knight: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Spearman', 'Darkest Knight'))
set_rule(world.get_location('Robbed: Victory', player),
set_rule(multiworld.get_location('Robbed: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Thief', 'Robbed') and
state._wargroove_has_item(player, 'Rifleman'))
# Levels 4BA-4BC
set_rule(world.get_location('Open Season: Caesar', player),
set_rule(multiworld.get_location('Open Season: Caesar', player),
lambda state: state._wargroove_has_item_and_region(player, 'Mage', 'Open Season') and
state._wargroove_has_item(player, 'Knight'))
set_rule(world.get_location('Open Season: Victory', player),
set_rule(multiworld.get_location('Open Season: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Mage', 'Open Season') and
state._wargroove_has_item(player, 'Knight'))
set_rule(world.get_location('Doggo Mountain: Find all the Dogs', player),
set_rule(multiworld.get_location('Doggo Mountain: Find all the Dogs', player),
lambda state: state._wargroove_has_item_and_region(player, 'Knight', 'Doggo Mountain'))
set_rule(world.get_location('Doggo Mountain: Victory', player),
set_rule(multiworld.get_location('Doggo Mountain: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Knight', 'Doggo Mountain'))
set_rule(world.get_location('Tenri\'s Fall: Victory', player),
set_rule(multiworld.get_location('Tenri\'s Fall: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Mage', 'Tenri\'s Fall') and
state._wargroove_has_item(player, 'Thief'))
set_rule(world.get_location('Foolish Canal: Victory', player),
set_rule(multiworld.get_location('Foolish Canal: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Mage', 'Foolish Canal') and
state._wargroove_has_item(player, 'Spearman'))
# Levels 4CA-4CC
set_rule(world.get_location('Master of the Lake: Victory', player),
set_rule(multiworld.get_location('Master of the Lake: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Warship', 'Master of the Lake'))
set_rule(world.get_location('A Ballista\'s Revenge: Victory', player),
set_rule(multiworld.get_location('A Ballista\'s Revenge: Victory', player),
lambda state: state._wargroove_has_item_and_region(player, 'Ballista', 'A Ballista\'s Revenge'))
set_rule(world.get_location('Rebel Village: Victory (Pink)', player),
set_rule(multiworld.get_location('Rebel Village: Victory (Pink)', player),
lambda state: state._wargroove_has_item_and_region(player, 'Spearman', 'Rebel Village'))
set_rule(world.get_location('Rebel Village: Victory (Red)', player),
set_rule(multiworld.get_location('Rebel Village: Victory (Red)', player),
lambda state: state._wargroove_has_item_and_region(player, 'Spearman', 'Rebel Village'))

4
worlds/wargroove/__init__.py
View File

@@ -143,8 +143,8 @@ class WargrooveWorld(World):
return self.multiworld.random.choice(["Commander Defense Boost", "Income Boost"])
def create_region(world: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, world)
def create_region(multiworld: MultiWorld, player: int, name: str, locations=None, exits=None):
ret = Region(name, player, multiworld)
if locations:
for location in locations:
loc_id = location_table.get(location, 0)

8
worlds/yachtdice/Rules.py
View File

@@ -218,12 +218,12 @@ def dice_simulation_state_change(state, player, frags_per_dice, frags_per_roll,
return state.prog_items[player]["maximum_achievable_score"]
def set_yacht_rules(world: MultiWorld, player: int, frags_per_dice, frags_per_roll, allowed_categories, difficulty):
def set_yacht_rules(multiworld: MultiWorld, player: int, frags_per_dice, frags_per_roll, allowed_categories, difficulty):
"""
Sets rules on reaching scores
"""
for location in world.get_locations(player):
for location in multiworld.get_locations(player):
set_rule(
location,
lambda state, curscore=location.yacht_dice_score, player=player: dice_simulation_state_change(
@@ -233,8 +233,8 @@ def set_yacht_rules(world: MultiWorld, player: int, frags_per_dice, frags_per_ro
)
def set_yacht_completion_rules(world: MultiWorld, player: int):
def set_yacht_completion_rules(multiworld: MultiWorld, player: int):
"""
Sets rules on completion condition
"""
world.completion_condition[player] = lambda state: state.has("Victory", player)
multiworld.completion_condition[player] = lambda state: state.has("Victory", player)

3
worlds/yoshisisland/__init__.py
View File

@@ -341,7 +341,6 @@ class YoshisIslandWorld(World):
def generate_output(self, output_directory: str) -> None:
rompath = "" # if variable is not declared finally clause may fail
try:
world = self.multiworld
player = self.player
rom = LocalRom(get_base_rom_path())
patch_rom(self, rom, self.player)
@@ -351,7 +350,7 @@ class YoshisIslandWorld(World):
self.rom_name = rom.name
patch = YoshisIslandDeltaPatch(os.path.splitext(rompath)[0] + YoshisIslandDeltaPatch.patch_file_ending,
player=player, player_name=world.player_name[player], patched_path=rompath)
player=player, player_name=self.player_name, patched_path=rompath)
patch.write()
finally:
self.rom_name_available_event.set()

4
worlds/yugioh06/__init__.py
View File

@@ -130,8 +130,8 @@ class Yugioh06World(World):
campaign_opponents: List[OpponentData]
is_draft_mode: bool
def __init__(self, world: MultiWorld, player: int):
super().__init__(world, player)
def __init__(self, multiworld: MultiWorld, player: int):
super().__init__(multiworld, player)
def generate_early(self):
self.starting_opponent = ""

4
worlds/zillion/__init__.py
View File

@@ -128,8 +128,8 @@ class ZillionWorld(World):
"""
logic_cache: ZillionLogicCache | None = None
def __init__(self, world: MultiWorld, player: int) -> None:
super().__init__(world, player)
def __init__(self, multiworld: MultiWorld, player: int) -> None:
super().__init__(multiworld, player)
self.logger = logging.getLogger("Zillion")
self.lsi = ZillionWorld.LogStreamInterface(self.logger)
self.zz_system = System()