diff --git a/worlds/adventure/Regions.py b/worlds/adventure/Regions.py index a0a04be2aa..e62aea54fe 100644 --- a/worlds/adventure/Regions.py +++ b/worlds/adventure/Regions.py @@ -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: diff --git a/worlds/adventure/Rules.py b/worlds/adventure/Rules.py index 53617b039d..4b3cd8868e 100644 --- a/worlds/adventure/Rules.py +++ b/worlds/adventure/Rules.py @@ -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 diff --git a/worlds/adventure/__init__.py b/worlds/adventure/__init__.py index 94f2b22e81..4beb0aa54d 100644 --- a/worlds/adventure/__init__.py +++ b/worlds/adventure/__init__.py @@ -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 diff --git a/worlds/cccharles/Regions.py b/worlds/cccharles/Regions.py index 68239dc060..0e69a7d5f4 100644 --- a/worlds/cccharles/Regions.py +++ b/worlds/cccharles/Regions.py @@ -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) diff --git a/worlds/cccharles/Rules.py b/worlds/cccharles/Rules.py index 979aacd529..a4224a3343 100644 --- a/worlds/cccharles/Rules.py +++ b/worlds/cccharles/Rules.py @@ -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) diff --git a/worlds/dkc3/__init__.py b/worlds/dkc3/__init__.py index 1dabeb0539..7209e62e6d 100644 --- a/worlds/dkc3/__init__.py +++ b/worlds/dkc3/__init__.py @@ -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): diff --git a/worlds/dlcquest/Regions.py b/worlds/dlcquest/Regions.py index 5b256afd45..8cb7d21e59 100644 --- a/worlds/dlcquest/Regions.py +++ b/worlds/dlcquest/Regions.py @@ -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): diff --git a/worlds/dlcquest/Rules.py b/worlds/dlcquest/Rules.py index 5dfd80165a..415d5c3825 100644 --- a/worlds/dlcquest/Rules.py +++ b/worlds/dlcquest/Rules.py @@ -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)) diff --git a/worlds/faxanadu/__init__.py b/worlds/faxanadu/__init__.py index ca17c06759..da4287ae34 100644 --- a/worlds/faxanadu/__init__.py +++ b/worlds/faxanadu/__init__.py @@ -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) diff --git a/worlds/ff1/Locations.py b/worlds/ff1/Locations.py index 47facad985..57b02d5931 100644 --- a/worlds/ff1/Locations.py +++ b/worlds/ff1/Locations.py @@ -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 diff --git a/worlds/ff1/__init__.py b/worlds/ff1/__init__.py index 39df9020e5..c3d57016e8 100644 --- a/worlds/ff1/__init__.py +++ b/worlds/ff1/__init__.py @@ -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 = [] diff --git a/worlds/ffmq/Regions.py b/worlds/ffmq/Regions.py index 7bf773f5cf..8d207eb0bb 100644 --- a/worlds/ffmq/Regions.py +++ b/worlds/ffmq/Regions.py @@ -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 diff --git a/worlds/hk/Regions.py b/worlds/hk/Regions.py deleted file mode 100644 index c6b2b219dd..0000000000 --- a/worlds/hk/Regions.py +++ /dev/null @@ -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) - - diff --git a/worlds/hylics2/Rules.py b/worlds/hylics2/Rules.py index 3914054193..3fbeaefdd2 100644 --- a/worlds/hylics2/Rules.py +++ b/worlds/hylics2/Rules.py @@ -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)) diff --git a/worlds/mm3/__init__.py b/worlds/mm3/__init__.py index 5b349bc9c3..d144accaa5 100644 --- a/worlds/mm3/__init__.py +++ b/worlds/mm3/__init__.py @@ -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]] = {} diff --git a/worlds/mmbn3/__init__.py b/worlds/mmbn3/__init__.py index 80716977d3..8400b01eaa 100644 --- a/worlds/mmbn3/__init__.py +++ b/worlds/mmbn3/__init__.py @@ -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 diff --git a/worlds/oot/EntranceShuffle.py b/worlds/oot/EntranceShuffle.py index 66c5df804c..278fcda1e2 100644 --- a/worlds/oot/EntranceShuffle.py +++ b/worlds/oot/EntranceShuffle.py @@ -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) diff --git a/worlds/oot/ItemPool.py b/worlds/oot/ItemPool.py index 805d1fc72d..ea964fb067 100644 --- a/worlds/oot/ItemPool.py +++ b/worlds/oot/ItemPool.py @@ -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)) diff --git a/worlds/overcooked2/test/TestOvercooked2.py b/worlds/overcooked2/test/TestOvercooked2.py index a3c1c3dc0d..917027ca09 100644 --- a/worlds/overcooked2/test/TestOvercooked2.py +++ b/worlds/overcooked2/test/TestOvercooked2.py @@ -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(): diff --git a/worlds/raft/__init__.py b/worlds/raft/__init__.py index 374d952d46..e6b027c4d2 100644 --- a/worlds/raft/__init__.py +++ b/worlds/raft/__init__.py @@ -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) diff --git a/worlds/sm/__init__.py b/worlds/sm/__init__.py index cdb58b72fb..ff20a53119 100644 --- a/worlds/sm/__init__.py +++ b/worlds/sm/__init__.py @@ -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]: diff --git a/worlds/sm64ex/Regions.py b/worlds/sm64ex/Regions.py index 44a0636f1b..2a8206b0cb 100644 --- a/worlds/sm64ex/Regions.py +++ b/worlds/sm64ex/Regions.py @@ -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 diff --git a/worlds/sm64ex/Rules.py b/worlds/sm64ex/Rules.py index a6cc8dad6d..92ee61bda4 100644 --- a/worlds/sm64ex/Rules.py +++ b/worlds/sm64ex/Rules.py @@ -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) diff --git a/worlds/smz3/__init__.py b/worlds/smz3/__init__.py index c4a1f313fa..bbaa2bcf87 100644 --- a/worlds/smz3/__init__.py +++ b/worlds/smz3/__init__.py @@ -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] diff --git a/worlds/timespinner/Regions.py b/worlds/timespinner/Regions.py index 9580eb14fe..98170d193a 100644 --- a/worlds/timespinner/Regions.py +++ b/worlds/timespinner/Regions.py @@ -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]]: diff --git a/worlds/undertale/Regions.py b/worlds/undertale/Regions.py index 138a684653..22cfcc4f5a 100644 --- a/worlds/undertale/Regions.py +++ b/worlds/undertale/Regions.py @@ -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) diff --git a/worlds/v6/Regions.py b/worlds/v6/Regions.py index f6e9ee7538..e4b04b5e9b 100644 --- a/worlds/v6/Regions.py +++ b/worlds/v6/Regions.py @@ -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) diff --git a/worlds/wargroove/Rules.py b/worlds/wargroove/Rules.py index e163377393..1243973c02 100644 --- a/worlds/wargroove/Rules.py +++ b/worlds/wargroove/Rules.py @@ -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')) diff --git a/worlds/wargroove/__init__.py b/worlds/wargroove/__init__.py index e6bcc6288a..f6218225e1 100644 --- a/worlds/wargroove/__init__.py +++ b/worlds/wargroove/__init__.py @@ -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) diff --git a/worlds/yachtdice/Rules.py b/worlds/yachtdice/Rules.py index 3fb712fdca..f9f36144b3 100644 --- a/worlds/yachtdice/Rules.py +++ b/worlds/yachtdice/Rules.py @@ -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) diff --git a/worlds/yoshisisland/__init__.py b/worlds/yoshisisland/__init__.py index f1aba3018b..111642d82d 100644 --- a/worlds/yoshisisland/__init__.py +++ b/worlds/yoshisisland/__init__.py @@ -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() diff --git a/worlds/yugioh06/__init__.py b/worlds/yugioh06/__init__.py index 5d4cddd95c..1e64fd488e 100644 --- a/worlds/yugioh06/__init__.py +++ b/worlds/yugioh06/__init__.py @@ -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 = "" diff --git a/worlds/zillion/__init__.py b/worlds/zillion/__init__.py index 02ef920d8f..b6d9e7255f 100644 --- a/worlds/zillion/__init__.py +++ b/worlds/zillion/__init__.py @@ -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()