Update docs/world api.md

Co-authored-by: Scipio Wright <scipiowright@gmail.com>

.gitattributes

@@ -0,0 +1 @@
+worlds/blasphemous/region_data.py linguist-generated=true

.github/workflows/unittests.yml

@@ -37,12 +37,13 @@ jobs:
           - {version: '3.9'}
           - {version: '3.10'}
           - {version: '3.11'}
+          - {version: '3.12'}
         include:
           - python: {version: '3.8'}  # win7 compat
             os: windows-latest
-          - python: {version: '3.11'}  # current
+          - python: {version: '3.12'}  # current
             os: windows-latest
-          - python: {version: '3.11'}  # current
+          - python: {version: '3.12'}  # current
             os: macos-latest
 
     steps:
@@ -70,7 +71,7 @@ jobs:
         os:
           - ubuntu-latest
         python:
-          - {version: '3.11'}  # current
+          - {version: '3.12'}  # current
 
     steps:
     - uses: actions/checkout@v4

BaseClasses.py

@@ -11,8 +11,10 @@ from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, NamedTuple, Optional, Set, Tuple, \
-                   TypedDict, Union, Type, ClassVar
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
+                    Optional, Protocol, Set, Tuple, Union, Type)
+
+from typing_extensions import NotRequired, TypedDict
 
 import NetUtils
 import Options
@@ -22,16 +24,16 @@ if typing.TYPE_CHECKING:
     from worlds import AutoWorld
 
 
-class Group(TypedDict, total=False):
+class Group(TypedDict):
     name: str
     game: str
     world: "AutoWorld.World"
-    players: Set[int]
-    item_pool: Set[str]
-    replacement_items: Dict[int, Optional[str]]
-    local_items: Set[str]
-    non_local_items: Set[str]
-    link_replacement: bool
+    players: AbstractSet[int]
+    item_pool: NotRequired[Set[str]]
+    replacement_items: NotRequired[Dict[int, Optional[str]]]
+    local_items: NotRequired[Set[str]]
+    non_local_items: NotRequired[Set[str]]
+    link_replacement: NotRequired[bool]
 
 
 class ThreadBarrierProxy:
@@ -48,6 +50,11 @@ class ThreadBarrierProxy:
                                "Please use multiworld.per_slot_randoms[player] or randomize ahead of output.")
 
 
+class HasNameAndPlayer(Protocol):
+    name: str
+    player: int
+
+
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
@@ -156,7 +163,7 @@ class MultiWorld():
         self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
 
         for player in range(1, players + 1):
-            def set_player_attr(attr, val):
+            def set_player_attr(attr: str, val) -> None:
                 self.__dict__.setdefault(attr, {})[player] = val
             set_player_attr('plando_items', [])
             set_player_attr('plando_texts', {})
@@ -165,13 +172,13 @@ class MultiWorld():
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
         self.per_slot_randoms = Utils.DeprecateDict("Using per_slot_randoms is now deprecated. Please use the "
-                                                      "world's random object instead (usually self.random)")
+                                                    "world's random object instead (usually self.random)")
         self.plando_options = PlandoOptions.none
 
     def get_all_ids(self) -> Tuple[int, ...]:
         return self.player_ids + tuple(self.groups)
 
-    def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tuple[int, Group]:
+    def add_group(self, name: str, game: str, players: AbstractSet[int] = frozenset()) -> Tuple[int, Group]:
         """Create a group with name and return the assigned player ID and group.
         If a group of this name already exists, the set of players is extended instead of creating a new one."""
         from worlds import AutoWorld
@@ -195,7 +202,7 @@ class MultiWorld():
 
         return new_id, new_group
 
-    def get_player_groups(self, player) -> Set[int]:
+    def get_player_groups(self, player: int) -> Set[int]:
         return {group_id for group_id, group in self.groups.items() if player in group["players"]}
 
     def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
@@ -258,7 +265,7 @@ class MultiWorld():
                         "link_replacement": replacement_prio.index(item_link["link_replacement"]),
                     }
 
-        for name, item_link in item_links.items():
+        for _name, item_link in item_links.items():
             current_item_name_groups = AutoWorld.AutoWorldRegister.world_types[item_link["game"]].item_name_groups
             pool = set()
             local_items = set()
@@ -335,6 +342,8 @@ class MultiWorld():
             region = Region("Menu", group_id, self, "ItemLink")
             self.regions.append(region)
             locations = region.locations
+            # ensure that progression items are linked first, then non-progression
+            self.itempool.sort(key=lambda item: item.advancement)
             for item in self.itempool:
                 count = common_item_count.get(item.player, {}).get(item.name, 0)
                 if count:
@@ -388,7 +397,7 @@ class MultiWorld():
         return tuple(world for player, world in self.worlds.items() if
                      player not in self.groups and self.game[player] == game_name)
 
-    def get_name_string_for_object(self, obj) -> str:
+    def get_name_string_for_object(self, obj: HasNameAndPlayer) -> str:
         return obj.name if self.players == 1 else f'{obj.name} ({self.get_player_name(obj.player)})'
 
     def get_player_name(self, player: int) -> str:
@@ -430,7 +439,7 @@ class MultiWorld():
             subworld = self.worlds[player]
             for item in subworld.get_pre_fill_items():
                 subworld.collect(ret, item)
-        ret.sweep_for_events()
+        ret.sweep_for_advancements()
 
         if use_cache:
             self._all_state = ret
@@ -439,7 +448,7 @@ class MultiWorld():
     def get_items(self) -> List[Item]:
         return [loc.item for loc in self.get_filled_locations()] + self.itempool
 
-    def find_item_locations(self, item, player: int, resolve_group_locations: bool = False) -> List[Location]:
+    def find_item_locations(self, item: str, player: int, resolve_group_locations: bool = False) -> List[Location]:
         if resolve_group_locations:
             player_groups = self.get_player_groups(player)
             return [location for location in self.get_locations() if
@@ -448,7 +457,7 @@ class MultiWorld():
         return [location for location in self.get_locations() if
                 location.item and location.item.name == item and location.item.player == player]
 
-    def find_item(self, item, player: int) -> Location:
+    def find_item(self, item: str, player: int) -> Location:
         return next(location for location in self.get_locations() if
                     location.item and location.item.name == item and location.item.player == player)
 
@@ -541,9 +550,9 @@ class MultiWorld():
                 return True
             state = starting_state.copy()
         else:
-            if self.has_beaten_game(self.state):
-                return True
             state = CollectionState(self)
+            if self.has_beaten_game(state):
+                return True
         prog_locations = {location for location in self.get_locations() if location.item
                           and location.item.advancement and location not in state.locations_checked}
 
@@ -616,8 +625,7 @@ class MultiWorld():
 
         def location_relevant(location: Location) -> bool:
             """Determine if this location is relevant to sweep."""
-            return location.progress_type != LocationProgressType.EXCLUDED \
-                and (location.player in players["full"] or location.advancement)
+            return location.player in players["full"] or location.advancement
 
         def all_done() -> bool:
             """Check if all access rules are fulfilled"""
@@ -662,7 +670,7 @@ class CollectionState():
     multiworld: MultiWorld
     reachable_regions: Dict[int, Set[Region]]
     blocked_connections: Dict[int, Set[Entrance]]
-    events: Set[Location]
+    advancements: Set[Location]
     path: Dict[Union[Region, Entrance], PathValue]
     locations_checked: Set[Location]
     stale: Dict[int, bool]
@@ -674,7 +682,7 @@ class CollectionState():
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
         self.blocked_connections = {player: set() for player in parent.get_all_ids()}
-        self.events = set()
+        self.advancements = set()
         self.path = {}
         self.locations_checked = set()
         self.stale = {player: True for player in parent.get_all_ids()}
@@ -686,17 +694,25 @@ class CollectionState():
 
     def update_reachable_regions(self, player: int):
         self.stale[player] = False
+        world: AutoWorld.World = self.multiworld.worlds[player]
         reachable_regions = self.reachable_regions[player]
-        blocked_connections = self.blocked_connections[player]
         queue = deque(self.blocked_connections[player])
-        start = self.multiworld.get_region("Menu", player)
+        start: Region = world.get_region(world.origin_region_name)
 
         # init on first call - this can't be done on construction since the regions don't exist yet
         if start not in reachable_regions:
             reachable_regions.add(start)
-            blocked_connections.update(start.exits)
+            self.blocked_connections[player].update(start.exits)
             queue.extend(start.exits)
 
+        if world.explicit_indirect_conditions:
+            self._update_reachable_regions_explicit_indirect_conditions(player, queue)
+        else:
+            self._update_reachable_regions_auto_indirect_conditions(player, queue)
+
+    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque):
+        reachable_regions = self.reachable_regions[player]
+        blocked_connections = self.blocked_connections[player]
         # run BFS on all connections, and keep track of those blocked by missing items
         while queue:
             connection = queue.popleft()
@@ -716,6 +732,29 @@ class CollectionState():
                     if new_entrance in blocked_connections and new_entrance not in queue:
                         queue.append(new_entrance)
 
+    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque):
+        reachable_regions = self.reachable_regions[player]
+        blocked_connections = self.blocked_connections[player]
+        new_connection: bool = True
+        # run BFS on all connections, and keep track of those blocked by missing items
+        while new_connection:
+            new_connection = False
+            while queue:
+                connection = queue.popleft()
+                new_region = connection.connected_region
+                if new_region in reachable_regions:
+                    blocked_connections.remove(connection)
+                elif connection.can_reach(self):
+                    assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
+                    reachable_regions.add(new_region)
+                    blocked_connections.remove(connection)
+                    blocked_connections.update(new_region.exits)
+                    queue.extend(new_region.exits)
+                    self.path[new_region] = (new_region.name, self.path.get(connection, None))
+                    new_connection = True
+            # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
+            queue.extend(blocked_connections)
+
     def copy(self) -> CollectionState:
         ret = CollectionState(self.multiworld)
         ret.prog_items = {player: counter.copy() for player, counter in self.prog_items.items()}
@@ -723,7 +762,7 @@ class CollectionState():
                                  self.reachable_regions.items()}
         ret.blocked_connections = {player: entrance_set.copy() for player, entrance_set in
                                    self.blocked_connections.items()}
-        ret.events = self.events.copy()
+        ret.advancements = self.advancements.copy()
         ret.path = self.path.copy()
         ret.locations_checked = self.locations_checked.copy()
         for function in self.additional_copy_functions:
@@ -756,19 +795,24 @@ class CollectionState():
         return self.multiworld.get_region(spot, player).can_reach(self)
 
     def sweep_for_events(self, locations: Optional[Iterable[Location]] = None) -> None:
+        Utils.deprecate("sweep_for_events has been renamed to sweep_for_advancements. The functionality is the same. "
+                        "Please switch over to sweep_for_advancements.")
+        return self.sweep_for_advancements(locations)
+
+    def sweep_for_advancements(self, locations: Optional[Iterable[Location]] = None) -> None:
         if locations is None:
             locations = self.multiworld.get_filled_locations()
-        reachable_events = True
-        # since the loop has a good chance to run more than once, only filter the events once
-        locations = {location for location in locations if location.advancement and location not in self.events}
+        reachable_advancements = True
+        # since the loop has a good chance to run more than once, only filter the advancements once
+        locations = {location for location in locations if location.advancement and location not in self.advancements}
 
-        while reachable_events:
-            reachable_events = {location for location in locations if location.can_reach(self)}
-            locations -= reachable_events
-            for event in reachable_events:
-                self.events.add(event)
-                assert isinstance(event.item, Item), "tried to collect Event with no Item"
-                self.collect(event.item, True, event)
+        while reachable_advancements:
+            reachable_advancements = {location for location in locations if location.can_reach(self)}
+            locations -= reachable_advancements
+            for advancement in reachable_advancements:
+                self.advancements.add(advancement)
+                assert isinstance(advancement.item, Item), "tried to collect Event with no Item"
+                self.collect(advancement.item, True, advancement)
 
     # item name related
     def has(self, item: str, player: int, count: int = 1) -> bool:
@@ -802,7 +846,7 @@ class CollectionState():
             if found >= count:
                 return True
         return False
-    
+
     def has_from_list_unique(self, items: Iterable[str], player: int, count: int) -> bool:
         """Returns True if the state contains at least `count` items matching any of the item names from a list.
         Ignores duplicates of the same item."""
@@ -817,7 +861,7 @@ class CollectionState():
     def count_from_list(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state."""
         return sum(self.prog_items[player][item_name] for item_name in items)
-    
+
     def count_from_list_unique(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state. Ignores duplicates of the same item."""
         return sum(self.prog_items[player][item_name] > 0 for item_name in items)
@@ -863,20 +907,16 @@ class CollectionState():
         )
 
     # Item related
-    def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
+    def collect(self, item: Item, prevent_sweep: bool = False, location: Optional[Location] = None) -> bool:
         if location:
             self.locations_checked.add(location)
 
         changed = self.multiworld.worlds[item.player].collect(self, item)
 
-        if not changed and event:
-            self.prog_items[item.player][item.name] += 1
-            changed = True
-
         self.stale[item.player] = True
 
-        if changed and not event:
-            self.sweep_for_events()
+        if changed and not prevent_sweep:
+            self.sweep_for_advancements()
 
         return changed
 
@@ -900,7 +940,7 @@ class Entrance:
     addresses = None
     target = None
 
-    def __init__(self, player: int, name: str = '', parent: Region = None):
+    def __init__(self, player: int, name: str = "", parent: Optional[Region] = None) -> None:
         self.name = name
         self.parent_region = parent
         self.player = player
@@ -920,9 +960,6 @@ class Entrance:
         region.entrances.append(self)
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         multiworld = self.parent_region.multiworld if self.parent_region else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
@@ -1048,7 +1085,7 @@ class Region:
             self.locations.append(location_type(self.player, location, address, self))
 
     def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[Callable[[CollectionState], bool]] = None) -> entrance_type:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
         """
         Connects this Region to another Region, placing the provided rule on the connection.
 
@@ -1088,9 +1125,6 @@ class Region:
                          rules[connecting_region] if rules and connecting_region in rules else None)
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         return self.multiworld.get_name_string_for_object(self) if self.multiworld else f'{self.name} (Player {self.player})'
 
 
@@ -1109,9 +1143,9 @@ class Location:
     locked: bool = False
     show_in_spoiler: bool = True
     progress_type: LocationProgressType = LocationProgressType.DEFAULT
-    always_allow = staticmethod(lambda state, item: False)
+    always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
     access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
-    item_rule = staticmethod(lambda item: True)
+    item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
     item: Optional[Item] = None
 
     def __init__(self, player: int, name: str = '', address: Optional[int] = None, parent: Optional[Region] = None):
@@ -1120,11 +1154,15 @@ class Location:
         self.address = address
         self.parent_region = parent
 
-    def can_fill(self, state: CollectionState, item: Item, check_access=True) -> bool:
-        return ((self.always_allow(state, item) and item.name not in state.multiworld.worlds[item.player].options.non_local_items)
-                or ((self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
-                    and self.item_rule(item)
-                    and (not check_access or self.can_reach(state))))
+    def can_fill(self, state: CollectionState, item: Item, check_access: bool = True) -> bool:
+        return ((
+            self.always_allow(state, item)
+            and item.name not in state.multiworld.worlds[item.player].options.non_local_items
+        ) or (
+            (self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
+            and self.item_rule(item)
+            and (not check_access or self.can_reach(state))
+        ))
 
     def can_reach(self, state: CollectionState) -> bool:
         # Region.can_reach is just a cache lookup, so placing it first for faster abort on average
@@ -1139,9 +1177,6 @@ class Location:
         self.locked = True
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         multiworld = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
@@ -1163,7 +1198,7 @@ class Location:
     @property
     def native_item(self) -> bool:
         """Returns True if the item in this location matches game."""
-        return self.item and self.item.game == self.game
+        return self.item is not None and self.item.game == self.game
 
     @property
     def hint_text(self) -> str:
@@ -1174,7 +1209,7 @@ class ItemClassification(IntFlag):
     filler = 0b0000  # aka trash, as in filler items like ammo, currency etc,
     progression = 0b0001  # Item that is logically relevant
     useful = 0b0010  # Item that is generally quite useful, but not required for anything logical
-    trap = 0b0100  # detrimental or entirely useless (nothing) item
+    trap = 0b0100  # detrimental item
     skip_balancing = 0b1000  # should technically never occur on its own
     # Item that is logically relevant, but progression balancing should not touch.
     # Typically currency or other counted items.
@@ -1246,9 +1281,6 @@ class Item:
         return hash((self.name, self.player))
 
     def __repr__(self) -> str:
-        return self.__str__()
-
-    def __str__(self) -> str:
         if self.location and self.location.parent_region and self.location.parent_region.multiworld:
             return self.location.parent_region.multiworld.get_name_string_for_object(self)
         return f"{self.name} (Player {self.player})"
@@ -1326,9 +1358,9 @@ class Spoiler:
 
         # in the second phase, we cull each sphere such that the game is still beatable,
         # reducing each range of influence to the bare minimum required inside it
-        restore_later = {}
+        restore_later: Dict[Location, Item] = {}
         for num, sphere in reversed(tuple(enumerate(collection_spheres))):
-            to_delete = set()
+            to_delete: Set[Location] = set()
             for location in sphere:
                 # we remove the item at location and check if game is still beatable
                 logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name,
@@ -1346,7 +1378,7 @@ class Spoiler:
             sphere -= to_delete
 
         # second phase, sphere 0
-        removed_precollected = []
+        removed_precollected: List[Item] = []
         for item in (i for i in chain.from_iterable(multiworld.precollected_items.values()) if i.advancement):
             logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
             multiworld.precollected_items[item.player].remove(item)
@@ -1427,7 +1459,7 @@ class Spoiler:
                 # Maybe move the big bomb over to the Event system instead?
                 if any(exit_path == 'Pyramid Fairy' for path in self.paths.values()
                        for (_, exit_path) in path):
-                    if multiworld.mode[player] != 'inverted':
+                    if multiworld.worlds[player].options.mode != 'inverted':
                         self.paths[str(multiworld.get_region('Big Bomb Shop', player))] = \
                             get_path(state, multiworld.get_region('Big Bomb Shop', player))
                     else:
@@ -1499,9 +1531,9 @@ class Spoiler:
 
             if self.paths:
                 outfile.write('\n\nPaths:\n\n')
-                path_listings = []
+                path_listings: List[str] = []
                 for location, path in sorted(self.paths.items()):
-                    path_lines = []
+                    path_lines: List[str] = []
                     for region, exit in path:
                         if exit is not None:
                             path_lines.append("{} -> {}".format(region, exit))

BizHawkClient.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import sys
 import ModuleUpdate
 ModuleUpdate.update()
 
 from worlds._bizhawk.context import launch
 
 if __name__ == "__main__":
-    launch()
+    launch(*sys.argv[1:])

CommonClient.py

@@ -252,7 +252,7 @@ class CommonContext:
     starting_reconnect_delay: int = 5
     current_reconnect_delay: int = starting_reconnect_delay
     command_processor: typing.Type[CommandProcessor] = ClientCommandProcessor
-    ui = None
+    ui: typing.Optional["kvui.GameManager"] = None
     ui_task: typing.Optional["asyncio.Task[None]"] = None
     input_task: typing.Optional["asyncio.Task[None]"] = None
     keep_alive_task: typing.Optional["asyncio.Task[None]"] = None
@@ -662,17 +662,19 @@ class CommonContext:
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
         self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
 
-    def run_gui(self):
-        """Import kivy UI system and start running it as self.ui_task."""
+    def make_gui(self) -> typing.Type["kvui.GameManager"]:
+        """To return the Kivy App class needed for run_gui so it can be overridden before being built"""
         from kvui import GameManager
 
         class TextManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
             base_title = "Archipelago Text Client"
 
-        self.ui = TextManager(self)
+        return TextManager
+
+    def run_gui(self):
+        """Import kivy UI system from make_gui() and start running it as self.ui_task."""
+        ui_class = self.make_gui()
+        self.ui = ui_class(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
     def run_cli(self):
@@ -994,7 +996,7 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-def run_as_textclient():
+def run_as_textclient(*args):
     class TextContext(CommonContext):
         # Text Mode to use !hint and such with games that have no text entry
         tags = CommonContext.tags | {"TextOnly"}
@@ -1033,15 +1035,18 @@ def run_as_textclient():
     parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
     parser.add_argument('--name', default=None, help="Slot Name to connect as.")
     parser.add_argument("url", nargs="?", help="Archipelago connection url")
-    args = parser.parse_args()
+    args = parser.parse_args(args)
 
     if args.url:
         url = urllib.parse.urlparse(args.url)
-        args.connect = url.netloc
-        if url.username:
-            args.name = urllib.parse.unquote(url.username)
-        if url.password:
-            args.password = urllib.parse.unquote(url.password)
+        if url.scheme == "archipelago":
+            args.connect = url.netloc
+            if url.username:
+                args.name = urllib.parse.unquote(url.username)
+            if url.password:
+                args.password = urllib.parse.unquote(url.password)
+        else:
+            parser.error(f"bad url, found {args.url}, expected url in form of archipelago://archipelago.gg:38281")
 
     colorama.init()
 
@@ -1051,4 +1056,4 @@ def run_as_textclient():
 
 if __name__ == '__main__':
     logging.getLogger().setLevel(logging.INFO)  # force log-level to work around log level resetting to WARNING
-    run_as_textclient()
+    run_as_textclient(*sys.argv[1:])  # default value for parse_args

Fill.py

@@ -12,7 +12,12 @@ from worlds.generic.Rules import add_item_rule
 
 
 class FillError(RuntimeError):
-    pass
+    def __init__(self, *args: typing.Union[str, typing.Any], **kwargs) -> None:
+        if "multiworld" in kwargs and isinstance(args[0], str):
+            placements = (args[0] + f"\nAll Placements:\n" +
+                          f"{[(loc, loc.item) for loc in kwargs['multiworld'].get_filled_locations()]}")
+            args = (placements, *args[1:])
+        super().__init__(*args)
 
 
 def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
@@ -24,7 +29,7 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     new_state = base_state.copy()
     for item in itempool:
         new_state.collect(item, True)
-    new_state.sweep_for_events(locations=locations)
+    new_state.sweep_for_advancements(locations=locations)
     return new_state
 
 
@@ -212,7 +217,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                             f"Unfilled locations:\n"
                             f"{', '.join(str(location) for location in locations)}\n"
                             f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
 
     item_pool.extend(unplaced_items)
 
@@ -299,7 +304,7 @@ def remaining_fill(multiworld: MultiWorld,
                             f"Unfilled locations:\n"
                             f"{', '.join(str(location) for location in locations)}\n"
                             f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
 
     itempool.extend(unplaced_items)
 
@@ -324,8 +329,8 @@ def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, lo
             pool.append(location.item)
             state.remove(location.item)
             location.item = None
-            if location in state.events:
-                state.events.remove(location)
+            if location in state.advancements:
+                state.advancements.remove(location)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
@@ -358,7 +363,7 @@ def distribute_early_items(multiworld: MultiWorld,
         early_priority_locations: typing.List[Location] = []
         loc_indexes_to_remove: typing.Set[int] = set()
         base_state = multiworld.state.copy()
-        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state.sweep_for_advancements(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
         for i, loc in enumerate(fill_locations):
             if loc.can_reach(base_state):
                 if loc.progress_type == LocationProgressType.PRIORITY:
@@ -470,28 +475,26 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         nonlocal lock_later
         lock_later.append(location)
 
+    single_player = multiworld.players == 1 and not multiworld.groups
+
     if prioritylocations:
         # "priority fill"
         fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
-                         single_player_placement=multiworld.players == 1, swap=False, on_place=mark_for_locking,
-                         name="Priority")
+                         single_player_placement=single_player, swap=False, on_place=mark_for_locking, name="Priority")
         accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
         # "advancement/progression fill"
         if panic_method == "swap":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=True,
-                             name="Progression", single_player_placement=multiworld.players == 1)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=True,
+                             name="Progression", single_player_placement=single_player)
         elif panic_method == "raise":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=False,
-                             name="Progression", single_player_placement=multiworld.players == 1)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
+                             name="Progression", single_player_placement=single_player)
         elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=False, allow_partial=True,
-                             name="Progression", single_player_placement=multiworld.players == 1)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
+                             allow_partial=True, name="Progression", single_player_placement=single_player)
             if progitempool:
                 for item in progitempool:
                     logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
@@ -506,7 +509,8 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         if progitempool:
             raise FillError(
                 f"Not enough locations for progression items. "
-                f"There are {len(progitempool)} more progression items than there are available locations."
+                f"There are {len(progitempool)} more progression items than there are available locations.",
+                multiworld=multiworld,
             )
         accessibility_corrections(multiworld, multiworld.state, defaultlocations)
 
@@ -523,7 +527,8 @@ def distribute_items_restrictive(multiworld: MultiWorld,
     if excludedlocations:
         raise FillError(
             f"Not enough filler items for excluded locations. "
-            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
+            f"There are {len(excludedlocations)} more excluded locations than filler or trap items.",
+            multiworld=multiworld,
         )
 
     restitempool = filleritempool + usefulitempool
@@ -551,7 +556,7 @@ def flood_items(multiworld: MultiWorld) -> None:
     progress_done = False
 
     # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_events()
+    multiworld.state.sweep_for_advancements()
 
     # fill multiworld from top of itempool while we can
     while not progress_done:
@@ -589,7 +594,7 @@ def flood_items(multiworld: MultiWorld) -> None:
             if candidate_item_to_place is not None:
                 item_to_place = candidate_item_to_place
             else:
-                raise FillError('No more progress items left to place.')
+                raise FillError('No more progress items left to place.', multiworld=multiworld)
 
         # find item to replace with progress item
         location_list = multiworld.get_reachable_locations()
@@ -739,7 +744,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
-                            reducing_state.sweep_for_events(locations=locations_to_test)
+                            reducing_state.sweep_for_advancements(locations=locations_to_test)
 
                             if multiworld.has_beaten_game(balancing_state):
                                 if not multiworld.has_beaten_game(reducing_state):
@@ -822,7 +827,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             warn(warning, force)
 
     swept_state = multiworld.state.copy()
-    swept_state.sweep_for_events()
+    swept_state.sweep_for_advancements()
     reachable = frozenset(multiworld.get_reachable_locations(swept_state))
     early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
     non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)

Generate.py

@@ -43,10 +43,10 @@ def mystery_argparse():
     parser.add_argument('--race', action='store_true', default=defaults.race)
     parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
     parser.add_argument('--log_level', default='info', help='Sets log level')
-    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
-                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
-    parser.add_argument('--plando', default=defaults.plando_options,
-                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
+    parser.add_argument("--csv_output", action="store_true",
+                        help="Output rolled player options to csv (made for async multiworld).")
+    parser.add_argument("--plando", default=defaults.plando_options,
+                        help="List of options that can be set manually. Can be combined, for example \"bosses, items\"")
     parser.add_argument("--skip_prog_balancing", action="store_true",
                         help="Skip progression balancing step during generation.")
     parser.add_argument("--skip_output", action="store_true",
@@ -155,6 +155,8 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
     erargs.outputpath = args.outputpath
     erargs.skip_prog_balancing = args.skip_prog_balancing
     erargs.skip_output = args.skip_output
+    erargs.name = {}
+    erargs.csv_output = args.csv_output
 
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
         {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
@@ -202,7 +204,7 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
 
                     if path == args.weights_file_path:  # if name came from the weights file, just use base player name
                         erargs.name[player] = f"Player{player}"
-                    elif not erargs.name[player]:  # if name was not specified, generate it from filename
+                    elif player not in erargs.name:  # if name was not specified, generate it from filename
                         erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
                     erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
 
@@ -215,28 +217,6 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
     if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
         raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in erargs.name.values())}")
 
-    if args.yaml_output:
-        import yaml
-        important = {}
-        for option, player_settings in vars(erargs).items():
-            if type(player_settings) == dict:
-                if all(type(value) != list for value in player_settings.values()):
-                    if len(player_settings.values()) > 1:
-                        important[option] = {player: value for player, value in player_settings.items() if
-                                             player <= args.yaml_output}
-                    else:
-                        logging.debug(f"No player settings defined for option '{option}'")
-
-            else:
-                if player_settings != "":  # is not empty name
-                    important[option] = player_settings
-                else:
-                    logging.debug(f"No player settings defined for option '{option}'")
-        if args.outputpath:
-            os.makedirs(args.outputpath, exist_ok=True)
-        with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
-            yaml.dump(important, f)
-
     return erargs, seed
 
 
@@ -511,7 +491,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
             continue
         logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers.")
     if PlandoOptions.items in plando_options:
-        ret.plando_items = game_weights.get("plando_items", [])
+        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
     if ret.game == "A Link to the Past":
         roll_alttp_settings(ret, game_weights)
 

KH1Client.py

@@ -0,0 +1,9 @@
+if __name__ == '__main__':
+    import ModuleUpdate
+    ModuleUpdate.update()
+
+    import Utils
+    Utils.init_logging("KH1Client", exception_logger="Client")
+
+    from worlds.kh1.Client import launch
+    launch()

Launcher.py

@@ -16,10 +16,11 @@ import multiprocessing
 import shlex
 import subprocess
 import sys
+import urllib.parse
 import webbrowser
 from os.path import isfile
 from shutil import which
-from typing import Callable, Sequence, Union, Optional
+from typing import Callable, Optional, Sequence, Tuple, Union
 
 import Utils
 import settings
@@ -107,7 +108,81 @@ components.extend([
 ])
 
 
-def identify(path: Union[None, str]):
+def handle_uri(path: str, launch_args: Tuple[str, ...]) -> None:
+    url = urllib.parse.urlparse(path)
+    queries = urllib.parse.parse_qs(url.query)
+    launch_args = (path, *launch_args)
+    client_component = None
+    text_client_component = None
+    if "game" in queries:
+        game = queries["game"][0]
+    else:  # TODO around 0.6.0 - this is for pre this change webhost uri's
+        game = "Archipelago"
+    for component in components:
+        if component.supports_uri and component.game_name == game:
+            client_component = component
+        elif component.display_name == "Text Client":
+            text_client_component = component
+
+    from kvui import App, Button, BoxLayout, Label, Clock, Window
+
+    class Popup(App):
+        timer_label: Label
+        remaining_time: Optional[int]
+
+        def __init__(self):
+            self.title = "Connect to Multiworld"
+            self.icon = r"data/icon.png"
+            super().__init__()
+
+        def build(self):
+            layout = BoxLayout(orientation="vertical")
+
+            if client_component is None:
+                self.remaining_time = 7
+                label_text = (f"A game client able to parse URIs was not detected for {game}.\n"
+                              f"Launching Text Client in 7 seconds...")
+                self.timer_label = Label(text=label_text)
+                layout.add_widget(self.timer_label)
+                Clock.schedule_interval(self.update_label, 1)
+            else:
+                layout.add_widget(Label(text="Select client to open and connect with."))
+                button_row = BoxLayout(orientation="horizontal", size_hint=(1, 0.4))
+
+                text_client_button = Button(
+                    text=text_client_component.display_name,
+                    on_release=lambda *args: run_component(text_client_component, *launch_args)
+                )
+                button_row.add_widget(text_client_button)
+
+                game_client_button = Button(
+                    text=client_component.display_name,
+                    on_release=lambda *args: run_component(client_component, *launch_args)
+                )
+                button_row.add_widget(game_client_button)
+
+                layout.add_widget(button_row)
+
+            return layout
+
+        def update_label(self, dt):
+            if self.remaining_time > 1:
+                # countdown the timer and string replace the number
+                self.remaining_time -= 1
+                self.timer_label.text = self.timer_label.text.replace(
+                    str(self.remaining_time + 1), str(self.remaining_time)
+                )
+            else:
+                # our timer is finished so launch text client and close down
+                run_component(text_client_component, *launch_args)
+                Clock.unschedule(self.update_label)
+                App.get_running_app().stop()
+                Window.close()
+
+    Popup().run()
+
+
+def identify(path: Union[None, str]) -> Tuple[Union[None, str], Union[None, Component]]:
     if path is None:
         return None, None
     for component in components:
@@ -266,7 +341,7 @@ def run_gui():
             if file and component:
                 run_component(component, file)
             else:
-                logging.warning(f"unable to identify component for {filename}")
+                logging.warning(f"unable to identify component for {file}")
 
         def _stop(self, *largs):
             # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
@@ -299,20 +374,24 @@ def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     elif not args:
         args = {}
 
-    if args.get("Patch|Game|Component", None) is not None:
-        file, component = identify(args["Patch|Game|Component"])
+    path = args.get("Patch|Game|Component|url", None)
+    if path is not None:
+        if path.startswith("archipelago://"):
+            handle_uri(path, args.get("args", ()))
+            return
+        file, component = identify(path)
         if file:
             args['file'] = file
         if component:
             args['component'] = component
         if not component:
-            logging.warning(f"Could not identify Component responsible for {args['Patch|Game|Component']}")
+            logging.warning(f"Could not identify Component responsible for {path}")
 
     if args["update_settings"]:
         update_settings()
-    if 'file' in args:
+    if "file" in args:
         run_component(args["component"], args["file"], *args["args"])
-    elif 'component' in args:
+    elif "component" in args:
         run_component(args["component"], *args["args"])
     elif not args["update_settings"]:
         run_gui()
@@ -322,12 +401,16 @@ if __name__ == '__main__':
     init_logging('Launcher')
     Utils.freeze_support()
     multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
-    parser = argparse.ArgumentParser(description='Archipelago Launcher')
+    parser = argparse.ArgumentParser(
+        description='Archipelago Launcher',
+        usage="[-h] [--update_settings] [Patch|Game|Component] [-- component args here]"
+    )
     run_group = parser.add_argument_group("Run")
     run_group.add_argument("--update_settings", action="store_true",
                            help="Update host.yaml and exit.")
-    run_group.add_argument("Patch|Game|Component", type=str, nargs="?",
-                           help="Pass either a patch file, a generated game or the name of a component to run.")
+    run_group.add_argument("Patch|Game|Component|url", type=str, nargs="?",
+                           help="Pass either a patch file, a generated game, the component name to run, or a url to "
+                                "connect with.")
     run_group.add_argument("args", nargs="*",
                            help="Arguments to pass to component.")
     main(parser.parse_args())

LinksAwakeningClient.py

@@ -467,6 +467,8 @@ class LinksAwakeningContext(CommonContext):
 
     def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
         self.client = LinksAwakeningClient()
+        self.slot_data = {}
+
         if magpie:
             self.magpie_enabled = True
             self.magpie = MagpieBridge()
@@ -564,6 +566,8 @@ class LinksAwakeningContext(CommonContext):
     def on_package(self, cmd: str, args: dict):
         if cmd == "Connected":
             self.game = self.slot_info[self.slot].game
+            self.slot_data = args.get("slot_data", {})
+            
         # TODO - use watcher_event
         if cmd == "ReceivedItems":
             for index, item in enumerate(args["items"], start=args["index"]):
@@ -628,6 +632,7 @@ class LinksAwakeningContext(CommonContext):
                             self.magpie.set_checks(self.client.tracker.all_checks)
                             await self.magpie.set_item_tracker(self.client.item_tracker)
                             await self.magpie.send_gps(self.client.gps_tracker)
+                            self.magpie.slot_data = self.slot_data
                         except Exception:
                             # Don't let magpie errors take out the client
                             pass

LttPAdjuster.py

@@ -14,7 +14,7 @@ import tkinter as tk
 from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
-from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, BOTH, TOP, LabelFrame, \
     IntVar, Checkbutton, E, W, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
 from tkinter.constants import DISABLED, NORMAL
 from urllib.parse import urlparse
@@ -29,7 +29,8 @@ from Utils import output_path, local_path, user_path, open_file, get_cert_none_s
 
 
 GAME_ALTTP = "A Link to the Past"
-
+WINDOW_MIN_HEIGHT = 525
+WINDOW_MIN_WIDTH = 425
 
 class AdjusterWorld(object):
     def __init__(self, sprite_pool):
@@ -242,16 +243,17 @@ def adjustGUI():
     from argparse import Namespace
     from Utils import __version__ as MWVersion
     adjustWindow = Tk()
+    adjustWindow.minsize(WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT)
     adjustWindow.wm_title("Archipelago %s LttP Adjuster" % MWVersion)
     set_icon(adjustWindow)
 
     rom_options_frame, rom_vars, set_sprite = get_rom_options_frame(adjustWindow)
 
-    bottomFrame2 = Frame(adjustWindow)
+    bottomFrame2 = Frame(adjustWindow, padx=8, pady=2)
 
     romFrame, romVar = get_rom_frame(adjustWindow)
 
-    romDialogFrame = Frame(adjustWindow)
+    romDialogFrame = Frame(adjustWindow, padx=8, pady=2)
     baseRomLabel2 = Label(romDialogFrame, text='Rom to adjust')
     romVar2 = StringVar()
     romEntry2 = Entry(romDialogFrame, textvariable=romVar2)
@@ -261,9 +263,9 @@ def adjustGUI():
         romVar2.set(rom)
 
     romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
-    romDialogFrame.pack(side=TOP, expand=True, fill=X)
-    baseRomLabel2.pack(side=LEFT)
-    romEntry2.pack(side=LEFT, expand=True, fill=X)
+    romDialogFrame.pack(side=TOP, expand=False, fill=X)
+    baseRomLabel2.pack(side=LEFT, expand=False, fill=X, padx=(0, 8))
+    romEntry2.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
     romSelectButton2.pack(side=LEFT)
 
     def adjustRom():
@@ -331,12 +333,11 @@ def adjustGUI():
         messagebox.showinfo(title="Success", message="Settings saved to persistent storage")
 
     adjustButton = Button(bottomFrame2, text='Adjust Rom', command=adjustRom)
-    rom_options_frame.pack(side=TOP)
+    rom_options_frame.pack(side=TOP, padx=8, pady=8, fill=BOTH, expand=True)
     adjustButton.pack(side=LEFT, padx=(5,5))
 
     saveButton = Button(bottomFrame2, text='Save Settings', command=saveGUISettings)
     saveButton.pack(side=LEFT, padx=(5,5))
-
     bottomFrame2.pack(side=TOP, pady=(5,5))
 
     tkinter_center_window(adjustWindow)
@@ -576,7 +577,7 @@ class AttachTooltip(object):
 def get_rom_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
 
-    romFrame = Frame(parent)
+    romFrame = Frame(parent, padx=8, pady=8)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
     romVar = StringVar(value=adjuster_settings.baserom)
     romEntry = Entry(romFrame, textvariable=romVar)
@@ -596,20 +597,19 @@ def get_rom_frame(parent=None):
     romSelectButton = Button(romFrame, text='Select Rom', command=RomSelect)
 
     baseRomLabel.pack(side=LEFT)
-    romEntry.pack(side=LEFT, expand=True, fill=X)
+    romEntry.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
     romSelectButton.pack(side=LEFT)
-    romFrame.pack(side=TOP, expand=True, fill=X)
+    romFrame.pack(side=TOP, fill=X)
 
     return romFrame, romVar
 
 def get_rom_options_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
 
-    romOptionsFrame = LabelFrame(parent, text="Rom options")
-    romOptionsFrame.columnconfigure(0, weight=1)
-    romOptionsFrame.columnconfigure(1, weight=1)
+    romOptionsFrame = LabelFrame(parent, text="Rom options", padx=8, pady=8)
+
     for i in range(5):
-        romOptionsFrame.rowconfigure(i, weight=1)
+        romOptionsFrame.rowconfigure(i, weight=0, pad=4)
     vars = Namespace()
 
     vars.MusicVar = IntVar()
@@ -660,7 +660,7 @@ def get_rom_options_frame(parent=None):
     spriteSelectButton = Button(spriteDialogFrame, text='...', command=SpriteSelect)
 
     baseSpriteLabel.pack(side=LEFT)
-    spriteEntry.pack(side=LEFT)
+    spriteEntry.pack(side=LEFT, expand=True, fill=X)
     spriteSelectButton.pack(side=LEFT)
 
     oofDialogFrame = Frame(romOptionsFrame)

Main.py

@@ -11,7 +11,8 @@ from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
 from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
-from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, flood_items
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
+    flood_items
 from Options import StartInventoryPool
 from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
@@ -45,6 +46,9 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     multiworld.sprite_pool = args.sprite_pool.copy()
 
     multiworld.set_options(args)
+    if args.csv_output:
+        from Options import dump_player_options
+        dump_player_options(multiworld)
     multiworld.set_item_links()
     multiworld.state = CollectionState(multiworld)
     logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, multiworld.seed)
@@ -100,7 +104,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 multiworld.early_items[player][item_name] = max(0, early-count)
                 remaining_count = count-early
                 if remaining_count > 0:
-                    local_early = multiworld.early_local_items[player].get(item_name, 0)
+                    local_early = multiworld.local_early_items[player].get(item_name, 0)
                     if local_early:
                         multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
                     del local_early
@@ -346,7 +350,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
                 if not multiworld.can_beat_game():
-                    raise Exception("Game appears as unbeatable. Aborting.")
+                    raise FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 

ModuleUpdate.py

@@ -75,13 +75,13 @@ def update(yes: bool = False, force: bool = False) -> None:
     if not update_ran:
         update_ran = True
 
+        install_pkg_resources(yes=yes)
+        import pkg_resources
+
         if force:
             update_command()
             return
 
-        install_pkg_resources(yes=yes)
-        import pkg_resources
-
         prev = ""  # if a line ends in \ we store here and merge later
         for req_file in requirements_files:
             path = os.path.join(os.path.dirname(sys.argv[0]), req_file)

MultiServer.py

@@ -67,6 +67,21 @@ def update_dict(dictionary, entries):
     return dictionary
 
 
+def queue_gc():
+    import gc
+    from threading import Thread
+
+    gc_thread: typing.Optional[Thread] = getattr(queue_gc, "_thread", None)
+    def async_collect():
+        time.sleep(2)
+        setattr(queue_gc, "_thread", None)
+        gc.collect()
+    if not gc_thread:
+        gc_thread = Thread(target=async_collect)
+        setattr(queue_gc, "_thread", gc_thread)
+        gc_thread.start()
+
+
 # functions callable on storable data on the server by clients
 modify_functions = {
     # generic:
@@ -551,6 +566,9 @@ class Context:
                         self.logger.info(f"Saving failed. Retry in {self.auto_save_interval} seconds.")
                     else:
                         self.save_dirty = False
+                if not atexit_save:  # if atexit is used, that keeps a reference anyway
+                    queue_gc()
+
             self.auto_saver_thread = threading.Thread(target=save_regularly, daemon=True)
             self.auto_saver_thread.start()
 
@@ -991,7 +1009,7 @@ def collect_player(ctx: Context, team: int, slot: int, is_group: bool = False):
                     collect_player(ctx, team, group, True)
 
 
-def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
+def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[typing.Tuple[int, int]]:
     return ctx.locations.get_remaining(ctx.location_checks, team, slot)
 
 
@@ -1203,6 +1221,10 @@ class CommonCommandProcessor(CommandProcessor):
             timer = int(seconds, 10)
         except ValueError:
             timer = 10
+        else:
+            if timer > 60 * 60:
+                raise ValueError(f"{timer} is invalid. Maximum is 1 hour.")
+
         async_start(countdown(self.ctx, timer))
         return True
 
@@ -1350,10 +1372,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
     def _cmd_remaining(self) -> bool:
         """List remaining items in your game, but not their location or recipient"""
         if self.ctx.remaining_mode == "enabled":
-            remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
-            if remaining_item_ids:
-                self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[self.client.slot]][item_id]
-                                                            for item_id in remaining_item_ids))
+            rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
+            if rest_locations:
+                self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
+                                                            for slot, item_id in rest_locations))
             else:
                 self.output("No remaining items found.")
             return True
@@ -1363,10 +1385,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
             return False
         else:  # is goal
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
-                remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
-                if remaining_item_ids:
-                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[self.client.slot]][item_id]
-                                                                for item_id in remaining_item_ids))
+                rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
+                if rest_locations:
+                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
+                                                                for slot, item_id in rest_locations))
                 else:
                     self.output("No remaining items found.")
                 return True
@@ -2039,6 +2061,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
             item_name, usable, response = get_intended_text(item_name, names)
             if usable:
                 amount: int = int(amount)
+                if amount > 100:
+                    raise ValueError(f"{amount} is invalid. Maximum is 100.")
                 new_items = [NetworkItem(names[item_name], -1, 0) for _ in range(int(amount))]
                 send_items_to(self.ctx, team, slot, *new_items)
 

NetUtils.py

@@ -79,6 +79,7 @@ class NetworkItem(typing.NamedTuple):
     item: int
     location: int
     player: int
+    """ Sending player, except in LocationInfo (from LocationScouts), where it is the receiving player. """
     flags: int = 0
 
 
@@ -272,7 +273,8 @@ class RawJSONtoTextParser(JSONtoTextParser):
 
 color_codes = {'reset': 0, 'bold': 1, 'underline': 4, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34,
                'magenta': 35, 'cyan': 36, 'white': 37, 'black_bg': 40, 'red_bg': 41, 'green_bg': 42, 'yellow_bg': 43,
-               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
+               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47,
+               'plum': 35, 'slateblue': 34, 'salmon': 31,}  # convert ui colors to terminal colors
 
 
 def color_code(*args):
@@ -397,12 +399,12 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
                 location_id not in checked]
 
     def get_remaining(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
-                      ) -> typing.List[int]:
+                      ) -> typing.List[typing.Tuple[int, int]]:
         checked = state[team, slot]
         player_locations = self[slot]
-        return sorted([player_locations[location_id][0] for
-                       location_id in player_locations if
-                       location_id not in checked])
+        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
+                        location_id in player_locations if
+                        location_id not in checked])
 
 
 if typing.TYPE_CHECKING:  # type-check with pure python implementation until we have a typing stub

Options.py

@@ -8,16 +8,17 @@ import numbers
 import random
 import typing
 import enum
+from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass
 
 from schema import And, Optional, Or, Schema
 from typing_extensions import Self
 
-from Utils import get_fuzzy_results, is_iterable_except_str
+from Utils import get_fuzzy_results, is_iterable_except_str, output_path
 
 if typing.TYPE_CHECKING:
-    from BaseClasses import PlandoOptions
+    from BaseClasses import MultiWorld, PlandoOptions
     from worlds.AutoWorld import World
     import pathlib
 
@@ -973,7 +974,19 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                     if random.random() < float(text.get("percentage", 100)/100):
                         at = text.get("at", None)
                         if at is not None:
+                            if isinstance(at, dict):
+                                if at:
+                                    at = random.choices(list(at.keys()),
+                                                        weights=list(at.values()), k=1)[0]
+                                else:
+                                    raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                             given_text = text.get("text", [])
+                            if isinstance(given_text, dict):
+                                if not given_text:
+                                    given_text = []
+                                else:
+                                    given_text = random.choices(list(given_text.keys()),
+                                                                weights=list(given_text.values()), k=1)
                             if isinstance(given_text, str):
                                 given_text = [given_text]
                             texts.append(PlandoText(
@@ -981,6 +994,8 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                                 given_text,
                                 text.get("percentage", 100)
                             ))
+                        else:
+                            raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                 elif isinstance(text, PlandoText):
                     if random.random() < float(text.percentage/100):
                         texts.append(text)
@@ -1321,7 +1336,7 @@ class PriorityLocations(LocationSet):
 
 
 class DeathLink(Toggle):
-    """When you die, everyone dies. Of course the reverse is true too."""
+    """When you die, everyone who enabled death link dies. Of course, the reverse is true too."""
     display_name = "Death Link"
     rich_text_doc = True
 
@@ -1520,29 +1535,40 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
                 f.write(res)
 
 
-if __name__ == "__main__":
+def dump_player_options(multiworld: MultiWorld) -> None:
+    from csv import DictWriter
 
-    from worlds.alttp.Options import Logic
-    import argparse
+    game_players = defaultdict(list)
+    for player, game in multiworld.game.items():
+        game_players[game].append(player)
+    game_players = dict(sorted(game_players.items()))
 
-    map_shuffle = Toggle
-    compass_shuffle = Toggle
-    key_shuffle = Toggle
-    big_key_shuffle = Toggle
-    hints = Toggle
-    test = argparse.Namespace()
-    test.logic = Logic.from_text("no_logic")
-    test.map_shuffle = map_shuffle.from_text("ON")
-    test.hints = hints.from_text('OFF')
-    try:
-        test.logic = Logic.from_text("overworld_glitches_typo")
-    except KeyError as e:
-        print(e)
-    try:
-        test.logic_owg = Logic.from_text("owg")
-    except KeyError as e:
-        print(e)
-    if test.map_shuffle:
-        print("map_shuffle is on")
-    print(f"Hints are {bool(test.hints)}")
-    print(test)
+    output = []
+    per_game_option_names = [
+        getattr(option, "display_name", option_key)
+        for option_key, option in PerGameCommonOptions.type_hints.items()
+    ]
+    all_option_names = per_game_option_names.copy()
+    for game, players in game_players.items():
+        game_option_names = per_game_option_names.copy()
+        for player in players:
+            world = multiworld.worlds[player]
+            player_output = {
+                "Game": multiworld.game[player],
+                "Name": multiworld.get_player_name(player),
+            }
+            output.append(player_output)
+            for option_key, option in world.options_dataclass.type_hints.items():
+                if issubclass(Removed, option):
+                    continue
+                display_name = getattr(option, "display_name", option_key)
+                player_output[display_name] = getattr(world.options, option_key).current_option_name
+                if display_name not in game_option_names:
+                    all_option_names.append(display_name)
+                    game_option_names.append(display_name)
+
+    with open(output_path(f"generate_{multiworld.seed_name}.csv"), mode="w", newline="") as file:
+        fields = ["Game", "Name", *all_option_names]
+        writer = DictWriter(file, fields)
+        writer.writeheader()
+        writer.writerows(output)

README.md

@@ -73,6 +73,9 @@ Currently, the following games are supported:
 * Yu-Gi-Oh! Ultimate Masters: World Championship Tournament 2006
 * A Hat in Time
 * Old School Runescape
+* Kingdom Hearts 1
+* Mega Man 2
+* Yacht Dice
 
 For setup and instructions check out our [tutorials page](https://archipelago.gg/tutorial/).
 Downloads can be found at [Releases](https://github.com/ArchipelagoMW/Archipelago/releases), including compiled

Utils.py

@@ -46,7 +46,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.5.0"
+__version__ = "0.5.1"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")

WebHost.py

@@ -1,3 +1,4 @@
+import argparse
 import os
 import multiprocessing
 import logging
@@ -31,6 +32,15 @@ def get_app() -> "Flask":
         import yaml
         app.config.from_file(configpath, yaml.safe_load)
         logging.info(f"Updated config from {configpath}")
+    # inside get_app() so it's usable in systems like gunicorn, which do not run WebHost.py, but import it.
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config_override', default=None,
+                        help="Path to yaml config file that overrules config.yaml.")
+    args = parser.parse_known_args()[0]
+    if args.config_override:
+        import yaml
+        app.config.from_file(os.path.abspath(args.config_override), yaml.safe_load)
+        logging.info(f"Updated config from {args.config_override}")
     if not app.config["HOST_ADDRESS"]:
         logging.info("Getting public IP, as HOST_ADDRESS is empty.")
         app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()

WebHostLib/api/__init__.py

@@ -1,51 +1,15 @@
 """API endpoints package."""
 from typing import List, Tuple
-from uuid import UUID
 
-from flask import Blueprint, abort, url_for
+from flask import Blueprint
 
-import worlds.Files
-from ..models import Room, Seed
+from ..models import Seed
 
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
 
-# unsorted/misc endpoints
-
 
 def get_players(seed: Seed) -> List[Tuple[str, str]]:
     return [(slot.player_name, slot.game) for slot in seed.slots]
 
 
-@api_endpoints.route('/room_status/<suuid:room>')
-def room_info(room: UUID):
-    room = Room.get(id=room)
-    if room is None:
-        return abort(404)
-    
-    def supports_apdeltapatch(game: str):
-        return game in worlds.Files.AutoPatchRegister.patch_types
-    downloads = []
-    for slot in sorted(room.seed.slots):
-        if slot.data and not supports_apdeltapatch(slot.game):
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
-            }
-            downloads.append(slot_download)
-        elif slot.data:
-            slot_download = {
-                "slot": slot.player_id,
-                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
-            }
-            downloads.append(slot_download)
-    return {
-        "tracker": room.tracker,
-        "players": get_players(room.seed),
-        "last_port": room.last_port,
-        "last_activity": room.last_activity,
-        "timeout": room.timeout,
-        "downloads": downloads,
-    }
-
-
-from . import generate, user, datapackage  # trigger registration
+from . import datapackage, generate, room, user  # trigger registration

WebHostLib/api/room.py

@@ -0,0 +1,42 @@
+from typing import Any, Dict
+from uuid import UUID
+
+from flask import abort, url_for
+
+import worlds.Files
+from . import api_endpoints, get_players
+from ..models import Room
+
+
+@api_endpoints.route('/room_status/<suuid:room_id>')
+def room_info(room_id: UUID) -> Dict[str, Any]:
+    room = Room.get(id=room_id)
+    if room is None:
+        return abort(404)
+
+    def supports_apdeltapatch(game: str) -> bool:
+        return game in worlds.Files.AutoPatchRegister.patch_types
+
+    downloads = []
+    for slot in sorted(room.seed.slots):
+        if slot.data and not supports_apdeltapatch(slot.game):
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
+            }
+            downloads.append(slot_download)
+        elif slot.data:
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
+            }
+            downloads.append(slot_download)
+
+    return {
+        "tracker": room.tracker,
+        "players": get_players(room.seed),
+        "last_port": room.last_port,
+        "last_activity": room.last_activity,
+        "timeout": room.timeout,
+        "downloads": downloads,
+    }

WebHostLib/customserver.py

@@ -72,6 +72,14 @@ class WebHostContext(Context):
         self.video = {}
         self.tags = ["AP", "WebHost"]
 
+    def __del__(self):
+        try:
+            import psutil
+            from Utils import format_SI_prefix
+            self.logger.debug(f"Context destroyed, Mem: {format_SI_prefix(psutil.Process().memory_info().rss, 1024)}iB")
+        except ImportError:
+            self.logger.debug("Context destroyed")
+
     def _load_game_data(self):
         for key, value in self.static_server_data.items():
             # NOTE: attributes are mutable and shared, so they will have to be copied before being modified
@@ -249,6 +257,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                 ctx = WebHostContext(static_server_data, logger)
                 ctx.load(room_id)
                 ctx.init_save()
+                assert ctx.server is None
                 try:
                     ctx.server = websockets.serve(
                         functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
@@ -279,6 +288,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     ctx.auto_shutdown = Room.get(id=room_id).timeout
                 if ctx.saving:
                     setattr(asyncio.current_task(), "save", lambda: ctx._save(True))
+                assert ctx.shutdown_task is None
                 ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
                 await ctx.shutdown_task
 
@@ -325,7 +335,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
         def run(self):
             while 1:
                 next_room = rooms_to_run.get(block=True,  timeout=None)
-                gc.collect(0)
+                gc.collect()
                 task = asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
                 self._tasks.append(task)
                 task.add_done_callback(self._done)

WebHostLib/generate.py

@@ -134,6 +134,7 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
                                                                        {"bosses", "items", "connections", "texts"}))
         erargs.skip_prog_balancing = False
         erargs.skip_output = False
+        erargs.csv_output = False
 
         name_counter = Counter()
         for player, (playerfile, settings) in enumerate(gen_options.items(), 1):

WebHostLib/misc.py

@@ -132,26 +132,41 @@ def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
     return "Access Denied", 403
 
 
-@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
+@app.post("/room/<suuid:room>")
+def host_room_command(room: UUID):
+    room: Room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+
+    if room.owner == session["_id"]:
+        cmd = request.form["cmd"]
+        if cmd:
+            Command(room=room, commandtext=cmd)
+            commit()
+    return redirect(url_for("host_room", room=room.id))
+
+
+@app.get("/room/<suuid:room>")
 def host_room(room: UUID):
     room: Room = Room.get(id=room)
     if room is None:
         return abort(404)
-    if request.method == "POST":
-        if room.owner == session["_id"]:
-            cmd = request.form["cmd"]
-            if cmd:
-                Command(room=room, commandtext=cmd)
-                commit()
-        return redirect(url_for("host_room", room=room.id))
 
     now = datetime.datetime.utcnow()
     # indicate that the page should reload to get the assigned port
-    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
+    should_refresh = ((not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
+                      or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
     with db_session:
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
-    def get_log(max_size: int = 1024000) -> str:
+    browser_tokens = "Mozilla", "Chrome", "Safari"
+    automated = ("update" in request.args
+                 or "Discordbot" in request.user_agent.string
+                 or not any(browser_token in request.user_agent.string for browser_token in browser_tokens))
+
+    def get_log(max_size: int = 0 if automated else 1024000) -> str:
+        if max_size == 0:
+            return "…"
         try:
             with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
                 raw_size = 0

WebHostLib/requirements.txt

@@ -1,10 +1,11 @@
 flask>=3.0.3
-werkzeug>=3.0.3
-pony>=0.7.17
+werkzeug>=3.0.4
+pony>=0.7.19
 waitress>=3.0.0
 Flask-Caching>=2.3.0
 Flask-Compress>=1.15
-Flask-Limiter>=3.7.0
+Flask-Limiter>=3.8.0
 bokeh>=3.1.1; python_version <= '3.8'
-bokeh>=3.4.1; python_version >= '3.9'
+bokeh>=3.4.3; python_version == '3.9'
+bokeh>=3.5.2; python_version >= '3.10'
 markupsafe>=2.1.5

WebHostLib/static/assets/faq/faq_en.md

@@ -77,4 +77,4 @@ There, you will find examples of games in the `worlds` folder:
 You may also find developer documentation in the `docs` folder:  
 [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
 
-If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.
+If you have more questions, feel free to ask in the **#ap-world-dev** channel on our Discord.

WebHostLib/static/styles/hostRoom.css

@@ -58,3 +58,28 @@
     overflow-y: auto;
     max-height: 400px;
 }
+
+.loader{
+  display: inline-block;
+  visibility: hidden;
+  margin-left: 5px;
+  width: 40px;
+  aspect-ratio: 4;
+  --_g: no-repeat radial-gradient(circle closest-side,#fff 90%,#fff0);
+  background:
+    var(--_g) 0    50%,
+    var(--_g) 50%  50%,
+    var(--_g) 100% 50%;
+  background-size: calc(100%/3) 100%;
+  animation: l7 1s infinite linear;
+}
+
+.loader.loading{
+  visibility: visible;
+}
+
+@keyframes l7{
+  33%{background-size:calc(100%/3) 0%  ,calc(100%/3) 100%,calc(100%/3) 100%}
+  50%{background-size:calc(100%/3) 100%,calc(100%/3) 0   ,calc(100%/3) 100%}
+  66%{background-size:calc(100%/3) 100%,calc(100%/3) 100%,calc(100%/3) 0   }
+}

WebHostLib/templates/hostRoom.html

@@ -19,28 +19,30 @@
 {% block body %}
     {% include 'header/grassHeader.html' %}
     <div id="host-room">
-        {% if room.owner == session["_id"] %}
-            Room created from <a href="{{ url_for("view_seed", seed=room.seed.id) }}">Seed #{{ room.seed.id|suuid }}</a>
-            <br />
-        {% endif %}
-        {% if room.tracker %}
-            This room has a <a href="{{ url_for("get_multiworld_tracker", tracker=room.tracker) }}">Multiworld Tracker</a>
-            and a <a href="{{ url_for("get_multiworld_sphere_tracker", tracker=room.tracker) }}">Sphere Tracker</a> enabled.
-            <br />
-        {% endif %}
-        The server for this room will be paused after {{ room.timeout//60//60 }} hours of inactivity.
-        Should you wish to continue later,
-        anyone can simply refresh this page and the server will resume.<br>
-        {% if room.last_port == -1 %}
-            There was an error hosting this Room. Another attempt will be made on refreshing this page.
-            The most likely failure reason is that the multiworld is too old to be loaded now.
-        {% elif room.last_port %}
-            You can connect to this room by using <span class="interactive"
-            data-tooltip="This means address/ip is {{ config['HOST_ADDRESS'] }} and port is {{ room.last_port }}.">
-            '/connect {{ config['HOST_ADDRESS'] }}:{{ room.last_port }}'
-            </span>
-            in the <a href="{{ url_for("tutorial_landing")}}">client</a>.<br>
-        {% endif %}
+        <span id="host-room-info">
+            {% if room.owner == session["_id"] %}
+                Room created from <a href="{{ url_for("view_seed", seed=room.seed.id) }}">Seed #{{ room.seed.id|suuid }}</a>
+                <br />
+            {% endif %}
+            {% if room.tracker %}
+                This room has a <a href="{{ url_for("get_multiworld_tracker", tracker=room.tracker) }}">Multiworld Tracker</a>
+                and a <a href="{{ url_for("get_multiworld_sphere_tracker", tracker=room.tracker) }}">Sphere Tracker</a> enabled.
+                <br />
+            {% endif %}
+            The server for this room will be paused after {{ room.timeout//60//60 }} hours of inactivity.
+            Should you wish to continue later,
+            anyone can simply refresh this page and the server will resume.<br>
+            {% if room.last_port == -1 %}
+                There was an error hosting this Room. Another attempt will be made on refreshing this page.
+                The most likely failure reason is that the multiworld is too old to be loaded now.
+            {% elif room.last_port %}
+                You can connect to this room by using <span class="interactive"
+                data-tooltip="This means address/ip is {{ config['HOST_ADDRESS'] }} and port is {{ room.last_port }}.">
+                '/connect {{ config['HOST_ADDRESS'] }}:{{ room.last_port }}'
+                </span>
+                in the <a href="{{ url_for("tutorial_landing")}}">client</a>.<br>
+            {% endif %}
+        </span>
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}
             <div style="display: flex; align-items: center;">
@@ -49,6 +51,7 @@
                         <label for="cmd"></label>
                         <input class="form-control" type="text" id="cmd" name="cmd"
                                placeholder="Server Command. /help to list them, list gets appended to log.">
+                        <span class="loader"></span>
                     </div>
                 </form>
                 <a href="{{ url_for("display_log", room=room.id) }}">
@@ -62,6 +65,7 @@
           let url = '{{ url_for('display_log', room = room.id) }}';
           let bytesReceived = {{ log_len }};
           let updateLogTimeout;
+          let updateLogImmediately = false;
           let awaitingCommandResponse = false;
           let logger = document.getElementById("logger");
 
@@ -78,29 +82,36 @@
 
           async function updateLog() {
             try {
-              let res = await fetch(url, {
-                headers: {
-                  'Range': `bytes=${bytesReceived}-`,
-                }
-              });
-              if (res.ok) {
-                let text = await res.text();
-                if (text.length > 0) {
-                  awaitingCommandResponse = false;
-                  if (bytesReceived === 0 || res.status !== 206) {
-                    logger.innerHTML = '';
-                  }
-                  if (res.status !== 206) {
-                    bytesReceived = 0;
-                  } else {
-                    bytesReceived += new Blob([text]).size;
-                  }
-                  if (logger.innerHTML.endsWith('…')) {
-                    logger.innerHTML = logger.innerHTML.substring(0, logger.innerHTML.length - 1);
-                  }
-                  logger.appendChild(document.createTextNode(text));
-                  scrollToBottom(logger);
+              if (!document.hidden) {
+                updateLogImmediately = false;
+                let res = await fetch(url, {
+                  headers: {
+                    'Range': `bytes=${bytesReceived}-`,
+                  }
+                });
+                if (res.ok) {
+                  let text = await res.text();
+                  if (text.length > 0) {
+                    awaitingCommandResponse = false;
+                    if (bytesReceived === 0 || res.status !== 206) {
+                      logger.innerHTML = '';
+                    }
+                    if (res.status !== 206) {
+                      bytesReceived = 0;
+                    } else {
+                      bytesReceived += new Blob([text]).size;
+                    }
+                    if (logger.innerHTML.endsWith('…')) {
+                      logger.innerHTML = logger.innerHTML.substring(0, logger.innerHTML.length - 1);
+                    }
+                    logger.appendChild(document.createTextNode(text));
+                    scrollToBottom(logger);
+                    let loader = document.getElementById("command-form").getElementsByClassName("loader")[0];
+                    loader.classList.remove("loading");
+                  }
                 }
+              } else {
+                updateLogImmediately = true;
               }
             }
             finally {
@@ -125,20 +136,62 @@
             });
             ev.preventDefault(); // has to happen before first await
             form.reset();
-            let res = await req;
-            if (res.ok || res.type === 'opaqueredirect') {
-              awaitingCommandResponse = true;
-              window.clearTimeout(updateLogTimeout);
-              updateLogTimeout = window.setTimeout(updateLog, 100);
-            } else {
-              window.alert(res.statusText);
+            let loader = form.getElementsByClassName("loader")[0];
+            loader.classList.add("loading");
+            try {
+              let res = await req;
+              if (res.ok || res.type === 'opaqueredirect') {
+                awaitingCommandResponse = true;
+                window.clearTimeout(updateLogTimeout);
+                updateLogTimeout = window.setTimeout(updateLog, 100);
+              } else {
+                loader.classList.remove("loading");
+                window.alert(res.statusText);
+              }
+            } catch (e) {
+                console.error(e);
+                loader.classList.remove("loading");
+                window.alert(e.message);
             }
           }
 
           document.getElementById("command-form").addEventListener("submit", postForm);
           updateLogTimeout = window.setTimeout(updateLog, 1000);
           logger.scrollTop = logger.scrollHeight;
+          document.addEventListener("visibilitychange", () => {
+            if (!document.hidden && updateLogImmediately) {
+              updateLog();
+            }
+          })
         </script>
         {% endif %}
+        <script>
+          function updateInfo() {
+            let url = new URL(window.location.href);
+            url.search = "?update";
+            fetch(url)
+              .then(res => {
+                if (!res.ok) {
+                  throw new Error(`HTTP error ${res.status}`);
+                }
+                return res.text()
+              })
+              .then(text => new DOMParser().parseFromString(text, 'text/html'))
+              .then(newDocument => {
+                let el = newDocument.getElementById("host-room-info");
+                document.getElementById("host-room-info").innerHTML = el.innerHTML;
+            });
+          }
+
+          if (document.querySelector("meta[http-equiv='refresh']")) {
+            console.log("Refresh!");
+            window.addEventListener('load', function () {
+              for (let i=0; i<3; i++) {
+                window.setTimeout(updateInfo, Math.pow(2, i) * 2000); // 2, 4, 8s
+              }
+              window.stop(); // cancel meta refresh
+            })
+          }
+        </script>
     </div>
 {% endblock %}

WebHostLib/templates/macros.html

@@ -22,7 +22,7 @@
             {% for patch in room.seed.slots|list|sort(attribute="player_id") %}
                 <tr>
                     <td>{{ patch.player_id }}</td>
-                    <td data-tooltip="Connect via TextClient"><a href="archipelago://{{ patch.player_name | e}}:None@{{ config['HOST_ADDRESS'] }}:{{ room.last_port }}">{{ patch.player_name }}</a></td>
+                    <td data-tooltip="Connect via Game Client"><a href="archipelago://{{ patch.player_name | e}}:None@{{ config['HOST_ADDRESS'] }}:{{ room.last_port }}?game={{ patch.game }}&room={{ room.id | suuid }}">{{ patch.player_name }}</a></td>
                     <td>{{ patch.game }}</td>
                     <td>
                         {% if patch.data %}

WebHostLib/templates/userContent.html

@@ -69,7 +69,7 @@
                     </tbody>
                 </table>
             {% else %}
-                You have no generated any seeds yet!
+                You have not generated any seeds yet!
             {% endif %}
         </div>
     </div>

WebHostLib/templates/weightedOptions/macros.html

@@ -138,7 +138,7 @@
                     id="{{ option_name }}-{{ key }}"
                     name="{{ option_name }}||{{ key }}"
                     value="1"
-                    checked="{{ "checked" if key in option.default else "" }}"
+                    {{ "checked" if key in option.default }}
                 />
                 <label for="{{ option_name }}-{{ key }}">
                     {{ key }}

_speedups.pyx

@@ -287,15 +287,15 @@ cdef class LocationStore:
                     entry in self.entries[start:start + count] if
                     entry.location not in checked]
 
-    def get_remaining(self, state: State, team: int, slot: int) -> List[int]:
+    def get_remaining(self, state: State, team: int, slot: int) -> List[Tuple[int, int]]:
         cdef LocationEntry* entry
         cdef ap_player_t sender = slot
         cdef size_t start = self.sender_index[sender].start
         cdef size_t count = self.sender_index[sender].count
         cdef set checked = state[team, slot]
-        return sorted([entry.item for
-                       entry in self.entries[start:start+count] if
-                       entry.location not in checked])
+        return sorted([(entry.receiver, entry.item) for
+                        entry in self.entries[start:start+count] if
+                        entry.location not in checked])
 
 
 @cython.auto_pickle(False)

docs/CODEOWNERS

@@ -46,7 +46,7 @@
 /worlds/clique/ @ThePhar
 
 # Dark Souls III
-/worlds/dark_souls_3/ @Marechal-L
+/worlds/dark_souls_3/ @Marechal-L @nex3
 
 # Donkey Kong Country 3
 /worlds/dkc3/ @PoryGone
@@ -78,6 +78,9 @@
 # Kirby's Dream Land 3
 /worlds/kdl3/ @Silvris
 
+# Kingdom Hearts
+/worlds/kh1/ @gaithern
+
 # Kingdom Hearts 2
 /worlds/kh2/ @JaredWeakStrike
 
@@ -103,6 +106,9 @@
 # Minecraft
 /worlds/minecraft/ @KonoTyran @espeon65536
 
+# Mega Man 2
+/worlds/mm2/ @Silvris
+
 # MegaMan Battle Network 3
 /worlds/mmbn3/ @digiholic
 
@@ -112,9 +118,6 @@
 # Noita
 /worlds/noita/ @ScipioWright @heinermann
 
-# Ocarina of Time
-/worlds/oot/ @espeon65536
-
 # Old School Runescape
 /worlds/osrs @digiholic
 
@@ -196,6 +199,9 @@
 # The Witness
 /worlds/witness/ @NewSoupVi @blastron
 
+# Yacht Dice
+/worlds/yachtdice/ @spinerak
+
 # Yoshi's Island
 /worlds/yoshisisland/ @PinkSwitch
 
@@ -221,6 +227,9 @@
 # Links Awakening DX
 # /worlds/ladx/
 
+# Ocarina of Time
+# /worlds/oot/
+
 ## Disabled Unmaintained Worlds
 
 # The following worlds in this repo are currently unmaintained and disabled as they do not work in core. If you are

docs/network protocol.md

@@ -702,14 +702,18 @@ GameData is a **dict** but contains these keys and values. It's broken out into
 | checksum            | str            | A checksum hash of this game's data.                                                                                          |
 
 ### Tags
-Tags are represented as a list of strings, the common Client tags follow:
+Tags are represented as a list of strings, the common client tags follow:
 
-| Name       | Notes                                                                                                                                                                                                              |
-|------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| AP         | Signifies that this client is a reference client, its usefulness is mostly in debugging to compare client behaviours more easily.                                                                                  |
-| DeathLink  | Client participates in the DeathLink mechanic, therefore will send and receive DeathLink bounce packets                                                                                                            |
-| Tracker    | Tells the server that this client will not send locations and is actually a Tracker. When specified and used with empty or null `game` in [Connect](#connect), game and game's version validation will be skipped. |
-| TextOnly   | Tells the server that this client will not send locations and is intended for chat. When specified and used with empty or null `game` in [Connect](#connect), game and game's version validation will be skipped.  |
+| Name      | Notes                                                                                                                                |
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------|
+| AP        | Signifies that this client is a reference client, its usefulness is mostly in debugging to compare client behaviours more easily.    |
+| DeathLink | Client participates in the DeathLink mechanic, therefore will send and receive DeathLink bounce packets.                             |
+| HintGame  | Indicates the client is a hint game, made to send hints instead of locations. Special join/leave message,¹ `game` is optional.²      |
+| Tracker   | Indicates the client is a tracker, made to track instead of sending locations. Special join/leave message,¹ `game` is optional.²     |
+| TextOnly  | Indicates the client is a basic client, made to chat instead of sending locations. Special join/leave message,¹ `game` is optional.² |
+
+¹: When connecting or disconnecting, the chat message shows e.g. "tracking".\
+²: Allows `game` to be empty or null in [Connect](#connect). Game and version validation will then be skipped.
 
 ### DeathLink
 A special kind of Bounce packet that can be supported by any AP game. It targets the tag "DeathLink" and carries the following data:

docs/options api.md

@@ -24,7 +24,7 @@ display as `Value1` on the webhost.
 files, and both will resolve as `value1`. This should be used when changing options around, i.e. changing a Toggle to a
 Choice, and defining `alias_true = option_full`.
 - All options with a fixed set of possible values (i.e. those which inherit from `Toggle`, `(Text)Choice` or
-`(Named/Special)Range`) support `random` as a generic option. `random` chooses from any of the available values for that
+`(Named)Range`) support `random` as a generic option. `random` chooses from any of the available values for that
 option, and is reserved by AP. You can set this as your default value, but you cannot define your own `option_random`.
 However, you can override `from_text` and handle `text == "random"` to customize its behavior or
 implement it for additional option types.
@@ -129,6 +129,23 @@ class Difficulty(Choice):
     default = 1
 ```
 
+### Option Visibility
+Every option has a Visibility IntFlag, defaulting to `all` (`0b1111`). This lets you choose where the option will be
+displayed. This only impacts where options are displayed, not how they can be used. Hidden options are still valid
+options in a yaml. The flags are as follows:
+* `none` (`0b0000`): This option is not shown anywhere
+* `template` (`0b0001`): This option shows up in template yamls
+* `simple_ui` (`0b0010`): This option shows up on the options page
+* `complex_ui` (`0b0100`): This option shows up on the advanced/weighted options page
+* `spoiler` (`0b1000`): This option shows up in spoiler logs
+
+```python
+from Options import Choice, Visibility
+
+class HiddenChoiceOption(Choice):
+    visibility = Visibility.none
+```
+
 ### Option Groups
 Options may be categorized into groups for display on the WebHost. Option groups are displayed in the order specified
 by your world on the player-options and weighted-options pages. In the generated template files, there will be a comment

docs/running from source.md

@@ -8,7 +8,7 @@ use that version. These steps are for developers or platforms without compiled r
 
 What you'll need:
  * [Python 3.8.7 or newer](https://www.python.org/downloads/), not the Windows Store version
-   * **Python 3.12 is currently unsupported**
+   * Python 3.12.x is currently the newest supported version
  * pip: included in downloads from python.org, separate in many Linux distributions
  * Matching C compiler
    * possibly optional, read operating system specific sections
@@ -31,14 +31,14 @@ After this, you should be able to run the programs.
 
 Recommended steps
  * Download and install a "Windows installer (64-bit)" from the [Python download page](https://www.python.org/downloads)
-   * **Python 3.12 is currently unsupported**
+   * [read above](#General) which versions are supported
 
  * **Optional**: Download and install Visual Studio Build Tools from
    [Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/).
    * Refer to [Windows Compilers on the python wiki](https://wiki.python.org/moin/WindowsCompilers) for details. 
      Generally, selecting the box for "Desktop Development with C++" will provide what you need.
    * Build tools are not required if all modules are installed pre-compiled. Pre-compiled modules are pinned on
-     [Discord in #archipelago-dev](https://discord.com/channels/731205301247803413/731214280439103580/905154456377757808)
+     [Discord in #ap-core-dev](https://discord.com/channels/731205301247803413/731214280439103580/905154456377757808)
 
  * It is recommended to use [PyCharm IDE](https://www.jetbrains.com/pycharm/)
  * Run Generate.py which will prompt installation of missing modules, press enter to confirm

docs/world api.md

@@ -303,6 +303,31 @@ generation (entrance randomization).
 An access rule is a function that returns `True` or `False` for a `Location` or `Entrance` based on the current `state`
 (items that have been collected).
 
+The two possible ways to make a [CollectionRule](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/generic/Rules.py#L10) are:
+- `def rule(state: CollectionState) -> bool:`
+- `lambda state: ... boolean expression ...`
+
+An access rule can be assigned through `set_rule(location, rule)`.
+
+Access rules usually check for one of two things.
+- Items that have been collected (e.g. `state.has("Sword", player)`)
+- Locations, Regions or Entrances that have been reached (e.g. `state.can_reach_region("Boss Room")`)
+
+Keep in mind that entrances and locations implicitly check for the accessibility of their parent region, so you do not need to check explicitly for it.
+
+#### An important note on Entrance access rules:
+When using `state.can_reach` within an entrance access condition, you must also use `multiworld.register_indirect_condition`.
+
+For efficiency reasons, every time reachable regions are searched, every entrance is only checked once in a somewhat non-deterministic order.
+This is fine when checking for items using `state.has`, because items do not change during a region sweep.
+However, `state.can_reach` checks for the very same thing we are updating: Regions.
+This can lead to non-deterministic behavior and, in the worst case, even generation failures.
+Even doing `state.can_reach_location` or `state.can_reach_entrance` is problematic, as these functions call `state.can_reach_region` on the respective parent region.
+
+**Therefore, it is considered unsafe to perform `state.can_reach` from within an access condition for an entrance**, unless you are checking for something that sits in the source region of the entrance.
+You can use `multiworld.register_indirect_condition(region, entrance)` to explicitly tell the generator that, when a given region becomes accessible, it is necessary to re-check a specific entrance.
+You **must** use `multiworld.register_indirect_condition` if you perform this kind of `can_reach` from an entrance access rule, unless you have a **very** good technical understanding of the relevant code and can reason why it will never lead to problems in your case.
+
 ### Item Rules
 
 An item rule is a function that returns `True` or `False` for a `Location` based on a single item. It can be used to
@@ -630,7 +655,7 @@ def set_rules(self) -> None:
 
 Custom methods can be defined for your logic rules. The access rule that ultimately gets assigned to the Location or
 Entrance should be
-a [`CollectionRule`](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/generic/Rules.py#L9).
+a [`CollectionRule`](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/generic/Rules.py#L10).
 Typically, this is done by defining a lambda expression on demand at the relevant bit, typically calling other
 functions, but this can also be achieved by defining a method with the appropriate format and assigning it directly.
 For an example, see [The Messenger](/worlds/messenger/rules.py).
@@ -671,9 +696,92 @@ When importing a file that defines a class that inherits from `worlds.AutoWorld.
 is automatically extended by the mixin's members. These members should be prefixed with the name of the implementing
 world since the namespace is shared with all other logic mixins.
 
-Some uses could be to add additional variables to the state object, or to have a custom state machine that gets modified
-with the state.
-Please do this with caution and only when necessary.
+LogicMixin is handy when your logic is more complex than one-to-one location-item relationships.  
+A game in which "The red key opens the red door" can just express this relationship through a one-line access rule.  
+But now, consider a game with a heavy focus on combat, where the main logical consideration is which enemies you can
+defeat with your current items.  
+There could be dozens of weapons, armor pieces, or consumables that each improve your ability to defeat
+specific enemies to varying degrees. It would be useful to be able to keep track of "defeatable enemies" as a state variable,
+and have this variable be recalculated as necessary based on newly collected/removed items.
+This is the capability of LogicMixin: Adding custom variables to state that get recalculated as necessary.
+
+In general, a LogicMixin class should have at least one mutable variable that is tracking some custom state per player,
+as well as `init_mixin` and `copy_mixin` functions so that this variable gets initialized and copied correctly when
+`CollectionState()` and `CollectionState.copy()` are called respectively.
+
+```python
+from BaseClasses import CollectionState, MultiWorld
+from worlds.AutoWorld import LogicMixin
+
+class MyGameState(LogicMixin):
+    mygame_defeatable_enemies: Dict[int, Set[str]]  # per player
+
+    def init_mixin(self, multiworld: MultiWorld) -> None:
+        # Initialize per player with the corresponding "nothing" value, such as 0 or an empty set.
+        # You can also use something like Collections.defaultdict
+        self.mygame_defeatable_enemies = {
+            player: set() for player in multiworld.get_game_players("My Game")
+        }
+
+    def copy_mixin(self, new_state: CollectionState) -> CollectionState:
+        # Be careful to make a "deep enough" copy here!
+        new_state.mygame_defeatable_enemies = {
+            player: enemies.copy() for player, enemies in self.mygame_defeatable_enemies.items()
+        }
+```
+
+After doing this, you can now access `state.mygame_defeatable_enemies[player]` from your access rules.
+
+Usually, doing this coincides with an override of `World.collect` and `World.remove`, where the custom state variable 
+gets recalculated when a relevant item is collected or removed.
+
+```python
+# __init__.py
+
+def collect(self, state: CollectionState, item: Item) -> bool:
+    change = super().collect(state, item)
+    if change and item in COMBAT_ITEMS:
+        state.mygame_defeatable_enemies[self.player] |= get_newly_unlocked_enemies(state)
+    return change
+
+def remove(self, state: CollectionState, item: Item) -> bool:
+    change = super().remove(state, item)
+    if change and item in COMBAT_ITEMS:
+        state.mygame_defeatable_enemies[self.player] -= get_newly_locked_enemies(state)
+    return change
+```
+
+Using LogicMixin can greatly slow down your code if you don't use it intelligently. This is because `collect`
+and `remove` are called very frequently during fill. If your `collect` & `remove` cause a heavy calculation
+every time, your code might end up being *slower* than just doing calculations in your access rules.
+
+One way to optimise recalculations is to make use of the fact that `collect` should only unlock things,
+and `remove` should only lock things.  
+In our example, we have two different functions: `get_newly_unlocked_enemies` and `get_newly_locked_enemies`.  
+`get_newly_unlocked_enemies` should only consider enemies that are *not already in the set*
+and check whether they were **unlocked**.  
+`get_newly_locked_enemies` should only consider enemies that are *already in the set*
+and check whether they **became locked**.
+
+Another impactful way to optimise LogicMixin is to use caching.  
+Your custom state variables don't actually need to be recalculated on every `collect` / `remove`, because there are
+often multiple calls to `collect` / `remove` between access rule calls. Thus, it would be much more efficient to hold
+off on recaculating until the an actual access rule call happens.  
+A common way to realize this is to define a `mygame_state_is_stale` variable that is set to True in `collect`, `remove`,
+and `init_mixin`. The calls to the actual recalculating functions are then moved to the start of the relevant
+access rules like this:
+
+```python
+def can_defeat_enemy(state: CollectionState, player: int, enemy: str) -> bool:
+    if state.mygame_state_is_stale[player]:
+        state.mygame_defeatable_enemies[player] = recalculate_defeatable_enemies(state)
+        state.mygame_state_is_stale[player] = False
+
+    return enemy in state.mygame_defeatable_enemies[player]
+```
+
+Only use LogicMixin if necessary. There are often other ways to achieve what it does, like making clever use of
+`state.prog_items`, using event items, pseudo-regions, etc.
 
 #### pre_fill
 

docs/world maintainer.md

@@ -26,8 +26,17 @@ Unless these are shared between multiple people, we expect the following from ea
 ### Adding a World
 
 When we merge your world into the core Archipelago repository, you automatically become world maintainer unless you
-nominate someone else (i.e. there are multiple devs). You can define who is allowed to approve changes to your world
-in the [CODEOWNERS](/docs/CODEOWNERS) document.
+nominate someone else (i.e. there are multiple devs).
+
+### Being added as a maintainer to an existing implementation
+
+At any point, a world maintainer can approve the addition of another maintainer to their world.  
+In order to do this, either an existing maintainer or the new maintainer must open a PR updating the
+[CODEOWNERS](/docs/CODEOWNERS) file.  
+This change must be approved by all existing maintainers of the affected world, the new maintainer candidate, and
+one core maintainer.  
+To help the core team review the change, information about the new maintainer and their contributions should be
+included in the PR description.
 
 ### Getting Voted
 
@@ -35,7 +44,7 @@ When a world is unmaintained, the [core maintainers](https://github.com/orgs/Arc
 can vote for a new maintainer if there is a candidate.
 For a vote to pass, the majority of participating core maintainers must vote in the affirmative.
 The time limit is 1 week, but can end early if the majority is reached earlier.
-Voting shall be conducted on Discord in #archipelago-dev.
+Voting shall be conducted on Discord in #ap-core-dev.
 
 ## Dropping out
 
@@ -51,7 +60,7 @@ for example when they become unreachable.
 For a vote to pass, the majority of participating core maintainers must vote in the affirmative.
 The time limit is 2 weeks, but can end early if the majority is reached earlier AND the world maintainer was pinged and
 made their case or was pinged and has been unreachable for more than 2 weeks already.
-Voting shall be conducted on Discord in #archipelago-dev. Commits that are a direct result of the voting shall include
+Voting shall be conducted on Discord in #ap-core-dev. Commits that are a direct result of the voting shall include
 date, voting members and final result in the commit message.
 
 ## Handling of Unmaintained Worlds

inno_setup.iss

@@ -186,6 +186,11 @@ Root: HKCR; Subkey: "{#MyAppName}cv64patch";                     ValueData: "Arc
 Root: HKCR; Subkey: "{#MyAppName}cv64patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                                          ValueType: string; ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}cv64patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                                 ValueType: string; ValueName: "";
 
+Root: HKCR; Subkey: ".apmm2";                                   ValueData: "{#MyAppName}mm2patch";                               Flags: uninsdeletevalue; ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch";                     ValueData: "Archipelago Mega Man 2 Patch";                    Flags: uninsdeletekey;   ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                                          ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                                 ValueType: string; ValueName: "";
+
 Root: HKCR; Subkey: ".apladx";                                   ValueData: "{#MyAppName}ladxpatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ladxpatch";                     ValueData: "Archipelago Links Awakening DX Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ladxpatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLinksAwakeningClient.exe,0";                           ValueType: string;  ValueName: "";
@@ -223,8 +228,8 @@ Root: HKCR; Subkey: "{#MyAppName}worlddata\shell\open\command"; ValueData: """{a
 
 Root: HKCR; Subkey: "archipelago"; ValueType: "string"; ValueData: "Archipegalo Protocol"; Flags: uninsdeletekey;
 Root: HKCR; Subkey: "archipelago"; ValueType: "string"; ValueName: "URL Protocol"; ValueData: "";
-Root: HKCR; Subkey: "archipelago\DefaultIcon"; ValueType: "string"; ValueData: "{app}\ArchipelagoTextClient.exe,0";
-Root: HKCR; Subkey: "archipelago\shell\open\command"; ValueType: "string"; ValueData: """{app}\ArchipelagoTextClient.exe"" ""%1""";
+Root: HKCR; Subkey: "archipelago\DefaultIcon"; ValueType: "string"; ValueData: "{app}\ArchipelagoLauncher.exe,0";
+Root: HKCR; Subkey: "archipelago\shell\open\command"; ValueType: "string"; ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";
 
 [Code]
 // See: https://stackoverflow.com/a/51614652/2287576

kvui.py

@@ -5,6 +5,8 @@ import typing
 import re
 from collections import deque
 
+assert "kivy" not in sys.modules, "kvui should be imported before kivy for frozen compatibility"
+
 if sys.platform == "win32":
     import ctypes
 

requirements.txt

@@ -1,14 +1,14 @@
 colorama>=0.4.6
-websockets>=12.0
-PyYAML>=6.0.1
-jellyfish>=1.0.3
+websockets>=13.0.1
+PyYAML>=6.0.2
+jellyfish>=1.1.0
 jinja2>=3.1.4
 schema>=0.7.7
 kivy>=2.3.0
 bsdiff4>=1.2.4
 platformdirs>=4.2.2
-certifi>=2024.6.2
-cython>=3.0.10
+certifi>=2024.8.30
+cython>=3.0.11
 cymem>=2.0.8
-orjson>=3.10.3
-typing_extensions>=4.12.1
+orjson>=3.10.7
+typing_extensions>=4.12.2

test/bases.py

@@ -23,8 +23,8 @@ class TestBase(unittest.TestCase):
         state = CollectionState(self.multiworld)
         for item in items:
             item.classification = ItemClassification.progression
-            state.collect(item, event=True)
-        state.sweep_for_events()
+            state.collect(item, prevent_sweep=True)
+        state.sweep_for_advancements()
         state.update_reachable_regions(1)
         self._state_cache[self.multiworld, tuple(items)] = state
         return state
@@ -221,8 +221,8 @@ class WorldTestBase(unittest.TestCase):
         if isinstance(items, Item):
             items = (items,)
         for item in items:
-            if item.location and item.advancement and item.location in self.multiworld.state.events:
-                self.multiworld.state.events.remove(item.location)
+            if item.location and item.advancement and item.location in self.multiworld.state.advancements:
+                self.multiworld.state.advancements.remove(item.location)
             self.multiworld.state.remove(item)
 
     def can_reach_location(self, location: str) -> bool:
@@ -293,13 +293,11 @@ class WorldTestBase(unittest.TestCase):
         if not (self.run_default_tests and self.constructed):
             return
         with self.subTest("Game", game=self.game, seed=self.multiworld.seed):
-            excluded = self.multiworld.worlds[self.player].options.exclude_locations.value
             state = self.multiworld.get_all_state(False)
             for location in self.multiworld.get_locations():
-                if location.name not in excluded:
-                    with self.subTest("Location should be reached", location=location.name):
-                        reachable = location.can_reach(state)
-                        self.assertTrue(reachable, f"{location.name} unreachable")
+                with self.subTest("Location should be reached", location=location.name):
+                    reachable = location.can_reach(state)
+                    self.assertTrue(reachable, f"{location.name} unreachable")
             with self.subTest("Beatable"):
                 self.multiworld.state = state
                 self.assertBeatable(True)

test/general/test_fill.py

@@ -192,7 +192,7 @@ class TestFillRestrictive(unittest.TestCase):
         location_pool = player1.locations[1:] + player2.locations
         item_pool = player1.prog_items[:-1] + player2.prog_items
         fill_restrictive(multiworld, multiworld.state, location_pool, item_pool)
-        multiworld.state.sweep_for_events()  # collect everything
+        multiworld.state.sweep_for_advancements()  # collect everything
 
         # all of player2's locations and items should be accessible (not all of player1's)
         for item in player2.prog_items:
@@ -443,8 +443,8 @@ class TestFillRestrictive(unittest.TestCase):
         item = player1.prog_items[0]
         item.code = None
         location.place_locked_item(item)
-        multiworld.state.sweep_for_events()
-        multiworld.state.sweep_for_events()
+        multiworld.state.sweep_for_advancements()
+        multiworld.state.sweep_for_advancements()
         self.assertTrue(multiworld.state.prog_items[item.player][item.name], "Sweep did not collect - Test flawed")
         self.assertEqual(multiworld.state.prog_items[item.player][item.name], 1, "Sweep collected multiple times")
 

test/general/test_reachability.py

@@ -14,6 +14,18 @@ class TestBase(unittest.TestCase):
             "Desert Northern Cliffs",  # on top of mountain, only reachable via OWG
             "Dark Death Mountain Bunny Descent Area"  # OWG Mountain descent
         },
+        # These Blasphemous regions are not reachable with default options
+        "Blasphemous": {
+            "D01Z04S13[SE]", # difficulty must be hard
+            "D01Z05S25[E]", # difficulty must be hard
+            "D02Z02S05[W]", # difficulty must be hard and purified_hand must be true
+            "D04Z01S06[E]", # purified_hand must be true
+            "D04Z02S02[NE]", # difficulty must be hard and purified_hand must be true
+            "D05Z01S11[SW]", # difficulty must be hard
+            "D06Z01S08[N]", # difficulty must be hard and purified_hand must be true
+            "D20Z02S11[NW]", # difficulty must be hard
+            "D20Z02S11[E]", # difficulty must be hard
+        },
         "Ocarina of Time": {
             "Prelude of Light Warp",  # Prelude is not progression by default
             "Serenade of Water Warp",  # Serenade is not progression by default
@@ -37,12 +49,10 @@ class TestBase(unittest.TestCase):
             unreachable_regions = self.default_settings_unreachable_regions.get(game_name, set())
             with self.subTest("Game", game=game_name):
                 multiworld = setup_solo_multiworld(world_type)
-                excluded = multiworld.worlds[1].options.exclude_locations.value
                 state = multiworld.get_all_state(False)
                 for location in multiworld.get_locations():
-                    if location.name not in excluded:
-                        with self.subTest("Location should be reached", location=location.name):
-                            self.assertTrue(location.can_reach(state), f"{location.name} unreachable")
+                    with self.subTest("Location should be reached", location=location.name):
+                        self.assertTrue(location.can_reach(state), f"{location.name} unreachable")
 
                 for region in multiworld.get_regions():
                     if region.name in unreachable_regions:

test/multiworld/test_multiworlds.py

@@ -55,7 +55,7 @@ class TestAllGamesMultiworld(MultiworldTestBase):
         all_worlds = list(AutoWorldRegister.world_types.values())
         self.multiworld = setup_multiworld(all_worlds, ())
         for world in self.multiworld.worlds.values():
-            world.options.accessibility.value = Accessibility.option_locations
+            world.options.accessibility.value = Accessibility.option_full
         self.assertSteps(gen_steps)
         with self.subTest("filling multiworld", seed=self.multiworld.seed):
             distribute_items_restrictive(self.multiworld)
@@ -66,8 +66,8 @@ class TestAllGamesMultiworld(MultiworldTestBase):
 class TestTwoPlayerMulti(MultiworldTestBase):
     def test_two_player_single_game_fills(self) -> None:
         """Tests that a multiworld of two players for each registered game world can generate."""
-        for world in AutoWorldRegister.world_types.values():
-            self.multiworld = setup_multiworld([world, world], ())
+        for world_type in AutoWorldRegister.world_types.values():
+            self.multiworld = setup_multiworld([world_type, world_type], ())
             for world in self.multiworld.worlds.values():
                 world.options.accessibility.value = Accessibility.option_full
             self.assertSteps(gen_steps)

test/netutils/test_location_store.py

@@ -130,9 +130,9 @@ class Base:
 
         def test_get_remaining(self) -> None:
             self.assertEqual(self.store.get_remaining(full_state, 0, 1), [])
-            self.assertEqual(self.store.get_remaining(one_state, 0, 1), [13, 21])
-            self.assertEqual(self.store.get_remaining(empty_state, 0, 1), [13, 21, 22])
-            self.assertEqual(self.store.get_remaining(empty_state, 0, 3), [99])
+            self.assertEqual(self.store.get_remaining(one_state, 0, 1), [(1, 13), (2, 21)])
+            self.assertEqual(self.store.get_remaining(empty_state, 0, 1), [(1, 13), (2, 21), (2, 22)])
+            self.assertEqual(self.store.get_remaining(empty_state, 0, 3), [(4, 99)])
 
         def test_location_set_intersection(self) -> None:
             locations = {10, 11, 12}

test/webhost/test_host_room.py

@@ -131,7 +131,8 @@ class TestHostFakeRoom(TestBase):
             f.write(text)
 
         with self.app.app_context(), self.app.test_request_context():
-            response = self.client.get(url_for("host_room", room=self.room_id))
+            response = self.client.get(url_for("host_room", room=self.room_id),
+                                       headers={"User-Agent": "Mozilla/5.0"})
             response_text = response.get_data(True)
             self.assertEqual(response.status_code, 200)
             self.assertIn("href=\"/seed/", response_text)

worlds/AutoWorld.py

@@ -292,6 +292,14 @@ class World(metaclass=AutoWorldRegister):
     web: ClassVar[WebWorld] = WebWorld()
     """see WebWorld for options"""
 
+    origin_region_name: str = "Menu"
+    """Name of the Region from which accessibility is tested."""
+
+    explicit_indirect_conditions: bool = True
+    """If True, the world implementation is supposed to use MultiWorld.register_indirect_condition() correctly.
+    If False, everything is rechecked at every step, which is slower computationally, 
+    but may be desirable in complex/dynamic worlds."""
+
     multiworld: "MultiWorld"
     """autoset on creation. The MultiWorld object for the currently generating multiworld."""
     player: int

worlds/LauncherComponents.py

@@ -26,10 +26,13 @@ class Component:
     cli: bool
     func: Optional[Callable]
     file_identifier: Optional[Callable[[str], bool]]
+    game_name: Optional[str]
+    supports_uri: Optional[bool]
 
     def __init__(self, display_name: str, script_name: Optional[str] = None, frozen_name: Optional[str] = None,
                  cli: bool = False, icon: str = 'icon', component_type: Optional[Type] = None,
-                 func: Optional[Callable] = None, file_identifier: Optional[Callable[[str], bool]] = None):
+                 func: Optional[Callable] = None, file_identifier: Optional[Callable[[str], bool]] = None,
+                 game_name: Optional[str] = None, supports_uri: Optional[bool] = False):
         self.display_name = display_name
         self.script_name = script_name
         self.frozen_name = frozen_name or f'Archipelago{script_name}' if script_name else None
@@ -45,6 +48,8 @@ class Component:
             Type.ADJUSTER if "Adjuster" in display_name else Type.MISC)
         self.func = func
         self.file_identifier = file_identifier
+        self.game_name = game_name
+        self.supports_uri = supports_uri
 
     def handles_file(self, path: str):
         return self.file_identifier(path) if self.file_identifier else False
@@ -56,10 +61,10 @@ class Component:
 processes = weakref.WeakSet()
 
 
-def launch_subprocess(func: Callable, name: str = None):
+def launch_subprocess(func: Callable, name: str = None, args: Tuple[str, ...] = ()) -> None:
     global processes
     import multiprocessing
-    process = multiprocessing.Process(target=func, name=name)
+    process = multiprocessing.Process(target=func, name=name, args=args)
     process.start()
     processes.add(process)
 
@@ -78,9 +83,9 @@ class SuffixIdentifier:
         return False
 
 
-def launch_textclient():
+def launch_textclient(*args):
     import CommonClient
-    launch_subprocess(CommonClient.run_as_textclient, name="TextClient")
+    launch_subprocess(CommonClient.run_as_textclient, name="TextClient", args=args)
 
 
 def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, pathlib.Path]]:
@@ -132,7 +137,8 @@ def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, path
             break
     if found_already_loaded:
         raise Exception(f"Installed APWorld successfully, but '{module_name}' is already loaded,\n"
-                        "so a Launcher restart is required to use the new installation.")
+                        "so a Launcher restart is required to use the new installation.\n"
+                        "If the Launcher is not open, no action needs to be taken.")
     world_source = worlds.WorldSource(str(target), is_zip=True)
     bisect.insort(worlds.world_sources, world_source)
     world_source.load()

worlds/_bizhawk/client.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 
 def launch_client(*args) -> None:
     from .context import launch
-    launch_subprocess(launch, name="BizHawkClient")
+    launch_subprocess(launch, name="BizHawkClient", args=args)
 
 
 component = Component("BizHawk Client", "BizHawkClient", component_type=Type.CLIENT, func=launch_client,

worlds/_bizhawk/context.py

@@ -59,14 +59,10 @@ class BizHawkClientContext(CommonContext):
         self.bizhawk_ctx = BizHawkContext()
         self.watcher_timeout = 0.5
 
-    def run_gui(self):
-        from kvui import GameManager
-
-        class BizHawkManager(GameManager):
-            base_title = "Archipelago BizHawk Client"
-
-        self.ui = BizHawkManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
+    def make_gui(self):
+        ui = super().make_gui()
+        ui.base_title = "Archipelago BizHawk Client"
+        return ui
 
     def on_package(self, cmd, args):
         if cmd == "Connected":
@@ -243,11 +239,11 @@ async def _patch_and_run_game(patch_file: str):
         logger.exception(exc)
 
 
-def launch() -> None:
+def launch(*launch_args) -> None:
     async def main():
         parser = get_base_parser()
         parser.add_argument("patch_file", default="", type=str, nargs="?", help="Path to an Archipelago patch file")
-        args = parser.parse_args()
+        args = parser.parse_args(launch_args)
 
         ctx = BizHawkClientContext(args.connect, args.password)
         ctx.server_task = asyncio.create_task(server_loop(ctx), name="ServerLoop")

worlds/ahit/Regions.py

@@ -968,40 +968,35 @@ def get_act_by_number(world: "HatInTimeWorld", chapter_name: str, num: int) -> R
 def create_thug_shops(world: "HatInTimeWorld"):
     min_items: int = world.options.NyakuzaThugMinShopItems.value
     max_items: int = world.options.NyakuzaThugMaxShopItems.value
-    count = -1
-    step = 0
-    old_name = ""
+
+    thug_location_counts: Dict[str, int] = {}
 
     for key, data in shop_locations.items():
-        if data.nyakuza_thug == "":
+        thug_name = data.nyakuza_thug
+        if thug_name == "":
+            # Different shop type.
             continue
 
-        if old_name != "" and old_name == data.nyakuza_thug:
+        if thug_name not in world.nyakuza_thug_items:
+            shop_item_count = world.random.randint(min_items, max_items)
+            world.nyakuza_thug_items[thug_name] = shop_item_count
+        else:
+            shop_item_count = world.nyakuza_thug_items[thug_name]
+
+        if shop_item_count <= 0:
             continue
 
-        try:
-            if world.nyakuza_thug_items[data.nyakuza_thug] <= 0:
-                continue
-        except KeyError:
-            pass
+        location_count = thug_location_counts.setdefault(thug_name, 0)
+        if location_count >= shop_item_count:
+            # Already created all the locations for this thug.
+            continue
 
-        if count == -1:
-            count = world.random.randint(min_items, max_items)
-            world.nyakuza_thug_items.setdefault(data.nyakuza_thug, count)
-            if count <= 0:
-                continue
-
-        if count >= 1:
-            region = world.multiworld.get_region(data.region, world.player)
-            loc = HatInTimeLocation(world.player, key, data.id, region)
-            region.locations.append(loc)
-            world.shop_locs.append(loc.name)
-
-            step += 1
-            if step >= count:
-                old_name = data.nyakuza_thug
-                step = 0
-                count = -1
+        # Create the shop location.
+        region = world.multiworld.get_region(data.region, world.player)
+        loc = HatInTimeLocation(world.player, key, data.id, region)
+        region.locations.append(loc)
+        world.shop_locs.append(loc.name)
+        thug_location_counts[thug_name] = location_count + 1
 
 
 def create_events(world: "HatInTimeWorld") -> int:

worlds/ahit/Rules.py

@@ -381,8 +381,8 @@ def set_moderate_rules(world: "HatInTimeWorld"):
              lambda state: can_use_hat(state, world, HatType.ICE), "or")
 
     # Moderate: Clock Tower Chest + Ruined Tower with nothing
-    add_rule(world.multiworld.get_location("Mafia Town - Clock Tower Chest", world.player), lambda state: True)
-    add_rule(world.multiworld.get_location("Mafia Town - Top of Ruined Tower", world.player), lambda state: True)
+    set_rule(world.multiworld.get_location("Mafia Town - Clock Tower Chest", world.player), lambda state: True)
+    set_rule(world.multiworld.get_location("Mafia Town - Top of Ruined Tower", world.player), lambda state: True)
 
     # Moderate: enter and clear The Subcon Well without Hookshot and without hitting the bell
     for loc in world.multiworld.get_region("The Subcon Well", world.player).locations:
@@ -432,8 +432,8 @@ def set_moderate_rules(world: "HatInTimeWorld"):
 
     if world.is_dlc1():
         # Moderate: clear Rock the Boat without Ice Hat
-        add_rule(world.multiworld.get_location("Rock the Boat - Post Captain Rescue", world.player), lambda state: True)
-        add_rule(world.multiworld.get_location("Act Completion (Rock the Boat)", world.player), lambda state: True)
+        set_rule(world.multiworld.get_location("Rock the Boat - Post Captain Rescue", world.player), lambda state: True)
+        set_rule(world.multiworld.get_location("Act Completion (Rock the Boat)", world.player), lambda state: True)
 
         # Moderate: clear Deep Sea without Ice Hat
         set_rule(world.multiworld.get_location("Act Completion (Time Rift - Deep Sea)", world.player),
@@ -855,6 +855,9 @@ def set_rift_rules(world: "HatInTimeWorld", regions: Dict[str, Region]):
 
     for entrance in regions["Time Rift - Alpine Skyline"].entrances:
         add_rule(entrance, lambda state: has_relic_combo(state, world, "Crayon"))
+        if entrance.parent_region.name == "Alpine Free Roam":
+            add_rule(entrance,
+                     lambda state: can_use_hookshot(state, world) and can_hit(state, world, umbrella_only=True))
 
     if world.is_dlc1():
         for entrance in regions["Time Rift - Balcony"].entrances:
@@ -933,6 +936,9 @@ def set_default_rift_rules(world: "HatInTimeWorld"):
 
     for entrance in world.multiworld.get_region("Time Rift - Alpine Skyline", world.player).entrances:
         add_rule(entrance, lambda state: has_relic_combo(state, world, "Crayon"))
+        if entrance.parent_region.name == "Alpine Free Roam":
+            add_rule(entrance,
+                     lambda state: can_use_hookshot(state, world) and can_hit(state, world, umbrella_only=True))
 
     if world.is_dlc1():
         for entrance in world.multiworld.get_region("Time Rift - Balcony", world.player).entrances:

worlds/alttp/Dungeons.py

@@ -248,7 +248,7 @@ def fill_dungeons_restrictive(multiworld: MultiWorld):
                     pass
             for item in pre_fill_items:
                 multiworld.worlds[item.player].collect(all_state_base, item)
-            all_state_base.sweep_for_events()
+            all_state_base.sweep_for_advancements()
 
             # Remove completion condition so that minimal-accessibility worlds place keys properly
             for player in {item.player for item in in_dungeon_items}:
@@ -262,8 +262,8 @@ def fill_dungeons_restrictive(multiworld: MultiWorld):
                         all_state_base.remove(item_factory(key_data[3], multiworld.worlds[player]))
                         loc = multiworld.get_location(key_loc, player)
 
-                        if loc in all_state_base.events:
-                            all_state_base.events.remove(loc)
+                        if loc in all_state_base.advancements:
+                            all_state_base.advancements.remove(loc)
             fill_restrictive(multiworld, all_state_base, locations, in_dungeon_items, lock=True, allow_excluded=True,
                              name="LttP Dungeon Items")
 

worlds/alttp/ItemPool.py

@@ -682,7 +682,7 @@ def get_pool_core(world, player: int):
     if 'triforce_hunt' in goal:
 
         if world.triforce_pieces_mode[player].value == TriforcePiecesMode.option_extra:
-            treasure_hunt_total = (world.triforce_pieces_available[player].value
+            treasure_hunt_total = (world.triforce_pieces_required[player].value
                                    + world.triforce_pieces_extra[player].value)
         elif world.triforce_pieces_mode[player].value == TriforcePiecesMode.option_percentage:
             percentage = float(world.triforce_pieces_percentage[player].value) / 100

worlds/alttp/Options.py

@@ -728,7 +728,7 @@ class ALttPPlandoConnections(PlandoConnections):
     entrances = set([connection[0] for connection in (
         *default_connections, *default_dungeon_connections, *inverted_default_connections,
         *inverted_default_dungeon_connections)])
-    exits = set([connection[1] for connection in (
+    exits = set([connection[0] for connection in (
         *default_connections, *default_dungeon_connections, *inverted_default_connections,
         *inverted_default_dungeon_connections)])
 

worlds/alttp/Rules.py

@@ -412,7 +412,7 @@ def global_rules(multiworld: MultiWorld, player: int):
              lambda state: ((state._lttp_has_key('Small Key (Thieves Town)', player, 3)) or (location_item_name(state, 'Thieves\' Town - Big Chest', player) == ("Small Key (Thieves Town)", player)) and state._lttp_has_key('Small Key (Thieves Town)', player, 2)) and state.has('Hammer', player))
     set_rule(multiworld.get_location('Thieves\' Town - Blind\'s Cell', player),
              lambda state: state._lttp_has_key('Small Key (Thieves Town)', player))
-    if multiworld.accessibility[player] != 'locations' and not multiworld.key_drop_shuffle[player]:
+    if multiworld.accessibility[player] != 'full' and not multiworld.key_drop_shuffle[player]:
         set_always_allow(multiworld.get_location('Thieves\' Town - Big Chest', player), lambda state, item: item.name == 'Small Key (Thieves Town)' and item.player == player)
     set_rule(multiworld.get_location('Thieves\' Town - Attic', player), lambda state: state._lttp_has_key('Small Key (Thieves Town)', player, 3))
     set_rule(multiworld.get_location('Thieves\' Town - Spike Switch Pot Key', player),
@@ -547,7 +547,7 @@ def global_rules(multiworld: MultiWorld, player: int):
                 location_item_name(state, 'Ganons Tower - Map Chest', player) in [('Big Key (Ganons Tower)', player)] and state._lttp_has_key('Small Key (Ganons Tower)', player, 6)))
 
     # this seemed to be causing generation failure, disable for now
-    # if world.accessibility[player] != 'locations':
+    # if world.accessibility[player] != 'full':
     #     set_always_allow(world.get_location('Ganons Tower - Map Chest', player), lambda state, item: item.name == 'Small Key (Ganons Tower)' and item.player == player and state._lttp_has_key('Small Key (Ganons Tower)', player, 7) and state.can_reach('Ganons Tower (Hookshot Room)', 'region', player))
 
     # It is possible to need more than 6 keys to get through this entrance if you spend keys elsewhere. We reflect this in the chest requirements.

worlds/alttp/__init__.py

@@ -356,6 +356,8 @@ class ALTTPWorld(World):
                 self.dungeon_local_item_names |= self.item_name_groups[option.item_name_group]
                 if option == "original_dungeon":
                     self.dungeon_specific_item_names |= self.item_name_groups[option.item_name_group]
+                else:
+                    self.options.local_items.value |= self.dungeon_local_item_names
 
         self.difficulty_requirements = difficulties[multiworld.item_pool[player].current_key]
 

worlds/alttp/docs/plando_en.md

@@ -2,8 +2,8 @@
 
 ## Configuration
 
-1. Plando features have to be enabled first, before they can be used (opt-in).
-2. To do so, go to your installation directory (Windows default: `C:\ProgramData\Archipelago`), then open the host.yaml
+1. All plando options are enabled by default, except for "items plando" which has to be enabled before it can be used (opt-in).
+2. To enable it, go to your installation directory (Windows default: `C:\ProgramData\Archipelago`), then open the host.yaml
    file with a text editor.
 3. In it, you're looking for the option key `plando_options`. To enable all plando modules you can set the value
    to `bosses, items, texts, connections`
@@ -66,6 +66,7 @@ boss_shuffle:
     - ignored if only one world is generated
     - can be a number, to target that slot in the multiworld
     - can be a name, to target that player's world
+    - can be a list of names, to target those players' worlds
     - can be true, to target any other player's world
     - can be false, to target own world and is the default
     - can be null, to target a random world
@@ -132,17 +133,15 @@ plando_items:
 
 ### Texts
 
-- This module is disabled by default.
 - Has the options `text`, `at`, and `percentage`
+- All of these options support subweights
 - percentage is the percentage chance for this text to be placed, can be omitted entirely for 100%
 - text is the text to be placed.
-    - can be weighted.
     - `\n` is a newline.
     - `@` is the entered player's name.
     - Warning: Text Mapper does not support full unicode.
     - [Alphabet](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L758)
 - at is the location within the game to attach the text to.
-    - can be weighted.
     - [List of targets](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/alttp/Text.py#L1499)
 
 #### Example
@@ -162,7 +161,6 @@ and `uncle_dying_sewer`, then places the text "This is a plando. You've been war
 
 ### Connections
 
-- This module is disabled by default.
 - Has the options `percentage`, `entrance`, `exit` and `direction`.
 - All options support subweights
 - percentage is the percentage chance for this to be connected, can be omitted entirely for 100%

worlds/alttp/test/dungeons/TestDungeon.py

@@ -54,7 +54,7 @@ class TestDungeon(LTTPTestBase):
 
                 for item in items:
                     item.classification = ItemClassification.progression
-                    state.collect(item, event=True)  # event=True prevents running sweep_for_events() and picking up
-                state.sweep_for_events()             # key drop keys repeatedly
+                    state.collect(item, prevent_sweep=True)  # prevent_sweep=True prevents running sweep_for_advancements() and picking up
+                state.sweep_for_advancements()             # key drop keys repeatedly
 
-                self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access, f"failed {self.multiworld.get_location(location, 1)} with: {item_pool}")
+                self.assertEqual(self.multiworld.get_location(location, 1).can_reach(state), access, f"failed {self.multiworld.get_location(location, 1)} with: {item_pool}")

worlds/alttp/test/options/test_dungeon_fill.py

@@ -0,0 +1,60 @@
+from unittest import TestCase
+
+from BaseClasses import MultiWorld
+from test.general import gen_steps, setup_multiworld
+from worlds.AutoWorld import call_all
+from worlds.generic.Rules import locality_rules
+from ... import ALTTPWorld
+from ...Options import DungeonItem
+
+
+class DungeonFillTestBase(TestCase):
+    multiworld: MultiWorld
+    world_1: ALTTPWorld
+    world_2: ALTTPWorld
+    options = (
+        "big_key_shuffle",
+        "small_key_shuffle",
+        "key_drop_shuffle",
+        "compass_shuffle",
+        "map_shuffle",
+    )
+
+    def setUp(self):
+        self.multiworld = setup_multiworld([ALTTPWorld, ALTTPWorld], ())
+        self.world_1 = self.multiworld.worlds[1]
+        self.world_2 = self.multiworld.worlds[2]
+
+    def generate_with_options(self, option_value: int):
+        for option in self.options:
+            getattr(self.world_1.options, option).value = getattr(self.world_2.options, option).value = option_value
+
+        for step in gen_steps:
+            call_all(self.multiworld, step)
+            # this is where locality rules are set in normal generation which we need to verify this test
+            if step == "set_rules":
+                locality_rules(self.multiworld)
+
+    def test_original_dungeons(self):
+        self.generate_with_options(DungeonItem.option_original_dungeon)
+        for location in self.multiworld.get_filled_locations():
+            with (self.subTest(location=location)):
+                if location.parent_region.dungeon is None:
+                    self.assertIs(location.item.dungeon, None)
+                else:
+                    self.assertEqual(location.player, location.item.player,
+                                     f"{location.item} does not belong to {location}'s player")
+                    if location.item.dungeon is None:
+                        continue
+                    self.assertIs(location.item.dungeon, location.parent_region.dungeon,
+                                  f"{location.item} was not placed in its original dungeon.")
+
+    def test_own_dungeons(self):
+        self.generate_with_options(DungeonItem.option_own_dungeons)
+        for location in self.multiworld.get_filled_locations():
+            with self.subTest(location=location):
+                if location.parent_region.dungeon is None:
+                    self.assertIs(location.item.dungeon, None)
+                else:
+                    self.assertEqual(location.player, location.item.player,
+                                     f"{location.item} does not belong to {location}'s player")

worlds/apsudoku/__init__.py

@@ -4,7 +4,7 @@ from BaseClasses import Tutorial
 from ..AutoWorld import WebWorld, World
 
 class AP_SudokuWebWorld(WebWorld):
-    options_page = "games/Sudoku/info/en"
+    options_page = False
     theme = 'partyTime'
 
     setup_en = Tutorial(

worlds/apsudoku/docs/setup_en.md

@@ -1,9 +1,7 @@
 # APSudoku Setup Guide
 
 ## Required Software
-- [APSudoku](https://github.com/EmilyV99/APSudoku)
-- Windows (most tested on Win10)
-- Other platforms might be able to build from source themselves; and may be included in the future.
+- [APSudoku](https://github.com/APSudoku/APSudoku)
 
 ## General Concept
 
@@ -13,25 +11,33 @@ Does not need to be added at the start of a seed, as it does not create any slot
 
 ## Installation Procedures
 
-Go to the latest release from the [APSudoku Releases page](https://github.com/EmilyV99/APSudoku/releases). Download and extract the `APSudoku.zip` file.
+Go to the latest release from the [APSudoku Releases page](https://github.com/APSudoku/APSudoku/releases/latest). Download and extract the appropriate file for your platform.
 
 ## Joining a MultiWorld Game
 
-1. Run APSudoku.exe
-2. Under the 'Archipelago' tab at the top-right:
-	- Enter the server url & port number
+1. Run the APSudoku executable.
+2. Under `Settings` → `Connection` at the top-right:
+	- Enter the server address and port number
 	- Enter the name of the slot you wish to connect to
 	- Enter the room password (optional)
 	- Select DeathLink related settings (optional)
-	- Press connect
-3. Go back to the 'Sudoku' tab
-	- Click the various '?' buttons for information on how to play / control
-4. Choose puzzle difficulty
-5. Try to solve the Sudoku. Click 'Check' when done.
+	- Press `Connect`
+4. Under the `Sudoku` tab
+	- Choose puzzle difficulty
+	- Click `Start` to generate a puzzle
+5. Try to solve the Sudoku. Click `Check` when done
+	- A correct solution rewards you with 1 hint for a location in the world you are connected to
+	- An incorrect solution has no penalty, unless DeathLink is enabled (see below)
 
+Info:
+- You can set various settings under `Settings` → `Sudoku`, and can change the colors used under `Settings` → `Theme`.
+- While connected, you can view the `Console` and `Hints` tabs for standard TextClient-like features
+- You can also use the `Tracking` tab to view either a basic tracker or a valid [GodotAP tracker pack](https://github.com/EmilyV99/GodotAP/blob/main/tracker_packs/GET_PACKS.md)
+- While connected, the number of "unhinted" locations for your slot is shown in the upper-left of the the `Sudoku` tab. (If this reads 0, no further hints can be earned for this slot, as every locations is already hinted)
+- Click the various `?` buttons for information on controls/how to play
 ## DeathLink Support
 
-If 'DeathLink' is enabled when you click 'Connect':
-- Lose a life if you check an incorrect puzzle (not an _incomplete_ puzzle- if any cells are empty, you get off with a warning), or quit a puzzle without solving it (including disconnecting).
-- Life count customizable (default 0). Dying with 0 lives left kills linked players AND resets your puzzle.
+If `DeathLink` is enabled when you click `Connect`:
+- Lose a life if you check an incorrect puzzle (not an _incomplete_ puzzle- if any cells are empty, you get off with a warning), or if you quit a puzzle without solving it (including disconnecting).
+- Your life count is customizable (default 0). Dying with 0 lives left kills linked players AND resets your puzzle.
 - On receiving a DeathLink from another player, your puzzle resets. 

worlds/blasphemous/ExtractorConfig.json

@@ -0,0 +1,19 @@
+{
+	"type": "WorldDefinition",
+	"configuration": "./output/StringWorldDefinition.json",
+	"emptyRegionsToKeep": [
+		"D17Z01S01",
+		"D01Z02S01",
+		"D02Z03S09",
+		"D03Z03S11",
+		"D04Z03S01",
+		"D06Z01S09",
+		"D20Z02S09",
+		"D09Z01S09[Cell24]",
+		"D09Z01S08[Cell7]",
+		"D09Z01S08[Cell18]",
+		"D09BZ01S01[Cell24]",
+		"D09BZ01S01[Cell17]",
+		"D09BZ01S01[Cell19]"
+	]
+}

worlds/blasphemous/Items.py

@@ -637,52 +637,35 @@ item_table: List[ItemDict] = [
         'classification': ItemClassification.filler}
 ]
 
-event_table: Dict[str, str] = {
-    "OpenedDCGateW": "D01Z05S24",
-    "OpenedDCGateE": "D01Z05S12",
-    "OpenedDCLadder": "D01Z05S20",
-    "OpenedWOTWCave": "D02Z01S06",
-    "RodeGOTPElevator": "D02Z02S11",
-    "OpenedConventLadder": "D02Z03S11",
-    "BrokeJondoBellW": "D03Z02S09",
-    "BrokeJondoBellE": "D03Z02S05",
-    "OpenedMOMLadder": "D04Z02S06",
-    "OpenedTSCGate": "D05Z02S11",
-    "OpenedARLadder": "D06Z01S23",
-    "BrokeBOTTCStatue": "D08Z01S02",
-    "OpenedWOTHPGate": "D09Z01S05",
-    "OpenedBOTSSLadder": "D17Z01S04"
-}
-
 group_table: Dict[str, Set[str]] = {
-    "wounds"  : ["Holy Wound of Attrition",
+    "wounds"  : {"Holy Wound of Attrition",
                  "Holy Wound of Contrition",
-                 "Holy Wound of Compunction"],
+                 "Holy Wound of Compunction"},
 
-    "masks"   : ["Deformed Mask of Orestes",
+    "masks"   : {"Deformed Mask of Orestes",
                  "Mirrored Mask of Dolphos",
-                 "Embossed Mask of Crescente"],
+                 "Embossed Mask of Crescente"},
 
-    "marks"   : ["Mark of the First Refuge",
+    "marks"   : {"Mark of the First Refuge",
                  "Mark of the Second Refuge",
-                 "Mark of the Third Refuge"],
+                 "Mark of the Third Refuge"},
 
-    "tirso"   : ["Bouquet of Rosemary",
+    "tirso"   : {"Bouquet of Rosemary",
                  "Incense Garlic",
                  "Olive Seeds",
                  "Dried Clove",
                  "Sooty Garlic",
-                 "Bouquet of Thyme"],
+                 "Bouquet of Thyme"},
 
-    "tentudia": ["Tentudia's Carnal Remains",
+    "tentudia": {"Tentudia's Carnal Remains",
                  "Remains of Tentudia's Hair",
-                 "Tentudia's Skeletal Remains"],
+                 "Tentudia's Skeletal Remains"},
 
-    "egg"     : ["Melted Golden Coins",
+    "egg"     : {"Melted Golden Coins",
                  "Torn Bridal Ribbon",
-                 "Black Grieving Veil"],
+                 "Black Grieving Veil"},
 
-    "bones"   : ["Parietal bone of Lasser, the Inquisitor",
+    "bones"   : {"Parietal bone of Lasser, the Inquisitor",
                  "Jaw of Ashgan, the Inquisitor",
                  "Cervical vertebra of Zicher, the Brewmaster",
                  "Clavicle of Dalhuisen, the Schoolchild",
@@ -725,14 +708,14 @@ group_table: Dict[str, Set[str]] = {
                  "Scaphoid of Fierce, the Leper",
                  "Anklebone of Weston, the Pilgrim",
                  "Calcaneum of Persian, the Bandit",
-                 "Navicular of Kahnnyhoo, the Murderer"],
+                 "Navicular of Kahnnyhoo, the Murderer"},
     
-    "power"   : ["Life Upgrade",
+    "power"   : {"Life Upgrade",
                  "Fervour Upgrade",
                  "Empty Bile Vessel",
-                 "Quicksilver"],
+                 "Quicksilver"},
 
-    "prayer"  : ["Seguiriya to your Eyes like Stars",
+    "prayer"  : {"Seguiriya to your Eyes like Stars",
                  "Debla of the Lights",
                  "Saeta Dolorosa",
                  "Campanillero to the Sons of the Aurora",
@@ -746,10 +729,17 @@ group_table: Dict[str, Set[str]] = {
                  "Romance to the Crimson Mist",
                  "Zambra to the Resplendent Crown",
                  "Cantina of the Blue Rose",
-                 "Mirabras of the Return to Port"]
+                 "Mirabras of the Return to Port"},
+
+    "toe"     : {"Little Toe made of Limestone",
+                 "Big Toe made of Limestone",
+                 "Fourth Toe made of Limestone"},
+    
+    "eye"     : {"Severed Right Eye of the Traitor",
+                 "Broken Left Eye of the Traitor"}
 }
 
-tears_set: Set[str] = [
+tears_list: List[str] = [
     "Tears of Atonement (500)",
     "Tears of Atonement (625)",
     "Tears of Atonement (750)",
@@ -772,16 +762,16 @@ tears_set: Set[str] = [
     "Tears of Atonement (30000)"
 ]
 
-reliquary_set: Set[str] = [
+reliquary_set: Set[str] = {
     "Reliquary of the Fervent Heart",
     "Reliquary of the Suffering Heart",
     "Reliquary of the Sorrowful Heart"
-]
+}
 
-skill_set: Set[str] = [
+skill_set: Set[str] = {
     "Combo Skill",
     "Charged Skill",
     "Ranged Skill",
     "Dive Skill",
     "Lunge Skill"
-]
+}

worlds/blasphemous/Options.py

@@ -1,4 +1,5 @@
-from Options import Choice, Toggle, DefaultOnToggle, DeathLink, StartInventoryPool
+from dataclasses import dataclass
+from Options import Choice, Toggle, DefaultOnToggle, DeathLink, PerGameCommonOptions, OptionGroup
 import random
 
 
@@ -20,23 +21,30 @@ class ChoiceIsRandom(Choice):
 
 
 class PrieDieuWarp(DefaultOnToggle):
-    """Automatically unlocks the ability to warp between Prie Dieu shrines."""
+    """
+    Automatically unlocks the ability to warp between Prie Dieu shrines.
+    """
     display_name = "Unlock Fast Travel"
 
 
 class SkipCutscenes(DefaultOnToggle):
-    """Automatically skips most cutscenes."""
+    """
+    Automatically skips most cutscenes.
+    """
     display_name = "Auto Skip Cutscenes"
 
 
 class CorpseHints(DefaultOnToggle):
-    """Changes the 34 corpses in game to give various hints about item locations."""
+    """
+    Changes the 34 corpses in game to give various hints about item locations.
+    """
     display_name = "Corpse Hints"
 
 
 class Difficulty(Choice):
-    """Adjusts the overall difficulty of the randomizer, including upgrades required to defeat bosses 
-    and advanced movement tricks or glitches."""
+    """
+    Adjusts the overall difficulty of the randomizer, including upgrades required to defeat bosses and advanced movement tricks or glitches.
+    """
     display_name = "Difficulty"
     option_easy = 0
     option_normal = 1
@@ -45,15 +53,18 @@ class Difficulty(Choice):
 
 
 class Penitence(Toggle):
-    """Allows one of the three Penitences to be chosen at the beginning of the game."""
+    """
+    Allows one of the three Penitences to be chosen at the beginning of the game.
+    """
     display_name = "Penitence"
 
 
 class StartingLocation(ChoiceIsRandom):
-    """Choose where to start the randomizer. Note that some starting locations cannot be chosen with certain 
-    other options.
-    Specifically, Brotherhood and Mourning And Havoc cannot be chosen if Shuffle Dash is enabled, and Grievance Ascends 
-    cannot be chosen if Shuffle Wall Climb is enabled."""
+    """
+    Choose where to start the randomizer. Note that some starting locations cannot be chosen with certain other options.
+    
+    Specifically, Brotherhood and Mourning And Havoc cannot be chosen if Shuffle Dash is enabled, and Grievance Ascends cannot be chosen if Shuffle Wall Climb is enabled.
+    """
     display_name = "Starting Location"
     option_brotherhood = 0
     option_albero = 1
@@ -66,10 +77,15 @@ class StartingLocation(ChoiceIsRandom):
 
 
 class Ending(Choice):
-    """Choose which ending is required to complete the game.
+    """
+    Choose which ending is required to complete the game.
+    
     Talking to Tirso in Albero will tell you the selected ending for the current game.
+    
     Ending A: Collect all thorn upgrades.
-    Ending C: Collect all thorn upgrades and the Holy Wound of Abnegation."""
+    
+    Ending C: Collect all thorn upgrades and the Holy Wound of Abnegation.
+    """
     display_name = "Ending"
     option_any_ending = 0
     option_ending_a = 1
@@ -78,14 +94,18 @@ class Ending(Choice):
 
 
 class SkipLongQuests(Toggle):
-    """Ensures that the rewards for long quests will be filler items.
-    Affected locations: \"Albero: Donate 50000 Tears\", \"Ossuary: 11th reward\", \"AtTotS: Miriam's gift\", 
-    \"TSC: Jocinero's final reward\""""
+    """
+    Ensures that the rewards for long quests will be filler items.
+    
+    Affected locations: "Albero: Donate 50000 Tears", "Ossuary: 11th reward", "AtTotS: Miriam's gift", "TSC: Jocinero's final reward"
+    """
     display_name = "Skip Long Quests"
 
 
 class ThornShuffle(Choice):
-    """Shuffles the Thorn given by Deogracias and all Thorn upgrades into the item pool."""
+    """
+    Shuffles the Thorn given by Deogracias and all Thorn upgrades into the item pool.
+    """
     display_name = "Shuffle Thorn"
     option_anywhere = 0
     option_local_only = 1
@@ -94,50 +114,68 @@ class ThornShuffle(Choice):
 
 
 class DashShuffle(Toggle):
-    """Turns the ability to dash into an item that must be found in the multiworld."""
+    """
+    Turns the ability to dash into an item that must be found in the multiworld.
+    """
     display_name = "Shuffle Dash"
 
 
 class WallClimbShuffle(Toggle):
-    """Turns the ability to climb walls with your sword into an item that must be found in the multiworld."""
+    """
+    Turns the ability to climb walls with your sword into an item that must be found in the multiworld.
+    """
     display_name = "Shuffle Wall Climb"
 
 
 class ReliquaryShuffle(DefaultOnToggle):
-    """Adds the True Torment exclusive Reliquary rosary beads into the item pool."""
+    """
+    Adds the True Torment exclusive Reliquary rosary beads into the item pool.
+    """
     display_name = "Shuffle Penitence Rewards"
 
 
 class CustomItem1(Toggle):
-    """Adds the custom relic Boots of Pleading into the item pool, which grants the ability to fall onto spikes 
-    and survive.
-    Must have the \"Blasphemous-Boots-of-Pleading\" mod installed to connect to a multiworld."""
+    """
+    Adds the custom relic Boots of Pleading into the item pool, which grants the ability to fall onto spikes and survive.
+    
+    Must have the "Boots of Pleading" mod installed to connect to a multiworld.
+    """
     display_name = "Boots of Pleading"
 
 
 class CustomItem2(Toggle):
-    """Adds the custom relic Purified Hand of the Nun into the item pool, which grants the ability to jump 
-    a second time in mid-air.
-    Must have the \"Blasphemous-Double-Jump\" mod installed to connect to a multiworld."""
+    """
+    Adds the custom relic Purified Hand of the Nun into the item pool, which grants the ability to jump a second time in mid-air.
+    
+    Must have the "Double Jump" mod installed to connect to a multiworld.
+    """
     display_name = "Purified Hand of the Nun"
 
 
 class StartWheel(Toggle):
-    """Changes the beginning gift to The Young Mason's Wheel."""
+    """
+    Changes the beginning gift to The Young Mason's Wheel.
+    """
     display_name = "Start with Wheel"
 
 
 class SkillRando(Toggle):
-    """Randomizes the abilities from the skill tree into the item pool."""
+    """
+    Randomizes the abilities from the skill tree into the item pool.
+    """
     display_name = "Skill Randomizer"
 
 
 class EnemyRando(Choice):
-    """Randomizes the enemies that appear in each room.
-    Shuffled: Enemies will be shuffled amongst each other, but can only appear as many times as they do in 
-    a standard game.
+    """
+    Randomizes the enemies that appear in each room.
+    
+    Shuffled: Enemies will be shuffled amongst each other, but can only appear as many times as they do in a standard game.
+    
     Randomized: Every enemy is completely random, and can appear any number of times.
-    Some enemies will never be randomized."""
+    
+    Some enemies will never be randomized.
+    """
     display_name = "Enemy Randomizer"
     option_disabled = 0
     option_shuffled = 1
@@ -146,43 +184,75 @@ class EnemyRando(Choice):
 
 
 class EnemyGroups(DefaultOnToggle):
-    """Randomized enemies will chosen from sets of specific groups. 
+    """
+    Randomized enemies will be chosen from sets of specific groups. 
+
     (Weak, normal, large, flying)
-    Has no effect if Enemy Randomizer is disabled."""
+    
+    Has no effect if Enemy Randomizer is disabled.
+    """
     display_name = "Enemy Groups"
 
 
 class EnemyScaling(DefaultOnToggle):
-    """Randomized enemies will have their stats increased or decreased depending on the area they appear in.
-    Has no effect if Enemy Randomizer is disabled."""
+    """
+    Randomized enemies will have their stats increased or decreased depending on the area they appear in.
+
+    Has no effect if Enemy Randomizer is disabled.
+    """
     display_name = "Enemy Scaling"
 
 
 class BlasphemousDeathLink(DeathLink):
-    """When you die, everyone dies. The reverse is also true.
-    Note that Guilt Fragments will not appear when killed by Death Link."""
+    """
+    When you die, everyone dies. The reverse is also true.
+
+    Note that Guilt Fragments will not appear when killed by Death Link.
+    """
 
 
-blasphemous_options = {
-    "prie_dieu_warp": PrieDieuWarp,
-    "skip_cutscenes": SkipCutscenes,
-    "corpse_hints": CorpseHints,
-    "difficulty": Difficulty,
-    "penitence": Penitence,
-    "starting_location": StartingLocation,
-    "ending": Ending,
-    "skip_long_quests": SkipLongQuests,
-    "thorn_shuffle" : ThornShuffle,
-    "dash_shuffle": DashShuffle,
-    "wall_climb_shuffle": WallClimbShuffle,
-    "reliquary_shuffle": ReliquaryShuffle,
-    "boots_of_pleading": CustomItem1,
-    "purified_hand": CustomItem2,
-    "start_wheel": StartWheel,
-    "skill_randomizer": SkillRando,
-    "enemy_randomizer": EnemyRando,
-    "enemy_groups": EnemyGroups,
-    "enemy_scaling": EnemyScaling,
-    "death_link": BlasphemousDeathLink,
-    "start_inventory": StartInventoryPool
-}
+@dataclass
+class BlasphemousOptions(PerGameCommonOptions):
+    prie_dieu_warp: PrieDieuWarp
+    skip_cutscenes: SkipCutscenes
+    corpse_hints: CorpseHints
+    difficulty: Difficulty
+    penitence: Penitence
+    starting_location: StartingLocation
+    ending: Ending
+    skip_long_quests: SkipLongQuests
+    thorn_shuffle: ThornShuffle
+    dash_shuffle: DashShuffle
+    wall_climb_shuffle: WallClimbShuffle
+    reliquary_shuffle: ReliquaryShuffle
+    boots_of_pleading: CustomItem1
+    purified_hand: CustomItem2
+    start_wheel: StartWheel
+    skill_randomizer: SkillRando
+    enemy_randomizer: EnemyRando
+    enemy_groups: EnemyGroups
+    enemy_scaling: EnemyScaling
+    death_link: BlasphemousDeathLink
+
+
+blas_option_groups = [
+    OptionGroup("Quality of Life",  [
+        PrieDieuWarp,
+        SkipCutscenes,
+        CorpseHints,
+        SkipLongQuests,
+        StartWheel
+    ]),
+    OptionGroup("Moveset", [
+        DashShuffle,
+        WallClimbShuffle,
+        SkillRando,
+        CustomItem1,
+        CustomItem2
+    ]),
+    OptionGroup("Enemy Randomizer", [
+        EnemyRando,
+        EnemyGroups,
+        EnemyScaling
+    ])
+]

worlds/blasphemous/Preprocessor.py

@@ -0,0 +1,582 @@
+# Preprocessor to convert Blasphemous Randomizer logic into a StringWorldDefinition for use with APHKLogicExtractor
+# https://github.com/BrandenEK/Blasphemous.Randomizer
+# https://github.com/ArchipelagoMW-HollowKnight/APHKLogicExtractor
+
+
+import json, requests, argparse
+from typing import List, Dict, Any
+
+
+def load_resource_local(file: str) -> List[Dict[str, Any]]:
+    print(f"Reading from {file}")
+    loaded = []
+    with open(file, encoding="utf-8") as f:
+        loaded = read_json(f.readlines())
+        f.close()
+
+    return loaded
+
+
+def load_resource_from_web(url: str) -> List[Dict[str, Any]]:
+    req = requests.get(url, timeout=1)
+    print(f"Reading from {url}")
+    req.encoding = "utf-8"
+    lines: List[str] = []
+    for line in req.text.splitlines():
+        while "\t" in line:
+            line = line[1::]
+        if line != "":
+            lines.append(line)
+    return read_json(lines)
+
+
+def read_json(lines: List[str]) -> List[Dict[str, Any]]:
+    loaded = []
+    creating_object: bool = False
+    obj: str = ""
+    for line in lines:
+        stripped = line.strip()
+        if "{" in stripped:
+            creating_object = True
+            obj += stripped
+            continue
+        elif "}," in stripped or "}" in stripped and "]" in lines[lines.index(line)+1]:
+            creating_object = False
+            obj += "}"
+            #print(f"obj = {obj}")
+            loaded.append(json.loads(obj))
+            obj = ""
+            continue
+
+        if not creating_object:
+            continue
+        else:
+            try:
+                if "}," in lines[lines.index(line)+1] and stripped[-1] == ",":
+                    obj += stripped[:-1]
+                else:
+                    obj += stripped
+            except IndexError:
+                obj += stripped
+
+    return loaded
+
+
+def get_room_from_door(door: str) -> str:
+    return door[:door.find("[")]
+
+
+def preprocess_logic(is_door: bool, id: str, logic: str) -> str:
+    if id in logic and not is_door:
+        index: int = logic.find(id)
+        logic = logic[:index] + logic[index+len(id)+4:]
+
+    while ">=" in logic:
+        index: int = logic.find(">=")
+        logic = logic[:index-1] + logic[index+3:]
+
+    while ">" in logic:
+        index: int = logic.find(">")
+        count = int(logic[index+2])
+        count += 1
+        logic = logic[:index-1] + str(count) + logic[index+3:]
+
+    while "<=" in logic:
+        index: int = logic.find("<=")
+        logic = logic[:index-1] + logic[index+3:]
+    
+    while "<" in logic:
+        index: int = logic.find("<")
+        count = int(logic[index+2])
+        count += 1
+        logic = logic[:index-1] + str(count) + logic[index+3:]
+
+    #print(logic)
+    return logic
+
+
+def build_logic_conditions(logic: str) -> List[List[str]]:
+    all_conditions: List[List[str]] = []
+
+    parts = logic.split()
+    sub_part: str = ""
+    current_index: int = 0
+    parens: int = -1
+    current_condition: List[str] = []
+    parens_conditions: List[List[List[str]]] = []
+
+    for index, part in enumerate(parts):
+        #print(current_index, index, parens, part)
+
+        # skip parts that have already been handled
+        if index < current_index:
+            continue
+
+        # break loop if reached final part
+        try:
+            parts[index+1]
+        except IndexError:
+            #print("INDEXERROR", part)
+            if parens < 0:
+                current_condition.append(part)
+                if len(parens_conditions) > 0:
+                    for i in parens_conditions:
+                        for j in i:
+                            all_conditions.append(j + current_condition)
+                else:
+                    all_conditions.append(current_condition)
+                break
+
+        #print(current_condition, parens, sub_part)
+
+        # prepare for subcondition
+        if "(" in part:
+            # keep track of nested parentheses
+            if parens == -1:
+                parens = 0
+            for char in part:
+                if char == "(":
+                    parens += 1
+            
+            # add to sub part
+            if sub_part == "":
+                sub_part = part
+            else:
+                sub_part += f" {part}"
+            #if not ")" in part:
+            continue
+
+        # end of subcondition
+        if ")" in part:
+            # read every character in case of multiple closing parentheses
+            for char in part:
+                if char == ")":
+                    parens -= 1
+
+            sub_part += f" {part}"
+
+            # if reached end of parentheses, handle subcondition
+            if parens == 0:
+                #print(current_condition, sub_part)
+                parens = -1
+
+                try:
+                    parts[index+1]
+                except IndexError:
+                    #print("END OF LOGIC")
+                    if len(parens_conditions) > 0:
+                        parens_conditions.append(build_logic_subconditions(current_condition, sub_part))
+                        #print("PARENS:", parens_conditions)
+
+                        temp_conditions: List[List[str]] = []
+
+                        for i in parens_conditions[0]:
+                            for j in parens_conditions[1]:
+                                temp_conditions.append(i + j)
+
+                        parens_conditions.pop(0)
+                        parens_conditions.pop(0)
+
+                        while len(parens_conditions) > 0:
+                            temp_conditions2 = temp_conditions
+                            temp_conditions = []
+                            for k in temp_conditions2:
+                                for l in parens_conditions[0]:
+                                    temp_conditions.append(k + l)
+                            
+                            parens_conditions.pop(0)
+
+                        #print("TEMP:", remove_duplicates(temp_conditions))
+                        all_conditions += temp_conditions
+                    else:
+                        all_conditions += build_logic_subconditions(current_condition, sub_part)
+                else:
+                    #print("NEXT PARTS:", parts[index+1], parts[index+2])
+                    if parts[index+1] == "&&":
+                        parens_conditions.append(build_logic_subconditions(current_condition, sub_part))
+                        #print("PARENS:", parens_conditions)
+                    else:
+                        if len(parens_conditions) > 0:
+                            parens_conditions.append(build_logic_subconditions(current_condition, sub_part))
+                            #print("PARENS:", parens_conditions)
+
+                            temp_conditions: List[List[str]] = []
+
+                            for i in parens_conditions[0]:
+                                for j in parens_conditions[1]:
+                                    temp_conditions.append(i + j)
+
+                            parens_conditions.pop(0)
+                            parens_conditions.pop(0)
+
+                            while len(parens_conditions) > 0:
+                                temp_conditions2 = temp_conditions
+                                temp_conditions = []
+                                for k in temp_conditions2:
+                                    for l in parens_conditions[0]:
+                                        temp_conditions.append(k + l)
+                                
+                                parens_conditions.pop(0)
+
+                            #print("TEMP:", remove_duplicates(temp_conditions))
+                            all_conditions += temp_conditions
+                        else:
+                            all_conditions += build_logic_subconditions(current_condition, sub_part)
+
+                    current_index = index+2
+                    
+                    current_condition = []
+                    sub_part = ""
+                    
+            continue
+
+        # collect all parts until reaching end of parentheses
+        if parens > 0:
+            sub_part += f" {part}"
+            continue
+
+        current_condition.append(part)
+
+        # continue with current condition
+        if parts[index+1] == "&&":
+            current_index = index+2
+            continue
+        
+        # add condition to list and start new one
+        elif parts[index+1] == "||":
+            if len(parens_conditions) > 0:
+                for i in parens_conditions:
+                    for j in i:
+                        all_conditions.append(j + current_condition)
+                parens_conditions = []
+            else:    
+                all_conditions.append(current_condition)
+            current_condition = []
+            current_index = index+2
+            continue
+        
+    return remove_duplicates(all_conditions)
+
+
+def build_logic_subconditions(current_condition: List[str], subcondition: str) -> List[List[str]]:
+    #print("STARTED SUBCONDITION", current_condition, subcondition)
+    subconditions = build_logic_conditions(subcondition[1:-1])
+    final_conditions = []
+
+    for condition in subconditions:
+        final_condition = current_condition + condition
+        final_conditions.append(final_condition)
+
+    #print("ENDED SUBCONDITION")
+    #print(final_conditions)
+    return final_conditions
+
+
+def remove_duplicates(conditions: List[List[str]]) -> List[List[str]]:
+    final_conditions: List[List[str]] = []
+    for condition in conditions:
+        final_conditions.append(list(dict.fromkeys(condition)))
+
+    return final_conditions
+
+
+def handle_door_visibility(door: Dict[str, Any]) -> Dict[str, Any]:
+    if door.get("visibilityFlags") == None:
+        return door
+    else:
+        flags: List[str] = str(door.get("visibilityFlags")).split(", ")
+        #print(flags)
+        temp_flags: List[str] = []
+        this_door: bool = False
+        #required_doors: str = ""
+
+        if "ThisDoor" in flags:
+            this_door = True
+
+        #if "requiredDoors" in flags:
+        #    required_doors: str = " || ".join(door.get("requiredDoors"))
+
+        if "DoubleJump" in flags:
+            temp_flags.append("DoubleJump")
+
+        if "NormalLogic" in flags:
+            temp_flags.append("NormalLogic")
+
+        if "NormalLogicAndDoubleJump" in flags:
+            temp_flags.append("NormalLogicAndDoubleJump")
+
+        if "HardLogic" in flags:
+            temp_flags.append("HardLogic")
+
+        if "HardLogicAndDoubleJump" in flags:
+            temp_flags.append("HardLogicAndDoubleJump")
+
+        if "EnemySkips" in flags:
+            temp_flags.append("EnemySkips")
+
+        if "EnemySkipsAndDoubleJump" in flags:
+            temp_flags.append("EnemySkipsAndDoubleJump")
+
+        # remove duplicates
+        temp_flags = list(dict.fromkeys(temp_flags))
+
+        original_logic: str = door.get("logic")
+        temp_logic: str = ""
+
+        if this_door:
+            temp_logic = door.get("id")
+
+        if temp_flags != []:
+            if temp_logic != "":
+                temp_logic += " || "
+            temp_logic += ' && '.join(temp_flags)
+
+        if temp_logic != "" and original_logic != None:
+            if len(original_logic.split()) == 1:
+                if len(temp_logic.split()) == 1:
+                    door["logic"] = f"{temp_logic} && {original_logic}"
+                else:
+                    door["logic"] = f"({temp_logic}) && {original_logic}"
+            else:
+                if len(temp_logic.split()) == 1:
+                    door["logic"] = f"{temp_logic} && ({original_logic})"
+                else:
+                    door["logic"] = f"({temp_logic}) && ({original_logic})"
+        elif temp_logic != "" and original_logic == None:
+            door["logic"] = temp_logic
+        
+        return door
+
+
+def get_state_provider_for_condition(condition: List[str]) -> str:
+    for item in condition:
+        if (item[0] == "D" and item[3] == "Z" and item[6] == "S")\
+        or (item[0] == "D" and item[3] == "B" and item[4] == "Z" and item[7] == "S"):
+            return item
+    return None
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-l', '--local', action="store_true", help="Use local files in the same directory instead of reading resource files from the BrandenEK/Blasphemous-Randomizer repository.")
+    args = parser.parse_args()
+    return args
+
+
+def main(args: argparse.Namespace):
+    doors = []
+    locations = []
+
+    if (args.local):
+        doors = load_resource_local("doors.json")
+        locations = load_resource_local("locations_items.json")
+    
+    else:
+        doors = load_resource_from_web("https://raw.githubusercontent.com/BrandenEK/Blasphemous-Randomizer/main/resources/data/Randomizer/doors.json")
+        locations = load_resource_from_web("https://raw.githubusercontent.com/BrandenEK/Blasphemous-Randomizer/main/resources/data/Randomizer/locations_items.json")
+
+    original_connections: Dict[str, str] = {}
+    rooms: Dict[str, List[str]] = {}
+    output: Dict[str, Any] = {}
+    logic_objects: List[Dict[str, Any]] = []
+
+    for door in doors:
+         if door.get("originalDoor") != None:
+            if not door.get("id") in original_connections:
+                original_connections[door.get("id")] = door.get("originalDoor")
+                original_connections[door.get("originalDoor")] = door.get("id")
+
+            room: str = get_room_from_door(door.get("originalDoor"))
+            if not room in rooms.keys():
+                rooms[room] = [door.get("id")]
+            else:
+                rooms[room].append(door.get("id"))
+
+    def flip_doors_in_condition(condition: List[str]) -> List[str]:
+        new_condition = []
+        for item in condition:
+            if item in original_connections:
+                new_condition.append(original_connections[item])
+            else:
+                new_condition.append(item)
+
+        return new_condition
+    
+    for room in rooms.keys():
+        obj = {
+            "Name": room,
+            "Logic": [],
+            "Handling": "Default"
+        }
+
+        for door in rooms[room]:
+            logic = {
+                "StateProvider": door,
+                "Conditions": [],
+                "StateModifiers": []
+            }
+            obj["Logic"].append(logic)
+        
+        logic_objects.append(obj)
+
+    for door in doors:
+        if door.get("direction") == 5:
+            continue
+
+        handling: str = "Transition"
+        if "Cell" in door.get("id"):
+            handling = "Default"
+        obj = {
+            "Name": door.get("id"),
+            "Logic": [],
+            "Handling": handling
+        }
+
+        visibility_flags: List[str] = []
+        if door.get("visibilityFlags") != None:
+            visibility_flags = str(door.get("visibilityFlags")).split(", ")
+            if "1" in visibility_flags:
+                visibility_flags.remove("1")
+                visibility_flags.append("ThisDoor")
+
+        required_doors: List[str] = []
+        if door.get("requiredDoors"):
+            required_doors = door.get("requiredDoors")
+
+        if len(visibility_flags) > 0:
+            for flag in visibility_flags:
+                if flag == "RequiredDoors":
+                    continue
+
+                if flag == "ThisDoor":
+                    flag = original_connections[door.get("id")]
+                
+                if door.get("logic") != None:
+                    logic: str = door.get("logic")
+                    logic = f"{flag} && ({logic})"
+                    logic = preprocess_logic(True, door.get("id"), logic)
+                    conditions = build_logic_conditions(logic)
+                    for condition in conditions:
+                        condition = flip_doors_in_condition(condition)
+                        state_provider: str = get_room_from_door(door.get("id"))
+
+                        if get_state_provider_for_condition(condition) != None:
+                            state_provider = get_state_provider_for_condition(condition)
+                            condition.remove(state_provider)
+
+                        logic = {
+                            "StateProvider": state_provider,
+                            "Conditions": condition,
+                            "StateModifiers": []
+                        }
+                        obj["Logic"].append(logic)
+                else:
+                    logic = {
+                        "StateProvider": get_room_from_door(door.get("id")),
+                        "Conditions": [flag],
+                        "StateModifiers": []
+                    }
+                    obj["Logic"].append(logic)
+            
+            if "RequiredDoors" in visibility_flags:
+                for d in required_doors:
+                    flipped = original_connections[d]
+                    if door.get("logic") != None:
+                        logic: str = preprocess_logic(True, door.get("id"), door.get("logic"))
+                        conditions = build_logic_conditions(logic)
+                        for condition in conditions:
+                            condition = flip_doors_in_condition(condition)
+                            state_provider: str = flipped
+
+                            if flipped in condition:
+                                condition.remove(flipped)
+
+                            logic = {
+                                "StateProvider": state_provider,
+                                "Conditions": condition,
+                                "StateModifiers": []
+                            }
+                            obj["Logic"].append(logic)
+                    else:
+                        logic = {
+                            "StateProvider": flipped,
+                            "Conditions": [],
+                            "StateModifiers": []
+                        }
+                        obj["Logic"].append(logic)
+
+        else:
+            if door.get("logic") != None:
+                logic: str = preprocess_logic(True, door.get("id"), door.get("logic"))
+                conditions = build_logic_conditions(logic)
+                for condition in conditions:
+                    condition = flip_doors_in_condition(condition)
+                    stateProvider: str = get_room_from_door(door.get("id"))
+
+                    if get_state_provider_for_condition(condition) != None:
+                        stateProvider = get_state_provider_for_condition(condition)
+                        condition.remove(stateProvider)
+
+                    logic = {
+                        "StateProvider": stateProvider,
+                        "Conditions": condition,
+                        "StateModifiers": []
+                    }
+                    obj["Logic"].append(logic)
+            else:
+                logic = {
+                    "StateProvider": get_room_from_door(door.get("id")),
+                    "Conditions": [],
+                    "StateModifiers": []
+                }
+                obj["Logic"].append(logic)
+
+        logic_objects.append(obj)
+
+    for location in locations:
+        obj = {
+            "Name": location.get("id"),
+            "Logic": [],
+            "Handling": "Location"
+        }
+
+        if location.get("logic") != None:
+            for condition in build_logic_conditions(preprocess_logic(False, location.get("id"), location.get("logic"))):
+                condition = flip_doors_in_condition(condition)
+                stateProvider: str = location.get("room")
+
+                if get_state_provider_for_condition(condition) != None:
+                    stateProvider = get_state_provider_for_condition(condition)
+                    condition.remove(stateProvider)
+
+                if stateProvider == "Initial":
+                    stateProvider = None
+
+                logic = {
+                    "StateProvider": stateProvider,
+                    "Conditions": condition,
+                    "StateModifiers": []
+                }
+                obj["Logic"].append(logic)
+        else:
+            stateProvider: str = location.get("room")
+            if stateProvider == "Initial":
+                stateProvider = None
+            logic = {
+                "StateProvider": stateProvider,
+                "Conditions": [],
+                "StateModifiers": []
+            }
+            obj["Logic"].append(logic)
+
+        logic_objects.append(obj)
+
+    output["LogicObjects"] = logic_objects
+        
+    with open("StringWorldDefinition.json", "w") as file:
+        print("Writing to StringWorldDefinition.json")
+        file.write(json.dumps(output, indent=4))
+
+
+if __name__ == "__main__":
+    main(parse_args())

worlds/blasphemous/Vanilla.py

@@ -8,12 +8,12 @@ unrandomized_dict: Dict[str, str] = {
 }
 
 
-junk_locations: Set[str] = [
+junk_locations: Set[str] = {
     "Albero: Donate 50000 Tears",
     "Ossuary: 11th reward",
     "AtTotS: Miriam's gift",
     "TSC: Jocinero's final reward"
-]
+}
 
 
 thorn_set: Set[str] = {
@@ -44,4 +44,4 @@ skill_dict: Dict[str, str] = {
     "Skill 5, Tier 1": "Lunge Skill",
     "Skill 5, Tier 2": "Lunge Skill",
     "Skill 5, Tier 3": "Lunge Skill",
-}
+}

worlds/blasphemous/__init__.py

@@ -1,15 +1,15 @@
 from typing import Dict, List, Set, Any
 from collections import Counter
-from BaseClasses import Region, Entrance, Location, Item, Tutorial, ItemClassification
+from BaseClasses import Region, Location, Item, Tutorial, ItemClassification
+from Options import OptionError
 from worlds.AutoWorld import World, WebWorld
-from .Items import base_id, item_table, group_table, tears_set, reliquary_set, event_table
-from .Locations import location_table
-from .Rooms import room_table, door_table
-from .Rules import rules
-from worlds.generic.Rules import set_rule, add_rule
-from .Options import blasphemous_options
+from .Items import base_id, item_table, group_table, tears_list, reliquary_set
+from .Locations import location_names
+from .Rules import BlasRules
+from worlds.generic.Rules import set_rule
+from .Options import BlasphemousOptions, blas_option_groups
 from .Vanilla import unrandomized_dict, junk_locations, thorn_set, skill_dict
-
+from .region_data import regions, locations
 
 class BlasphemousWeb(WebWorld):
     theme = "stone"
@@ -21,39 +21,33 @@ class BlasphemousWeb(WebWorld):
         "setup/en",
         ["TRPG"]
     )]
+    option_groups = blas_option_groups
 
 
 class BlasphemousWorld(World):
     """
     Blasphemous is a challenging Metroidvania set in the cursed land of Cvstodia. Play as the Penitent One, trapped
-    in an endless cycle of death and rebirth, and free the world from it's terrible fate in your quest to break
+    in an endless cycle of death and rebirth, and free the world from its terrible fate in your quest to break
     your eternal damnation!
     """
 
-    game: str = "Blasphemous"
+    game = "Blasphemous"
     web = BlasphemousWeb()
 
     item_name_to_id = {item["name"]: (base_id + index) for index, item in enumerate(item_table)}
-    location_name_to_id = {loc["name"]: (base_id + index) for index, loc in enumerate(location_table)}
-    location_name_to_game_id = {loc["name"]: loc["game_id"] for loc in location_table}
+    location_name_to_id = {loc: (base_id + index) for index, loc in enumerate(location_names.values())}
 
     item_name_groups = group_table
-    option_definitions = blasphemous_options
+    options_dataclass = BlasphemousOptions
+    options: BlasphemousOptions
 
-    required_client_version = (0, 4, 2)
+    required_client_version = (0, 4, 7)
 
 
     def __init__(self, multiworld, player):
         super(BlasphemousWorld, self).__init__(multiworld, player)
         self.start_room: str = "D17Z01S01"
-        self.door_connections: Dict[str, str] = {}
-
-
-    def set_rules(self):
-        rules(self)
-        for door in door_table:
-            add_rule(self.multiworld.get_location(door["Id"], self.player),
-                lambda state: state.can_reach(self.get_connected_door(door["Id"])), self.player)
+        self.disabled_locations: List[str] = []
 
 
     def create_item(self, name: str) -> "BlasphemousItem":
@@ -68,64 +62,56 @@ class BlasphemousWorld(World):
 
 
     def get_filler_item_name(self) -> str:
-        return self.multiworld.random.choice(tears_set)
+        return self.random.choice(tears_list)
 
 
     def generate_early(self):
-        world = self.multiworld
-        player = self.player
+        if not self.options.starting_location.randomized:
+            if self.options.starting_location == "mourning_havoc" and self.options.difficulty < 2:
+                raise OptionError(f"[Blasphemous - '{self.player_name}'] "
+                                f"{self.options.starting_location} cannot be chosen if Difficulty is lower than Hard.")
 
-        if not world.starting_location[player].randomized:
-            if world.starting_location[player].value == 6 and world.difficulty[player].value < 2:
-                raise Exception(f"[Blasphemous - '{world.get_player_name(player)}'] {world.starting_location[player]}"
-                                " cannot be chosen if Difficulty is lower than Hard.")
-
-            if (world.starting_location[player].value == 0 or world.starting_location[player].value == 6) \
-                and world.dash_shuffle[player]:
-                    raise Exception(f"[Blasphemous - '{world.get_player_name(player)}'] {world.starting_location[player]}"
-                                    " cannot be chosen if Shuffle Dash is enabled.")
+            if (self.options.starting_location == "brotherhood" or self.options.starting_location == "mourning_havoc") \
+                and self.options.dash_shuffle:
+                    raise OptionError(f"[Blasphemous - '{self.player_name}'] "
+                                    f"{self.options.starting_location} cannot be chosen if Shuffle Dash is enabled.")
             
-            if world.starting_location[player].value == 3 and world.wall_climb_shuffle[player]:
-                raise Exception(f"[Blasphemous - '{world.get_player_name(player)}'] {world.starting_location[player]}"
-                                " cannot be chosen if Shuffle Wall Climb is enabled.")
+            if self.options.starting_location == "grievance" and self.options.wall_climb_shuffle:
+                raise OptionError(f"[Blasphemous - '{self.player_name}'] "
+                                f"{self.options.starting_location} cannot be chosen if Shuffle Wall Climb is enabled.")
         else:
             locations: List[int] = [ 0, 1, 2, 3, 4, 5, 6 ]
-            invalid: bool = False
 
-            if world.difficulty[player].value < 2:
+            if self.options.difficulty < 2:
                 locations.remove(6)
 
-            if world.dash_shuffle[player]:
+            if self.options.dash_shuffle:
                 locations.remove(0)
                 if 6 in locations:
                     locations.remove(6)
 
-            if world.wall_climb_shuffle[player]:
+            if self.options.wall_climb_shuffle:
                 locations.remove(3)
 
-            if world.starting_location[player].value == 6 and world.difficulty[player].value < 2:
-                invalid = True
-
-            if (world.starting_location[player].value == 0 or world.starting_location[player].value == 6) \
-                and world.dash_shuffle[player]:
-                    invalid = True
-            
-            if world.starting_location[player].value == 3 and world.wall_climb_shuffle[player]:
-                invalid = True
-
-            if invalid:
-                world.starting_location[player].value = world.random.choice(locations)
+            if self.options.starting_location.value not in locations:
+                self.options.starting_location.value = self.random.choice(locations)
             
         
-        if not world.dash_shuffle[player]:
-            world.push_precollected(self.create_item("Dash Ability"))
+        if not self.options.dash_shuffle:
+            self.multiworld.push_precollected(self.create_item("Dash Ability"))
 
-        if not world.wall_climb_shuffle[player]:
-            world.push_precollected(self.create_item("Wall Climb Ability"))
+        if not self.options.wall_climb_shuffle:
+            self.multiworld.push_precollected(self.create_item("Wall Climb Ability"))
 
-        if world.skip_long_quests[player]:
+        if not self.options.boots_of_pleading:
+            self.disabled_locations.append("RE401")
+
+        if not self.options.purified_hand:
+            self.disabled_locations.append("RE402")
+
+        if self.options.skip_long_quests:
             for loc in junk_locations:
-                world.exclude_locations[player].value.add(loc)
+                self.options.exclude_locations.value.add(loc)
 
         start_rooms: Dict[int, str] = {
             0: "D17Z01S01",
@@ -137,13 +123,10 @@ class BlasphemousWorld(World):
             6: "D20Z02S09"
         }
 
-        self.start_room = start_rooms[world.starting_location[player].value]
+        self.start_room = start_rooms[self.options.starting_location.value]
 
 
     def create_items(self):
-        world = self.multiworld
-        player = self.player
-
         removed: int = 0
         to_remove: List[str] = [
             "Tears of Atonement (250)",
@@ -156,46 +139,46 @@ class BlasphemousWorld(World):
         skipped_items = []
         junk: int = 0
 
-        for item, count in world.start_inventory[player].value.items():
+        for item, count in self.options.start_inventory.value.items():
             for _ in range(count):
                 skipped_items.append(item)
                 junk += 1
 
         skipped_items.extend(unrandomized_dict.values())
 
-        if world.thorn_shuffle[player] == 2:
-            for i in range(8):
+        if self.options.thorn_shuffle == "vanilla":
+            for _ in range(8):
                 skipped_items.append("Thorn Upgrade")
 
-        if world.dash_shuffle[player]:
+        if self.options.dash_shuffle:
             skipped_items.append(to_remove[removed])
             removed += 1
-        elif not world.dash_shuffle[player]:
+        elif not self.options.dash_shuffle:
             skipped_items.append("Dash Ability")
 
-        if world.wall_climb_shuffle[player]:
+        if self.options.wall_climb_shuffle:
             skipped_items.append(to_remove[removed])
             removed += 1
-        elif not world.wall_climb_shuffle[player]:
+        elif not self.options.wall_climb_shuffle:
             skipped_items.append("Wall Climb Ability")
 
-        if not world.reliquary_shuffle[player]:
+        if not self.options.reliquary_shuffle:
             skipped_items.extend(reliquary_set)
-        elif world.reliquary_shuffle[player]:
-            for i in range(3):
+        elif self.options.reliquary_shuffle:
+            for _ in range(3):
                 skipped_items.append(to_remove[removed])
                 removed += 1
 
-        if not world.boots_of_pleading[player]:
+        if not self.options.boots_of_pleading:
             skipped_items.append("Boots of Pleading")
 
-        if not world.purified_hand[player]:
+        if not self.options.purified_hand:
             skipped_items.append("Purified Hand of the Nun")
 
-        if world.start_wheel[player]:
+        if self.options.start_wheel:
             skipped_items.append("The Young Mason's Wheel")
 
-        if not world.skill_randomizer[player]:
+        if not self.options.skill_randomizer:
             skipped_items.extend(skill_dict.values())
 
         counter = Counter(skipped_items)
@@ -208,184 +191,138 @@ class BlasphemousWorld(World):
             if count <= 0:
                 continue
             else:
-                for i in range(count):
+                for _ in range(count):
                     pool.append(self.create_item(item["name"]))
 
         for _ in range(junk):
             pool.append(self.create_item(self.get_filler_item_name()))
 
-        world.itempool += pool
-
-
-    def pre_fill(self):
-        world = self.multiworld
-        player = self.player
+        self.multiworld.itempool += pool
 
         self.place_items_from_dict(unrandomized_dict)
 
-        if world.thorn_shuffle[player] == 2:
+        if self.options.thorn_shuffle == "vanilla":
             self.place_items_from_set(thorn_set, "Thorn Upgrade")
 
-        if world.start_wheel[player]:
-            world.get_location("Beginning gift", player)\
-                .place_locked_item(self.create_item("The Young Mason's Wheel"))
+        if self.options.start_wheel:
+            self.get_location("Beginning gift").place_locked_item(self.create_item("The Young Mason's Wheel"))
 
-        if not world.skill_randomizer[player]:
+        if not self.options.skill_randomizer:
             self.place_items_from_dict(skill_dict)
 
-        if world.thorn_shuffle[player] == 1:
-            world.local_items[player].value.add("Thorn Upgrade")
+        if self.options.thorn_shuffle == "local_only":
+            self.options.local_items.value.add("Thorn Upgrade")
         
 
     def place_items_from_set(self, location_set: Set[str], name: str):
         for loc in location_set:
-            self.multiworld.get_location(loc, self.player)\
-                .place_locked_item(self.create_item(name))
+            self.get_location(loc).place_locked_item(self.create_item(name))
 
     
     def place_items_from_dict(self, option_dict: Dict[str, str]):
         for loc, item in option_dict.items():
-            self.multiworld.get_location(loc, self.player)\
-                .place_locked_item(self.create_item(item))
+            self.get_location(loc).place_locked_item(self.create_item(item))
 
 
     def create_regions(self) -> None:
+        multiworld = self.multiworld
         player = self.player
-        world = self.multiworld
+
+        created_regions: List[str] = []
+
+        for r in regions:
+            multiworld.regions.append(Region(r["name"], player, multiworld))
+            created_regions.append(r["name"])
+
+        self.get_region("Menu").add_exits({self.start_room: "New Game"})
+
+        blas_logic = BlasRules(self)
+
+        for r in regions:
+            region = self.get_region(r["name"])
+
+            for e in r["exits"]:
+                region.add_exits({e["target"]}, {e["target"]: blas_logic.load_rule(True, r["name"], e)})
+
+            for l in [l for l in r["locations"] if l not in self.disabled_locations]:
+                region.add_locations({location_names[l]: self.location_name_to_id[location_names[l]]}, BlasphemousLocation)
+
+            for t in r["transitions"]:
+                if t == r["name"]:
+                    continue
+                
+                if t in created_regions:
+                    region.add_exits({t})
+                else:
+                    multiworld.regions.append(Region(t, player, multiworld))
+                    created_regions.append(t)
+                    region.add_exits({t})
+
+
+        for l in [l for l in locations if l["name"] not in self.disabled_locations]:
+            location = self.get_location(location_names[l["name"]])
+            set_rule(location, blas_logic.load_rule(False, l["name"], l))
+
+        for rname, ename in blas_logic.indirect_conditions:
+            self.multiworld.register_indirect_condition(self.get_region(rname), self.get_entrance(ename))
+        #from Utils import visualize_regions
+        #visualize_regions(self.get_region("Menu"), "blasphemous_regions.puml")
         
-        menu_region = Region("Menu", player, world)
-        misc_region = Region("Misc", player, world)
-        world.regions += [menu_region, misc_region]
-
-        for room in room_table:
-            region = Region(room, player, world)
-            world.regions.append(region)
-
-        menu_region.add_exits({self.start_room: "New Game"})
-        world.get_region(self.start_room, player).add_exits({"Misc": "Misc"})
-
-        for door in door_table:
-            if door.get("OriginalDoor") is None:
-                continue
-            else:
-                if not door["Id"] in self.door_connections.keys():
-                    self.door_connections[door["Id"]] = door["OriginalDoor"]
-                    self.door_connections[door["OriginalDoor"]] = door["Id"]
-
-                parent_region: Region = self.get_room_from_door(door["Id"])
-                target_region: Region = self.get_room_from_door(door["OriginalDoor"])
-                parent_region.add_exits({
-                    target_region.name: door["Id"]
-                }, {
-                    target_region.name: lambda x: door.get("VisibilityFlags") != 1
-                })
-
-        for index, loc in enumerate(location_table):
-            if not world.boots_of_pleading[player] and loc["name"] == "BotSS: 2nd meeting with Redento":
-                continue
-            if not world.purified_hand[player] and loc["name"] == "MoM: Western room ledge":
-                continue
-
-            region: Region = world.get_region(loc["room"], player)
-            region.add_locations({loc["name"]: base_id + index})
-            #id = base_id + location_table.index(loc)
-            #reg.locations.append(BlasphemousLocation(player, loc["name"], id, reg))
-
-        for e, r in event_table.items():
-            region: Region = world.get_region(r, player)
-            event = BlasphemousLocation(player, e, None, region)
-            event.show_in_spoiler = False
-            event.place_locked_item(self.create_event(e))
-            region.locations.append(event)
-
-        for door in door_table:
-            region: Region = self.get_room_from_door(self.door_connections[door["Id"]])
-            event = BlasphemousLocation(player, door["Id"], None, region)
-            event.show_in_spoiler = False
-            event.place_locked_item(self.create_event(door["Id"]))
-            region.locations.append(event)
-        
-        victory = Location(player, "His Holiness Escribar", None, world.get_region("D07Z01S03", player))
+        victory = Location(player, "His Holiness Escribar", None, self.get_region("D07Z01S03[W]"))
         victory.place_locked_item(self.create_event("Victory"))
-        world.get_region("D07Z01S03", player).locations.append(victory)
+        self.get_region("D07Z01S03[W]").locations.append(victory)
 
-        if world.ending[self.player].value == 1:
+        if self.options.ending == "ending_a":
             set_rule(victory, lambda state: state.has("Thorn Upgrade", player, 8))
-        elif world.ending[self.player].value == 2:
+        elif self.options.ending == "ending_c":
             set_rule(victory, lambda state: state.has("Thorn Upgrade", player, 8) and
                 state.has("Holy Wound of Abnegation", player))
 
-        world.completion_condition[self.player] = lambda state: state.has("Victory", player)
-        
-
-    def get_room_from_door(self, door: str) -> Region:
-        return self.multiworld.get_region(door.split("[")[0], self.player)
-
-    
-    def get_connected_door(self, door: str) -> Entrance:
-        return self.multiworld.get_entrance(self.door_connections[door], self.player)
+        multiworld.completion_condition[self.player] = lambda state: state.has("Victory", player)
     
     
     def fill_slot_data(self) -> Dict[str, Any]:
         slot_data: Dict[str, Any] = {}
-        locations = []
         doors: Dict[str, str] = {}
-
-        world = self.multiworld
-        player = self.player
         thorns: bool = True
 
-        if world.thorn_shuffle[player].value == 2:
+        if self.options.thorn_shuffle == "vanilla":
             thorns = False
 
-        for loc in world.get_filled_locations(player):
-            if loc.item.code == None:
-                continue
-            else:
-                data = {
-                    "id": self.location_name_to_game_id[loc.name],
-                    "ap_id": loc.address,
-                    "name": loc.item.name,
-                    "player_name": world.player_name[loc.item.player],
-                    "type": int(loc.item.classification)
-                }
-
-                locations.append(data)
-
         config = {
-            "LogicDifficulty": world.difficulty[player].value,
-            "StartingLocation": world.starting_location[player].value,
+            "LogicDifficulty": self.options.difficulty.value,
+            "StartingLocation": self.options.starting_location.value,
             "VersionCreated": "AP",
             
-            "UnlockTeleportation": bool(world.prie_dieu_warp[player].value),
-            "AllowHints": bool(world.corpse_hints[player].value),
-            "AllowPenitence": bool(world.penitence[player].value),
+            "UnlockTeleportation": bool(self.options.prie_dieu_warp.value),
+            "AllowHints": bool(self.options.corpse_hints.value),
+            "AllowPenitence": bool(self.options.penitence.value),
             
-            "ShuffleReliquaries": bool(world.reliquary_shuffle[player].value),
-            "ShuffleBootsOfPleading": bool(world.boots_of_pleading[player].value),
-            "ShufflePurifiedHand": bool(world.purified_hand[player].value),
-            "ShuffleDash": bool(world.dash_shuffle[player].value),
-            "ShuffleWallClimb": bool(world.wall_climb_shuffle[player].value),
+            "ShuffleReliquaries": bool(self.options.reliquary_shuffle.value),
+            "ShuffleBootsOfPleading": bool(self.options.boots_of_pleading.value),
+            "ShufflePurifiedHand": bool(self.options.purified_hand.value),
+            "ShuffleDash": bool(self.options.dash_shuffle.value),
+            "ShuffleWallClimb": bool(self.options.wall_climb_shuffle.value),
             
-            "ShuffleSwordSkills": bool(world.skill_randomizer[player].value),
+            "ShuffleSwordSkills": bool(self.options.wall_climb_shuffle.value),
             "ShuffleThorns": thorns,
-            "JunkLongQuests": bool(world.skip_long_quests[player].value),
-            "StartWithWheel": bool(world.start_wheel[player].value),
+            "JunkLongQuests": bool(self.options.skip_long_quests.value),
+            "StartWithWheel": bool(self.options.start_wheel.value),
 
-            "EnemyShuffleType": world.enemy_randomizer[player].value,
-            "MaintainClass": bool(world.enemy_groups[player].value),
-            "AreaScaling": bool(world.enemy_scaling[player].value),
+            "EnemyShuffleType": self.options.enemy_randomizer.value,
+            "MaintainClass": bool(self.options.enemy_groups.value),
+            "AreaScaling": bool(self.options.enemy_scaling.value),
 
             "BossShuffleType": 0,
             "DoorShuffleType": 0
         }
     
         slot_data = {
-            "locations": locations,
+            "locationinfo": [{"gameId": loc, "apId": (base_id + index)} for index, loc in enumerate(location_names)],
             "doors": doors,
             "cfg": config,
-            "ending": world.ending[self.player].value,
-            "death_link": bool(world.death_link[self.player].value)
+            "ending": self.options.ending.value,
+            "death_link": bool(self.options.death_link.value)
         }
     
         return slot_data
@@ -396,4 +333,4 @@ class BlasphemousItem(Item):
 
 
 class BlasphemousLocation(Location):
-    game: str = "Blasphemous"
+    game: str = "Blasphemous"

worlds/blasphemous/docs/setup_en.md

@@ -1,48 +1,17 @@
 # Blasphemous Multiworld Setup Guide
 
-## Useful Links
+It is recommended to use the [Mod Installer](https://github.com/BrandenEK/Blasphemous.Modding.Installer) to handle installing and updating mods. If you would prefer to install mods manually, instructions can also be found at the Mod Installer repository. 
 
-Required:
-- Blasphemous: [Steam](https://store.steampowered.com/app/774361/Blasphemous/)
-    - The GOG version of Blasphemous will also work.
-- Blasphemous Mod Installer: [GitHub](https://github.com/BrandenEK/Blasphemous-Mod-Installer)
-- Blasphemous Modding API: [GitHub](https://github.com/BrandenEK/Blasphemous-Modding-API)
-- Blasphemous Randomizer: [GitHub](https://github.com/BrandenEK/Blasphemous-Randomizer)
-- Blasphemous Multiworld: [GitHub](https://github.com/BrandenEK/Blasphemous-Multiworld)
+You will need the [Multiworld](https://github.com/BrandenEK/Blasphemous.Randomizer.Multiworld) mod to play an Archipelago randomizer.
 
-Optional:
-- In-game map tracker: [GitHub](https://github.com/BrandenEK/Blasphemous-Rando-Map)
-- Quick Prie Dieu warp mod: [GitHub](https://github.com/BadMagic100/Blasphemous-PrieWarp)
-- Boots of Pleading mod: [GitHub](https://github.com/BrandenEK/Blasphemous-Boots-of-Pleading)
-- Double Jump mod: [GitHub](https://github.com/BrandenEK/Blasphemous-Double-Jump)
+Some optional mods are also recommended:
+- [Rando Map](https://github.com/BrandenEK/Blasphemous.Randomizer.MapTracker)
+- [Boots of Pleading](https://github.com/BrandenEK/Blasphemous.BootsOfPleading) (Required if the "Boots of Pleading" option is enabled)
+- [Double Jump](https://github.com/BrandenEK/Blasphemous.DoubleJump) (Required if the "Purified Hand of the Nun" option is enabled)
 
-## Mod Installer (Recommended)
+To connect to a multiworld: Choose a save file and enter the address, your name, and the password (if the server has one) into the menu.
 
-1. Download the [Mod Installer](https://github.com/BrandenEK/Blasphemous-Mod-Installer),
-and point it to your install directory for Blasphemous.
-
-2. Install the `Modding API`, `Randomizer`, and `Multiworld` mods. Optionally, you can also install the
-`Rando Map`, `PrieWarp`, `Boots of Pleading`, and `Double Jump` mods, and set up the PopTracker pack if desired.
-
-3. Start Blasphemous. To verfy that the mods are working, look for a version number for both
-the Randomizer and Multiworld on the title screen.
-
-## Manual Installation
-
-1. Download the [Modding API](https://github.com/BrandenEK/Blasphemous-Modding-API/releases), and follow
-the [installation instructions](https://github.com/BrandenEK/Blasphemous-Modding-API#installation) on the GitHub page.
-
-2. After the Modding API has been installed, download the 
-[Randomizer](https://github.com/BrandenEK/Blasphemous-Randomizer/releases) and 
-[Multiworld](https://github.com/BrandenEK/Blasphemous-Multiworld/releases) archives, and extract the contents of both
-into the `Modding` folder. Then, add any desired additional mods.
-
-3. Start Blasphemous. To verfy that the mods are working, look for a version number for both
-the Randomizer and Multiworld on the title screen.
-
-## Connecting
-
-To connect to an Archipelago server, open the in-game console by pressing backslash `\` and use
-the command `multiworld connect [address:port] [name] [password]`. 
-The port and password are both optional - if no port is provided then the default port of 38281 is used.
-**Make sure to connect to the server before attempting to start a new save file.**
+After connecting, there are some commands you can use in the console, which can be opened by pressing backslash `\`:
+- `ap status` - Display connection status.
+- `ap say [message]` - Send a message to the server.
+- `ap hint [item]` - Request a hint for an item from the server.

worlds/blasphemous/test/__init__.py

@@ -0,0 +1,7 @@
+from test.bases import WorldTestBase
+from .. import BlasphemousWorld
+
+
+class BlasphemousTestBase(WorldTestBase):
+    game = "Blasphemous"
+    world: BlasphemousWorld

worlds/blasphemous/test/test_background_zones.py

@@ -0,0 +1,56 @@
+from . import BlasphemousTestBase
+from ..Locations import location_names
+
+
+class BotSSGauntletTest(BlasphemousTestBase):
+    options = {
+        "starting_location": "albero",
+        "wall_climb_shuffle": True,
+        "dash_shuffle": True
+    }
+
+    @property
+    def run_default_tests(self) -> bool:
+        return False
+    
+    def test_botss_gauntlet(self) -> None:
+        self.assertAccessDependency([location_names["CO25"]], [["Dash Ability", "Wall Climb Ability"]], True)
+
+
+class BackgroundZonesTest(BlasphemousTestBase):
+    @property
+    def run_default_tests(self) -> bool:
+        return False
+
+    def test_dc_shroud(self) -> None:
+        self.assertAccessDependency([location_names["RB03"]], [["Shroud of Dreamt Sins"]], True)
+
+    def test_wothp_bronze_cells(self) -> None:
+        bronze_locations = [
+            location_names["QI70"],
+            location_names["RESCUED_CHERUB_03"]
+        ]
+
+        self.assertAccessDependency(bronze_locations, [["Key of the Secular"]], True)
+
+    def test_wothp_silver_cells(self) -> None:
+        silver_locations = [
+            location_names["CO24"],
+            location_names["RESCUED_CHERUB_34"],
+            location_names["CO37"],
+            location_names["RESCUED_CHERUB_04"]
+        ]
+
+        self.assertAccessDependency(silver_locations, [["Key of the Scribe"]], True)
+
+    def test_wothp_gold_cells(self) -> None:
+        gold_locations = [
+            location_names["QI51"],
+            location_names["CO26"],
+            location_names["CO02"]
+        ]
+
+        self.assertAccessDependency(gold_locations, [["Key of the Inquisitor"]], True)
+
+    def test_wothp_quirce(self) -> None:
+        self.assertAccessDependency([location_names["BS14"]], [["Key of the Secular", "Key of the Scribe", "Key of the Inquisitor"]], True)

worlds/blasphemous/test/test_starting_locations.py

@@ -0,0 +1,135 @@
+from . import BlasphemousTestBase
+
+
+class TestBrotherhoodEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "brotherhood",
+        "difficulty": "easy"
+    }
+
+
+class TestBrotherhoodNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "brotherhood",
+        "difficulty": "normal"
+    }
+
+
+class TestBrotherhoodHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "brotherhood",
+        "difficulty": "hard"
+    }
+
+
+class TestAlberoEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "albero",
+        "difficulty": "easy"
+    }
+
+
+class TestAlberoNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "albero",
+        "difficulty": "normal"
+    }
+
+
+class TestAlberoHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "albero",
+        "difficulty": "hard"
+    }
+
+
+class TestConventEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "convent",
+        "difficulty": "easy"
+    }
+
+
+class TestConventNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "convent",
+        "difficulty": "normal"
+    }
+
+
+class TestConventHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "convent",
+        "difficulty": "hard"
+    }
+
+
+class TestGrievanceEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "grievance",
+        "difficulty": "easy"
+    }
+
+
+class TestGrievanceNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "grievance",
+        "difficulty": "normal"
+    }
+
+
+class TestGrievanceHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "grievance",
+        "difficulty": "hard"
+    }
+
+
+class TestKnotOfWordsEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "knot_of_words",
+        "difficulty": "easy"
+    }
+
+
+class TestKnotOfWordsNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "knot_of_words",
+        "difficulty": "normal"
+    }
+
+
+class TestKnotOfWordsHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "knot_of_words",
+        "difficulty": "hard"
+    }
+
+
+class TestRooftopsEasy(BlasphemousTestBase):
+    options = {
+        "starting_location": "rooftops",
+        "difficulty": "easy"
+    }
+
+
+class TestRooftopsNormal(BlasphemousTestBase):
+    options = {
+        "starting_location": "rooftops",
+        "difficulty": "normal"
+    }
+
+
+class TestRooftopsHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "rooftops",
+        "difficulty": "hard"
+    }
+
+
+# mourning and havoc can't be selected on easy or normal. hard only
+class TestMourningHavocHard(BlasphemousTestBase):
+    options = {
+        "starting_location": "mourning_havoc",
+        "difficulty": "hard"
+    }

worlds/celeste64/docs/guide_en.md

@@ -28,7 +28,7 @@ An Example `AP.json` file:
 
 ```
 {
-	"Url": "archipelago:12345",
+	"Url": "archipelago.gg:12345",
 	"SlotName": "Maddy",
 	"Password": ""
 }

worlds/checksfinder/__init__.py

@@ -44,15 +44,15 @@ class ChecksFinderWorld(World):
         self.multiworld.regions += [menu, board]
 
     def create_items(self):
-        # Generate item pool
-        itempool = []
+        # Generate list of items
+        items_to_create = []
         # Add the map width and height stuff
-        itempool += ["Map Width"] * 5  # 10 - 5
-        itempool += ["Map Height"] * 5  # 10 - 5
+        items_to_create += ["Map Width"] * 5  # 10 - 5
+        items_to_create += ["Map Height"] * 5  # 10 - 5
         # Add the map bombs
-        itempool += ["Map Bombs"] * 15  # 20 - 5
-        # Convert itempool into real items
-        itempool = [self.create_item(item) for item in itempool]
+        items_to_create += ["Map Bombs"] * 15  # 20 - 5
+        # Convert list into real items
+        itempool = [self.create_item(item) for item in items_to_create]
 
         self.multiworld.itempool += itempool
 

worlds/dark_souls_3/Bosses.py

@@ -63,6 +63,9 @@ all_bosses = [
     DS3BossInfo("Deacons of the Deep", 3500800, locations = {
         "CD: Soul of the Deacons of the Deep",
         "CD: Small Doll - boss drop",
+        "CD: Archdeacon White Crown - boss room after killing boss",
+        "CD: Archdeacon Holy Garb - boss room after killing boss",
+        "CD: Archdeacon Skirt - boss room after killing boss",
         "FS: Hawkwood's Shield - gravestone after Hawkwood leaves",
     }),
     DS3BossInfo("Abyss Watchers", 3300801, before_storm_ruler = True, locations = {

worlds/dark_souls_3/Items.py

@@ -238,15 +238,6 @@ class DS3ItemData:
             ds3_code = cast(int, self.ds3_code) + level,
             filler = False,
         )
-    
-    def __hash__(self) -> int:
-        return (self.name, self.ds3_code).__hash__()
-    
-    def __eq__(self, other: Any) -> bool:
-        if isinstance(other, self.__class__):
-            return self.name == other.name and self.ds3_code == other.ds3_code
-        else:
-            return False
 
 
 class DarkSouls3Item(Item):

worlds/dark_souls_3/__init__.py

@@ -612,9 +612,7 @@ class DarkSouls3World(World):
                 self._add_entrance_rule("Painted World of Ariandel (Before Contraption)", "Basin of Vows")
 
         # Define the access rules to some specific locations
-        if self._is_location_available("FS: Lift Chamber Key - Leonhard"):
-            self._add_location_rule("HWL: Red Eye Orb - wall tower, miniboss",
-                                    "Lift Chamber Key")
+        self._add_location_rule("HWL: Red Eye Orb - wall tower, miniboss", "Lift Chamber Key")
         self._add_location_rule("ID: Bellowing Dragoncrest Ring - drop from B1 towards pit",
                                 "Jailbreaker's Key")
         self._add_location_rule("ID: Covetous Gold Serpent Ring - Siegward's cell", "Old Cell Key")
@@ -1252,6 +1250,9 @@ class DarkSouls3World(World):
                 lambda item: not item.advancement
             )
 
+        # Prevent the player from prioritizing and "excluding" the same location
+        self.options.priority_locations.value -= allow_useful_locations
+
         if self.options.excluded_location_behavior == "allow_useful":
             self.options.exclude_locations.value.clear()
 
@@ -1292,10 +1293,10 @@ class DarkSouls3World(World):
         locations = location if isinstance(location, list) else [location]
         for location in locations:
             data = location_dictionary[location]
-            if data.dlc and not self.options.enable_dlc: return
-            if data.ngp and not self.options.enable_ngp: return
+            if data.dlc and not self.options.enable_dlc: continue
+            if data.ngp and not self.options.enable_ngp: continue
 
-            if not self._is_location_available(location): return
+            if not self._is_location_available(location): continue
             if isinstance(rule, str):
                 assert item_dictionary[rule].classification == ItemClassification.progression
                 rule = lambda state, item=rule: state.has(item, self.player)
@@ -1504,16 +1505,19 @@ class DarkSouls3World(World):
         # We include all the items the game knows about so that users can manually request items
         # that aren't randomized, and then we _also_ include all the items that are placed in
         # practice `item_dictionary.values()` doesn't include upgraded or infused weapons.
-        all_items = {
-            cast(DarkSouls3Item, location.item).data
+        items_by_name = {
+            location.item.name: cast(DarkSouls3Item, location.item).data
             for location in self.multiworld.get_filled_locations()
             # item.code None is used for events, which we want to skip
             if location.item.code is not None and location.item.player == self.player
-        }.union(item_dictionary.values())
+        }
+        for item in item_dictionary.values():
+            if item.name not in items_by_name:
+                items_by_name[item.name] = item
 
         ap_ids_to_ds3_ids: Dict[str, int] = {}
         item_counts: Dict[str, int] = {}
-        for item in all_items:
+        for item in items_by_name.values():
             if item.ap_code is None: continue
             if item.ds3_code: ap_ids_to_ds3_ids[str(item.ap_code)] = item.ds3_code
             if item.count != 1: item_counts[str(item.ap_code)] = item.count

worlds/doom_ii/Locations.py

@@ -1470,7 +1470,7 @@ location_table: Dict[int, LocationDict] = {
              'map': 6,
              'index': 102,
              'doom_type': 2006,
-             'region': "Tenements (MAP17) Main"},
+             'region': "Tenements (MAP17) Yellow"},
     361243: {'name': 'Tenements (MAP17) - Plasma gun',
              'episode': 2,
              'map': 6,

worlds/factorio/Mod.py

@@ -1,5 +1,6 @@
 """Outputs a Factorio Mod to facilitate integration with Archipelago"""
 
+import dataclasses
 import json
 import os
 import shutil
@@ -88,6 +89,8 @@ class FactorioModFile(worlds.Files.APContainer):
 def generate_mod(world: "Factorio", output_directory: str):
     player = world.player
     multiworld = world.multiworld
+    random = world.random
+
     global data_final_template, locale_template, control_template, data_template, settings_template
     with template_load_lock:
         if not data_final_template:
@@ -110,8 +113,6 @@ def generate_mod(world: "Factorio", output_directory: str):
     mod_name = f"AP-{multiworld.seed_name}-P{player}-{multiworld.get_file_safe_player_name(player)}"
     versioned_mod_name = mod_name + "_" + Utils.__version__
 
-    random = multiworld.per_slot_randoms[player]
-
     def flop_random(low, high, base=None):
         """Guarantees 50% below base and 50% above base, uniform distribution in each direction."""
         if base:
@@ -129,43 +130,43 @@ def generate_mod(world: "Factorio", output_directory: str):
         "base_tech_table": base_tech_table,
         "tech_to_progressive_lookup": tech_to_progressive_lookup,
         "mod_name": mod_name,
-        "allowed_science_packs": multiworld.max_science_pack[player].get_allowed_packs(),
-        "custom_technologies": multiworld.worlds[player].custom_technologies,
+        "allowed_science_packs": world.options.max_science_pack.get_allowed_packs(),
+        "custom_technologies": world.custom_technologies,
         "tech_tree_layout_prerequisites": world.tech_tree_layout_prerequisites,
-        "slot_name": multiworld.player_name[player], "seed_name": multiworld.seed_name,
+        "slot_name": world.player_name, "seed_name": multiworld.seed_name,
         "slot_player": player,
-        "starting_items": multiworld.starting_items[player], "recipes": recipes,
+        "starting_items": world.options.starting_items, "recipes": recipes,
         "random": random, "flop_random": flop_random,
-        "recipe_time_scale": recipe_time_scales.get(multiworld.recipe_time[player].value, None),
-        "recipe_time_range": recipe_time_ranges.get(multiworld.recipe_time[player].value, None),
+        "recipe_time_scale": recipe_time_scales.get(world.options.recipe_time.value, None),
+        "recipe_time_range": recipe_time_ranges.get(world.options.recipe_time.value, None),
         "free_sample_blacklist": {item: 1 for item in free_sample_exclusions},
         "progressive_technology_table": {tech.name: tech.progressive for tech in
                                          progressive_technology_table.values()},
         "custom_recipes": world.custom_recipes,
-        "max_science_pack": multiworld.max_science_pack[player].value,
+        "max_science_pack": world.options.max_science_pack.value,
         "liquids": fluids,
-        "goal": multiworld.goal[player].value,
-        "energy_link": multiworld.energy_link[player].value,
+        "goal": world.options.goal.value,
+        "energy_link": world.options.energy_link.value,
         "useless_technologies": useless_technologies,
-        "chunk_shuffle": multiworld.chunk_shuffle[player].value if hasattr(multiworld, "chunk_shuffle") else 0,
+        "chunk_shuffle": 0,
     }
 
-    for factorio_option in Options.factorio_options:
+    for factorio_option, factorio_option_instance in dataclasses.asdict(world.options).items():
         if factorio_option in ["free_sample_blacklist", "free_sample_whitelist"]:
             continue
-        template_data[factorio_option] = getattr(multiworld, factorio_option)[player].value
+        template_data[factorio_option] = factorio_option_instance.value
 
-    if getattr(multiworld, "silo")[player].value == Options.Silo.option_randomize_recipe:
+    if world.options.silo == Options.Silo.option_randomize_recipe:
         template_data["free_sample_blacklist"]["rocket-silo"] = 1
 
-    if getattr(multiworld, "satellite")[player].value == Options.Satellite.option_randomize_recipe:
+    if world.options.satellite == Options.Satellite.option_randomize_recipe:
         template_data["free_sample_blacklist"]["satellite"] = 1
 
-    template_data["free_sample_blacklist"].update({item: 1 for item in multiworld.free_sample_blacklist[player].value})
-    template_data["free_sample_blacklist"].update({item: 0 for item in multiworld.free_sample_whitelist[player].value})
+    template_data["free_sample_blacklist"].update({item: 1 for item in world.options.free_sample_blacklist.value})
+    template_data["free_sample_blacklist"].update({item: 0 for item in world.options.free_sample_whitelist.value})
 
     zf_path = os.path.join(output_directory, versioned_mod_name + ".zip")
-    mod = FactorioModFile(zf_path, player=player, player_name=multiworld.player_name[player])
+    mod = FactorioModFile(zf_path, player=player, player_name=world.player_name)
 
     if world.zip_path:
         with zipfile.ZipFile(world.zip_path) as zf:

worlds/factorio/Options.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
-import typing
+
+from dataclasses import dataclass
 import datetime
+import typing
+
+from schema import Schema, Optional, And, Or
 
 from Options import Choice, OptionDict, OptionSet, Option, DefaultOnToggle, Range, DeathLink, Toggle, \
-    StartInventoryPool
-from schema import Schema, Optional, And, Or
+    StartInventoryPool, PerGameCommonOptions
 
 # schema helpers
 FloatRange = lambda low, high: And(Or(int, float), lambda f: low <= f <= high)
@@ -422,50 +425,37 @@ class EnergyLink(Toggle):
     display_name = "EnergyLink"
 
 
-factorio_options: typing.Dict[str, type(Option)] = {
-    "max_science_pack": MaxSciencePack,
-    "goal": Goal,
-    "tech_tree_layout": TechTreeLayout,
-    "min_tech_cost": MinTechCost,
-    "max_tech_cost": MaxTechCost,
-    "tech_cost_distribution": TechCostDistribution,
-    "tech_cost_mix": TechCostMix,
-    "ramping_tech_costs": RampingTechCosts,
-    "silo": Silo,
-    "satellite": Satellite,
-    "free_samples": FreeSamples,
-    "tech_tree_information": TechTreeInformation,
-    "starting_items": FactorioStartItems,
-    "free_sample_blacklist": FactorioFreeSampleBlacklist,
-    "free_sample_whitelist": FactorioFreeSampleWhitelist,
-    "recipe_time": RecipeTime,
-    "recipe_ingredients": RecipeIngredients,
-    "recipe_ingredients_offset": RecipeIngredientsOffset,
-    "imported_blueprints": ImportedBlueprint,
-    "world_gen": FactorioWorldGen,
-    "progressive": Progressive,
-    "teleport_traps": TeleportTrapCount,
-    "grenade_traps": GrenadeTrapCount,
-    "cluster_grenade_traps": ClusterGrenadeTrapCount,
-    "artillery_traps": ArtilleryTrapCount,
-    "atomic_rocket_traps": AtomicRocketTrapCount,
-    "attack_traps": AttackTrapCount,
-    "evolution_traps": EvolutionTrapCount,
-    "evolution_trap_increase": EvolutionTrapIncrease,
-    "death_link": DeathLink,
-    "energy_link": EnergyLink,
-    "start_inventory_from_pool": StartInventoryPool,
-}
-
-# spoilers below. If you spoil it for yourself, please at least don't spoil it for anyone else.
-if datetime.datetime.today().month == 4:
-
-    class ChunkShuffle(Toggle):
-        """Entrance Randomizer."""
-        display_name = "Chunk Shuffle"
-
-
-    if datetime.datetime.today().day > 1:
-        ChunkShuffle.__doc__ += """
-        2023 April Fool's option. Shuffles chunk border transitions."""
-    factorio_options["chunk_shuffle"] = ChunkShuffle
+@dataclass
+class FactorioOptions(PerGameCommonOptions):
+    max_science_pack: MaxSciencePack
+    goal: Goal
+    tech_tree_layout: TechTreeLayout
+    min_tech_cost: MinTechCost
+    max_tech_cost: MaxTechCost
+    tech_cost_distribution: TechCostDistribution
+    tech_cost_mix: TechCostMix
+    ramping_tech_costs: RampingTechCosts
+    silo: Silo
+    satellite: Satellite
+    free_samples: FreeSamples
+    tech_tree_information: TechTreeInformation
+    starting_items: FactorioStartItems
+    free_sample_blacklist: FactorioFreeSampleBlacklist
+    free_sample_whitelist: FactorioFreeSampleWhitelist
+    recipe_time: RecipeTime
+    recipe_ingredients: RecipeIngredients
+    recipe_ingredients_offset: RecipeIngredientsOffset
+    imported_blueprints: ImportedBlueprint
+    world_gen: FactorioWorldGen
+    progressive: Progressive
+    teleport_traps: TeleportTrapCount
+    grenade_traps: GrenadeTrapCount
+    cluster_grenade_traps: ClusterGrenadeTrapCount
+    artillery_traps: ArtilleryTrapCount
+    atomic_rocket_traps: AtomicRocketTrapCount
+    attack_traps: AttackTrapCount
+    evolution_traps: EvolutionTrapCount
+    evolution_trap_increase: EvolutionTrapIncrease
+    death_link: DeathLink
+    energy_link: EnergyLink
+    start_inventory_from_pool: StartInventoryPool

worlds/factorio/Shapes.py

@@ -19,12 +19,10 @@ def _sorter(location: "FactorioScienceLocation"):
     return location.complexity, location.rel_cost
 
 
-def get_shapes(factorio_world: "Factorio") -> Dict["FactorioScienceLocation", Set["FactorioScienceLocation"]]:
-    world = factorio_world.multiworld
-    player = factorio_world.player
+def get_shapes(world: "Factorio") -> Dict["FactorioScienceLocation", Set["FactorioScienceLocation"]]:
     prerequisites: Dict["FactorioScienceLocation", Set["FactorioScienceLocation"]] = {}
-    layout = world.tech_tree_layout[player].value
-    locations: List["FactorioScienceLocation"] = sorted(factorio_world.science_locations, key=lambda loc: loc.name)
+    layout = world.options.tech_tree_layout.value
+    locations: List["FactorioScienceLocation"] = sorted(world.science_locations, key=lambda loc: loc.name)
     world.random.shuffle(locations)
 
     if layout == TechTreeLayout.option_single:
@@ -247,5 +245,5 @@ def get_shapes(factorio_world: "Factorio") -> Dict["FactorioScienceLocation", Se
     else:
         raise NotImplementedError(f"Layout {layout} is not implemented.")
 
-    factorio_world.tech_tree_layout_prerequisites = prerequisites
+    world.tech_tree_layout_prerequisites = prerequisites
     return prerequisites

worlds/factorio/Technologies.py

@@ -13,12 +13,11 @@ import Utils
 from . import Options
 
 factorio_tech_id = factorio_base_id = 2 ** 17
-# Factorio technologies are imported from a .json document in /data
-source_folder = os.path.join(os.path.dirname(__file__), "data")
 
 pool = ThreadPoolExecutor(1)
 
 
+# Factorio technologies are imported from a .json document in /data
 def load_json_data(data_name: str) -> Union[List[str], Dict[str, Any]]:
     return orjson.loads(pkgutil.get_data(__name__, "data/" + data_name + ".json"))
 
@@ -99,7 +98,7 @@ class CustomTechnology(Technology):
                            and ((ingredients & {"chemical-science-pack", "production-science-pack", "utility-science-pack"})
                                 or origin.name == "rocket-silo")
         self.player = player
-        if origin.name not in world.worlds[player].special_nodes:
+        if origin.name not in world.special_nodes:
             if military_allowed:
                 ingredients.add("military-science-pack")
             ingredients = list(ingredients)

worlds/factorio/__init__.py

@@ -11,7 +11,7 @@ from worlds.LauncherComponents import Component, components, Type, launch_subpro
 from worlds.generic import Rules
 from .Locations import location_pools, location_table
 from .Mod import generate_mod
-from .Options import factorio_options, MaxSciencePack, Silo, Satellite, TechTreeInformation, Goal, TechCostDistribution
+from .Options import FactorioOptions, MaxSciencePack, Silo, Satellite, TechTreeInformation, Goal, TechCostDistribution
 from .Shapes import get_shapes
 from .Technologies import base_tech_table, recipe_sources, base_technology_table, \
     all_ingredient_names, all_product_sources, required_technologies, get_rocket_requirements, \
@@ -89,18 +89,21 @@ class Factorio(World):
     advancement_technologies: typing.Set[str]
 
     web = FactorioWeb()
+    options_dataclass = FactorioOptions
+    options: FactorioOptions
 
     item_name_to_id = all_items
     location_name_to_id = location_table
     item_name_groups = {
         "Progressive": set(progressive_tech_table.keys()),
     }
-    required_client_version = (0, 4, 2)
+    required_client_version = (0, 5, 0)
 
     ordered_science_packs: typing.List[str] = MaxSciencePack.get_ordered_science_packs()
     tech_tree_layout_prerequisites: typing.Dict[FactorioScienceLocation, typing.Set[FactorioScienceLocation]]
     tech_mix: int = 0
     skip_silo: bool = False
+    origin_region_name = "Nauvis"
     science_locations: typing.List[FactorioScienceLocation]
 
     settings: typing.ClassVar[FactorioSettings]
@@ -116,35 +119,32 @@ class Factorio(World):
 
     def generate_early(self) -> None:
         # if max < min, then swap max and min
-        if self.multiworld.max_tech_cost[self.player] < self.multiworld.min_tech_cost[self.player]:
-            self.multiworld.min_tech_cost[self.player].value, self.multiworld.max_tech_cost[self.player].value = \
-                self.multiworld.max_tech_cost[self.player].value, self.multiworld.min_tech_cost[self.player].value
-        self.tech_mix = self.multiworld.tech_cost_mix[self.player]
-        self.skip_silo = self.multiworld.silo[self.player].value == Silo.option_spawn
+        if self.options.max_tech_cost < self.options.min_tech_cost:
+            self.options.min_tech_cost.value, self.options.max_tech_cost.value = \
+                self.options.max_tech_cost.value, self.options.min_tech_cost.value
+        self.tech_mix = self.options.tech_cost_mix.value
+        self.skip_silo = self.options.silo.value == Silo.option_spawn
 
     def create_regions(self):
         player = self.player
-        random = self.multiworld.random
-        menu = Region("Menu", player, self.multiworld)
-        crash = Entrance(player, "Crash Land", menu)
-        menu.exits.append(crash)
+        random = self.random
         nauvis = Region("Nauvis", player, self.multiworld)
 
         location_count = len(base_tech_table) - len(useless_technologies) - self.skip_silo + \
-                         self.multiworld.evolution_traps[player] + \
-                         self.multiworld.attack_traps[player] + \
-                         self.multiworld.teleport_traps[player] + \
-                         self.multiworld.grenade_traps[player] + \
-                         self.multiworld.cluster_grenade_traps[player] + \
-                         self.multiworld.atomic_rocket_traps[player] + \
-                         self.multiworld.artillery_traps[player]
+                         self.options.evolution_traps + \
+                         self.options.attack_traps + \
+                         self.options.teleport_traps + \
+                         self.options.grenade_traps + \
+                         self.options.cluster_grenade_traps + \
+                         self.options.atomic_rocket_traps + \
+                         self.options.artillery_traps
 
         location_pool = []
 
-        for pack in sorted(self.multiworld.max_science_pack[self.player].get_allowed_packs()):
+        for pack in sorted(self.options.max_science_pack.get_allowed_packs()):
             location_pool.extend(location_pools[pack])
         try:
-            location_names = self.multiworld.random.sample(location_pool, location_count)
+            location_names = random.sample(location_pool, location_count)
         except ValueError as e:
             # should be "ValueError: Sample larger than population or is negative"
             raise Exception("Too many traps for too few locations. Either decrease the trap count, "
@@ -152,9 +152,9 @@ class Factorio(World):
 
         self.science_locations = [FactorioScienceLocation(player, loc_name, self.location_name_to_id[loc_name], nauvis)
                                   for loc_name in location_names]
-        distribution: TechCostDistribution = self.multiworld.tech_cost_distribution[self.player]
-        min_cost = self.multiworld.min_tech_cost[self.player]
-        max_cost = self.multiworld.max_tech_cost[self.player]
+        distribution: TechCostDistribution = self.options.tech_cost_distribution
+        min_cost = self.options.min_tech_cost.value
+        max_cost = self.options.max_tech_cost.value
         if distribution == distribution.option_even:
             rand_values = (random.randint(min_cost, max_cost) for _ in self.science_locations)
         else:
@@ -163,7 +163,7 @@ class Factorio(World):
                     distribution.option_high: max_cost}[distribution.value]
             rand_values = (random.triangular(min_cost, max_cost, mode) for _ in self.science_locations)
         rand_values = sorted(rand_values)
-        if self.multiworld.ramping_tech_costs[self.player]:
+        if self.options.ramping_tech_costs:
             def sorter(loc: FactorioScienceLocation):
                 return loc.complexity, loc.rel_cost
         else:
@@ -178,34 +178,32 @@ class Factorio(World):
         event = FactorioItem("Victory", ItemClassification.progression, None, player)
         location.place_locked_item(event)
 
-        for ingredient in sorted(self.multiworld.max_science_pack[self.player].get_allowed_packs()):
+        for ingredient in sorted(self.options.max_science_pack.get_allowed_packs()):
             location = FactorioLocation(player, f"Automate {ingredient}", None, nauvis)
             nauvis.locations.append(location)
             event = FactorioItem(f"Automated {ingredient}", ItemClassification.progression, None, player)
             location.place_locked_item(event)
 
-        crash.connect(nauvis)
-        self.multiworld.regions += [menu, nauvis]
+        self.multiworld.regions.append(nauvis)
 
     def create_items(self) -> None:
-        player = self.player
         self.custom_technologies = self.set_custom_technologies()
         self.set_custom_recipes()
         traps = ("Evolution", "Attack", "Teleport", "Grenade", "Cluster Grenade", "Artillery", "Atomic Rocket")
         for trap_name in traps:
             self.multiworld.itempool.extend(self.create_item(f"{trap_name} Trap") for _ in
-                                            range(getattr(self.multiworld,
-                                                          f"{trap_name.lower().replace(' ', '_')}_traps")[player]))
+                                            range(getattr(self.options,
+                                                          f"{trap_name.lower().replace(' ', '_')}_traps")))
 
-        want_progressives = collections.defaultdict(lambda: self.multiworld.progressive[player].
-                                                    want_progressives(self.multiworld.random))
+        want_progressives = collections.defaultdict(lambda: self.options.progressive.
+                                                    want_progressives(self.random))
 
         cost_sorted_locations = sorted(self.science_locations, key=lambda location: location.name)
         special_index = {"automation": 0,
                          "logistics": 1,
                          "rocket-silo": -1}
         loc: FactorioScienceLocation
-        if self.multiworld.tech_tree_information[player] == TechTreeInformation.option_full:
+        if self.options.tech_tree_information == TechTreeInformation.option_full:
             # mark all locations as pre-hinted
             for loc in self.science_locations:
                 loc.revealed = True
@@ -232,14 +230,13 @@ class Factorio(World):
                     loc.revealed = True
 
     def set_rules(self):
-        world = self.multiworld
         player = self.player
         shapes = get_shapes(self)
 
-        for ingredient in self.multiworld.max_science_pack[self.player].get_allowed_packs():
-            location = world.get_location(f"Automate {ingredient}", player)
+        for ingredient in self.options.max_science_pack.get_allowed_packs():
+            location = self.get_location(f"Automate {ingredient}")
 
-            if self.multiworld.recipe_ingredients[self.player]:
+            if self.options.recipe_ingredients:
                 custom_recipe = self.custom_recipes[ingredient]
 
                 location.access_rule = lambda state, ingredient=ingredient, custom_recipe=custom_recipe: \
@@ -260,30 +257,30 @@ class Factorio(World):
                     prerequisites: all(state.can_reach(loc) for loc in locations))
 
         silo_recipe = None
-        if self.multiworld.silo[self.player] == Silo.option_spawn:
+        if self.options.silo == Silo.option_spawn:
             silo_recipe = self.custom_recipes["rocket-silo"] if "rocket-silo" in self.custom_recipes \
                 else next(iter(all_product_sources.get("rocket-silo")))
         part_recipe = self.custom_recipes["rocket-part"]
         satellite_recipe = None
-        if self.multiworld.goal[self.player] == Goal.option_satellite:
+        if self.options.goal == Goal.option_satellite:
             satellite_recipe = self.custom_recipes["satellite"] if "satellite" in self.custom_recipes \
                 else next(iter(all_product_sources.get("satellite")))
         victory_tech_names = get_rocket_requirements(silo_recipe, part_recipe, satellite_recipe)
-        if self.multiworld.silo[self.player] != Silo.option_spawn:
+        if self.options.silo != Silo.option_spawn:
             victory_tech_names.add("rocket-silo")
-        world.get_location("Rocket Launch", player).access_rule = lambda state: all(state.has(technology, player)
-                                                                                    for technology in
-                                                                                    victory_tech_names)
+        self.get_location("Rocket Launch").access_rule = lambda state: all(state.has(technology, player)
+                                                                           for technology in
+                                                                           victory_tech_names)
 
-        world.completion_condition[player] = lambda state: state.has('Victory', player)
+        self.multiworld.completion_condition[player] = lambda state: state.has('Victory', player)
 
     def generate_basic(self):
-        map_basic_settings = self.multiworld.world_gen[self.player].value["basic"]
+        map_basic_settings = self.options.world_gen.value["basic"]
         if map_basic_settings.get("seed", None) is None:  # allow seed 0
             # 32 bit uint
-            map_basic_settings["seed"] = self.multiworld.per_slot_randoms[self.player].randint(0, 2 ** 32 - 1)
+            map_basic_settings["seed"] = self.random.randint(0, 2 ** 32 - 1)
 
-        start_location_hints: typing.Set[str] = self.multiworld.start_location_hints[self.player].value
+        start_location_hints: typing.Set[str] = self.options.start_location_hints.value
 
         for loc in self.science_locations:
             # show start_location_hints ingame
@@ -307,8 +304,6 @@ class Factorio(World):
 
         return super(Factorio, self).collect_item(state, item, remove)
 
-    option_definitions = factorio_options
-
     @classmethod
     def stage_write_spoiler(cls, world, spoiler_handle):
         factorio_players = world.get_game_players(cls.game)
@@ -348,7 +343,7 @@ class Factorio(World):
         # have to first sort for determinism, while filtering out non-stacking items
         pool: typing.List[str] = sorted(pool & valid_ingredients)
         # then sort with random data to shuffle
-        self.multiworld.random.shuffle(pool)
+        self.random.shuffle(pool)
         target_raw = int(sum((count for ingredient, count in original.base_cost.items())) * factor)
         target_energy = original.total_energy * factor
         target_num_ingredients = len(original.ingredients) + ingredients_offset
@@ -392,7 +387,7 @@ class Factorio(World):
             if min_num > max_num:
                 fallback_pool.append(ingredient)
                 continue  # can't use that ingredient
-            num = self.multiworld.random.randint(min_num, max_num)
+            num = self.random.randint(min_num, max_num)
             new_ingredients[ingredient] = num
             remaining_raw -= num * ingredient_raw
             remaining_energy -= num * ingredient_energy
@@ -436,66 +431,66 @@ class Factorio(World):
 
     def set_custom_technologies(self):
         custom_technologies = {}
-        allowed_packs = self.multiworld.max_science_pack[self.player].get_allowed_packs()
+        allowed_packs = self.options.max_science_pack.get_allowed_packs()
         for technology_name, technology in base_technology_table.items():
-            custom_technologies[technology_name] = technology.get_custom(self.multiworld, allowed_packs, self.player)
+            custom_technologies[technology_name] = technology.get_custom(self, allowed_packs, self.player)
         return custom_technologies
 
     def set_custom_recipes(self):
-        ingredients_offset = self.multiworld.recipe_ingredients_offset[self.player]
+        ingredients_offset = self.options.recipe_ingredients_offset
         original_rocket_part = recipes["rocket-part"]
         science_pack_pools = get_science_pack_pools()
-        valid_pool = sorted(science_pack_pools[self.multiworld.max_science_pack[self.player].get_max_pack()] & valid_ingredients)
-        self.multiworld.random.shuffle(valid_pool)
+        valid_pool = sorted(science_pack_pools[self.options.max_science_pack.get_max_pack()] & valid_ingredients)
+        self.random.shuffle(valid_pool)
         self.custom_recipes = {"rocket-part": Recipe("rocket-part", original_rocket_part.category,
                                                      {valid_pool[x]: 10 for x in range(3 + ingredients_offset)},
                                                      original_rocket_part.products,
                                                      original_rocket_part.energy)}
 
-        if self.multiworld.recipe_ingredients[self.player]:
+        if self.options.recipe_ingredients:
             valid_pool = []
-            for pack in self.multiworld.max_science_pack[self.player].get_ordered_science_packs():
+            for pack in self.options.max_science_pack.get_ordered_science_packs():
                 valid_pool += sorted(science_pack_pools[pack])
-                self.multiworld.random.shuffle(valid_pool)
+                self.random.shuffle(valid_pool)
                 if pack in recipes:  # skips over space science pack
                     new_recipe = self.make_quick_recipe(recipes[pack], valid_pool, ingredients_offset=
-                                                        ingredients_offset)
+                                                        ingredients_offset.value)
                     self.custom_recipes[pack] = new_recipe
 
-        if self.multiworld.silo[self.player].value == Silo.option_randomize_recipe \
-                or self.multiworld.satellite[self.player].value == Satellite.option_randomize_recipe:
+        if self.options.silo.value == Silo.option_randomize_recipe \
+                or self.options.satellite.value == Satellite.option_randomize_recipe:
             valid_pool = set()
-            for pack in sorted(self.multiworld.max_science_pack[self.player].get_allowed_packs()):
+            for pack in sorted(self.options.max_science_pack.get_allowed_packs()):
                 valid_pool |= science_pack_pools[pack]
 
-            if self.multiworld.silo[self.player].value == Silo.option_randomize_recipe:
+            if self.options.silo.value == Silo.option_randomize_recipe:
                 new_recipe = self.make_balanced_recipe(
                     recipes["rocket-silo"], valid_pool,
-                    factor=(self.multiworld.max_science_pack[self.player].value + 1) / 7,
-                    ingredients_offset=ingredients_offset)
+                    factor=(self.options.max_science_pack.value + 1) / 7,
+                    ingredients_offset=ingredients_offset.value)
                 self.custom_recipes["rocket-silo"] = new_recipe
 
-            if self.multiworld.satellite[self.player].value == Satellite.option_randomize_recipe:
+            if self.options.satellite.value == Satellite.option_randomize_recipe:
                 new_recipe = self.make_balanced_recipe(
                     recipes["satellite"], valid_pool,
-                    factor=(self.multiworld.max_science_pack[self.player].value + 1) / 7,
-                    ingredients_offset=ingredients_offset)
+                    factor=(self.options.max_science_pack.value + 1) / 7,
+                    ingredients_offset=ingredients_offset.value)
                 self.custom_recipes["satellite"] = new_recipe
         bridge = "ap-energy-bridge"
         new_recipe = self.make_quick_recipe(
             Recipe(bridge, "crafting", {"replace_1": 1, "replace_2": 1, "replace_3": 1,
                                         "replace_4": 1, "replace_5": 1, "replace_6": 1},
                    {bridge: 1}, 10),
-            sorted(science_pack_pools[self.multiworld.max_science_pack[self.player].get_ordered_science_packs()[0]]),
-            ingredients_offset=ingredients_offset)
+            sorted(science_pack_pools[self.options.max_science_pack.get_ordered_science_packs()[0]]),
+            ingredients_offset=ingredients_offset.value)
         for ingredient_name in new_recipe.ingredients:
-            new_recipe.ingredients[ingredient_name] = self.multiworld.random.randint(50, 500)
+            new_recipe.ingredients[ingredient_name] = self.random.randint(50, 500)
         self.custom_recipes[bridge] = new_recipe
 
-        needed_recipes = self.multiworld.max_science_pack[self.player].get_allowed_packs() | {"rocket-part"}
-        if self.multiworld.silo[self.player] != Silo.option_spawn:
+        needed_recipes = self.options.max_science_pack.get_allowed_packs() | {"rocket-part"}
+        if self.options.silo != Silo.option_spawn:
             needed_recipes |= {"rocket-silo"}
-        if self.multiworld.goal[self.player].value == Goal.option_satellite:
+        if self.options.goal.value == Goal.option_satellite:
             needed_recipes |= {"satellite"}
 
         for recipe in needed_recipes:
@@ -545,7 +540,8 @@ class FactorioScienceLocation(FactorioLocation):
 
         self.ingredients = {Factorio.ordered_science_packs[self.complexity]: 1}
         for complexity in range(self.complexity):
-            if parent.multiworld.tech_cost_mix[self.player] > parent.multiworld.random.randint(0, 99):
+            if (parent.multiworld.worlds[self.player].options.tech_cost_mix >
+                    parent.multiworld.worlds[self.player].random.randint(0, 99)):
                 self.ingredients[Factorio.ordered_science_packs[complexity]] = 1
 
     @property

worlds/hk/__init__.py

@@ -21,6 +21,16 @@ from .Charms import names as charm_names
 from BaseClasses import Region, Location, MultiWorld, Item, LocationProgressType, Tutorial, ItemClassification, CollectionState
 from worlds.AutoWorld import World, LogicMixin, WebWorld
 
+from settings import Group, Bool
+
+
+class HollowKnightSettings(Group):
+    class DisableMapModSpoilers(Bool):
+        """Disallows the APMapMod from showing spoiler placements."""
+
+    disable_spoilers: typing.Union[DisableMapModSpoilers, bool] = False
+
+
 path_of_pain_locations = {
     "Soul_Totem-Path_of_Pain_Below_Thornskip",
     "Lore_Tablet-Path_of_Pain_Entrance",
@@ -124,14 +134,25 @@ shop_cost_types: typing.Dict[str, typing.Tuple[str, ...]] = {
 
 
 class HKWeb(WebWorld):
-    tutorials = [Tutorial(
+    setup_en  = Tutorial(
         "Mod Setup and Use Guide",
         "A guide to playing Hollow Knight with Archipelago.",
         "English",
         "setup_en.md",
         "setup/en",
         ["Ijwu"]
-    )]
+    )
+
+    setup_pt_br  = Tutorial(
+        setup_en.tutorial_name,
+        setup_en.description,
+        "Português Brasileiro",
+        "setup_pt_br.md",
+        "setup/pt_br",
+        ["JoaoVictor-FA"]
+    )
+
+    tutorials = [setup_en, setup_pt_br]
 
     bug_report_page = "https://github.com/Ijwu/Archipelago.HollowKnight/issues/new?assignees=&labels=bug%2C+needs+investigation&template=bug_report.md&title="
 
@@ -145,6 +166,7 @@ class HKWorld(World):
     game: str = "Hollow Knight"
     options_dataclass = HKOptions
     options: HKOptions
+    settings: typing.ClassVar[HollowKnightSettings]
 
     web = HKWeb()
 
@@ -544,6 +566,8 @@ class HKWorld(World):
 
         slot_data["grub_count"] = self.grub_count
 
+        slot_data["is_race"] = int(self.settings.disable_spoilers or self.multiworld.is_race)
+
         return slot_data
 
     def create_item(self, name: str) -> HKItem:
@@ -601,11 +625,11 @@ class HKWorld(World):
         if change:
             for effect_name, effect_value in item_effects.get(item.name, {}).items():
                 state.prog_items[item.player][effect_name] += effect_value
-        if item.name in {"Left_Mothwing_Cloak", "Right_Mothwing_Cloak"}:
-            if state.prog_items[item.player].get('RIGHTDASH', 0) and \
-                    state.prog_items[item.player].get('LEFTDASH', 0):
-                (state.prog_items[item.player]["RIGHTDASH"], state.prog_items[item.player]["LEFTDASH"]) = \
-                    ([max(state.prog_items[item.player]["RIGHTDASH"], state.prog_items[item.player]["LEFTDASH"])] * 2)
+            if item.name in {"Left_Mothwing_Cloak", "Right_Mothwing_Cloak"}:
+                if state.prog_items[item.player].get('RIGHTDASH', 0) and \
+                        state.prog_items[item.player].get('LEFTDASH', 0):
+                    (state.prog_items[item.player]["RIGHTDASH"], state.prog_items[item.player]["LEFTDASH"]) = \
+                        ([max(state.prog_items[item.player]["RIGHTDASH"], state.prog_items[item.player]["LEFTDASH"])] * 2)
         return change
 
     def remove(self, state, item: HKItem) -> bool:

worlds/hk/docs/setup_en.md

@@ -15,7 +15,7 @@
 ### What to do if Lumafly fails to find your installation directory
 1. Find the directory manually.
    * Xbox Game Pass:
-      1. Enter the XBox app and move your mouse over "Hollow Knight" on the left sidebar. 
+      1. Enter the Xbox app and move your mouse over "Hollow Knight" on the left sidebar. 
       2. Click the three points then click "Manage".
       3. Go to the "Files" tab and select "Browse...". 
       4. Click "Hollow Knight", then "Content", then click the path bar and copy it.

worlds/hk/docs/setup_pt_br.md

@@ -0,0 +1,52 @@
+# Guia de configuração para Hollow Knight no Archipelago
+
+## Programas obrigatórios
+* Baixe e extraia o Lumafly Mod Manager (gerenciador de mods Lumafly) do [Site Lumafly](https://themulhima.github.io/Lumafly/).
+* Uma cópia legal de Hollow Knight.
+   * Versões Steam, Gog, e Xbox Game Pass do jogo são suportadas.
+   * Windows, Mac, e Linux (incluindo Steam Deck) são suportados.
+
+## Instalando o mod Archipelago Mod usando Lumafly
+1. Abra o Lumafly e confirme que ele localizou sua pasta de instalação do Hollow Knight.
+2. Clique em "Install (instalar)" perto da opção "Archipelago" mod.
+   * Se quiser, instale também o "Archipelago Map Mod (mod do mapa do archipelago)" para usá-lo como rastreador dentro do jogo.
+3. Abra o jogo, tudo preparado!
+
+### O que fazer se o Lumafly falha em encontrar a sua pasta de instalação
+1. Encontre a pasta manualmente.
+   * Xbox Game Pass:
+      1. Entre no seu aplicativo Xbox e mova seu mouse em cima de "Hollow Knight" na sua barra da esquerda. 
+      2. Clique nos 3 pontos depois clique gerenciar.
+      3. Vá nos arquivos e selecione procurar. 
+      4. Clique em "Hollow Knight", depois em "Content (Conteúdo)", depois clique na barra com o endereço e a copie.
+   * Steam:
+      1. Você provavelmente colocou sua biblioteca Steam num local não padrão. Se esse for o caso você provavelmente sabe onde está.
+         . Encontre sua biblioteca Steam, depois encontre a pasta do Hollow Knight e copie seu endereço.
+         * Windows - `C:\Program Files (x86)\Steam\steamapps\common\Hollow Knight`
+         * Linux/Steam Deck - `~/.local/share/Steam/steamapps/common/Hollow Knight`
+         * Mac - `~/Library/Application Support/Steam/steamapps/common/Hollow Knight/hollow_knight.app`
+2. Rode o Lumafly como administrador e, quando ele perguntar pelo endereço do arquivo, cole o endereço do arquivo que você copiou.
+
+## Configurando seu arquivo YAML
+### O que é um YAML e por que eu preciso de um?
+Um arquivo YAML é a forma que você informa suas configurações do jogador para o Archipelago.
+Olhe o [guia de configuração básica de um multiworld](/tutorial/Archipelago/setup/en) aqui no site do Archipelago para aprender mais.
+
+### Onde eu consigo o YAML?
+Você pode usar a [página de configurações do jogador para Hollow Knight](/games/Hollow%20Knight/player-options) aqui no site do Archipelago 
+para gerar o YAML usando a interface gráfica.
+
+### Entrando numa partida de Archipelago no Hollow Knight
+1. Começe o jogo depois de instalar todos os mods necessários.
+2. Crie um **novo jogo salvo.**
+3. Selecione o modo de jogo **Archipelago** do menu de seleção.
+4. Coloque as configurações corretas do seu servidor Archipelago.
+5. Aperte em **Começar**. O jogo vai travar por uns segundos enquanto ele coloca todos itens.
+6. O jogo vai te colocar imediatamente numa partida randomizada. 
+   * Se você está esperando uma contagem então espere ele cair antes de apertar começar.
+   * Ou clique em começar e pause o jogo enquanto estiver nele.
+   
+## Dicas e outros comandos
+Enquanto jogar um multiworld, você pode interagir com o servidor usando vários comandos listados no
+[Guia de comandos](/tutorial/Archipelago/commands/en). Você pode usar o cliente de texto do Archipelago para isso,
+que está incluido na ultima versão do [Archipelago software](https://github.com/ArchipelagoMW/Archipelago/releases/latest).

worlds/kdl3/Locations.py

@@ -1,940 +0,0 @@
-import typing
-from BaseClasses import Location, Region
-from .Names import LocationName
-
-if typing.TYPE_CHECKING:
-    from .Room import KDL3Room
-
-
-class KDL3Location(Location):
-    game: str = "Kirby's Dream Land 3"
-    room: typing.Optional["KDL3Room"] = None
-
-    def __init__(self, player: int, name: str, address: typing.Optional[int], parent: typing.Union[Region, None]):
-        super().__init__(player, name, address, parent)
-        if not address:
-            self.show_in_spoiler = False
-
-
-stage_locations = {
-    0x770001: LocationName.grass_land_1,
-    0x770002: LocationName.grass_land_2,
-    0x770003: LocationName.grass_land_3,
-    0x770004: LocationName.grass_land_4,
-    0x770005: LocationName.grass_land_5,
-    0x770006: LocationName.grass_land_6,
-    0x770007: LocationName.ripple_field_1,
-    0x770008: LocationName.ripple_field_2,
-    0x770009: LocationName.ripple_field_3,
-    0x77000A: LocationName.ripple_field_4,
-    0x77000B: LocationName.ripple_field_5,
-    0x77000C: LocationName.ripple_field_6,
-    0x77000D: LocationName.sand_canyon_1,
-    0x77000E: LocationName.sand_canyon_2,
-    0x77000F: LocationName.sand_canyon_3,
-    0x770010: LocationName.sand_canyon_4,
-    0x770011: LocationName.sand_canyon_5,
-    0x770012: LocationName.sand_canyon_6,
-    0x770013: LocationName.cloudy_park_1,
-    0x770014: LocationName.cloudy_park_2,
-    0x770015: LocationName.cloudy_park_3,
-    0x770016: LocationName.cloudy_park_4,
-    0x770017: LocationName.cloudy_park_5,
-    0x770018: LocationName.cloudy_park_6,
-    0x770019: LocationName.iceberg_1,
-    0x77001A: LocationName.iceberg_2,
-    0x77001B: LocationName.iceberg_3,
-    0x77001C: LocationName.iceberg_4,
-    0x77001D: LocationName.iceberg_5,
-    0x77001E: LocationName.iceberg_6,
-}
-
-heart_star_locations = {
-    0x770101: LocationName.grass_land_tulip,
-    0x770102: LocationName.grass_land_muchi,
-    0x770103: LocationName.grass_land_pitcherman,
-    0x770104: LocationName.grass_land_chao,
-    0x770105: LocationName.grass_land_mine,
-    0x770106: LocationName.grass_land_pierre,
-    0x770107: LocationName.ripple_field_kamuribana,
-    0x770108: LocationName.ripple_field_bakasa,
-    0x770109: LocationName.ripple_field_elieel,
-    0x77010A: LocationName.ripple_field_toad,
-    0x77010B: LocationName.ripple_field_mama_pitch,
-    0x77010C: LocationName.ripple_field_hb002,
-    0x77010D: LocationName.sand_canyon_mushrooms,
-    0x77010E: LocationName.sand_canyon_auntie,
-    0x77010F: LocationName.sand_canyon_caramello,
-    0x770110: LocationName.sand_canyon_hikari,
-    0x770111: LocationName.sand_canyon_nyupun,
-    0x770112: LocationName.sand_canyon_rob,
-    0x770113: LocationName.cloudy_park_hibanamodoki,
-    0x770114: LocationName.cloudy_park_piyokeko,
-    0x770115: LocationName.cloudy_park_mrball,
-    0x770116: LocationName.cloudy_park_mikarin,
-    0x770117: LocationName.cloudy_park_pick,
-    0x770118: LocationName.cloudy_park_hb007,
-    0x770119: LocationName.iceberg_kogoesou,
-    0x77011A: LocationName.iceberg_samus,
-    0x77011B: LocationName.iceberg_kawasaki,
-    0x77011C: LocationName.iceberg_name,
-    0x77011D: LocationName.iceberg_shiro,
-    0x77011E: LocationName.iceberg_angel,
-}
-
-boss_locations = {
-    0x770200: LocationName.grass_land_whispy,
-    0x770201: LocationName.ripple_field_acro,
-    0x770202: LocationName.sand_canyon_poncon,
-    0x770203: LocationName.cloudy_park_ado,
-    0x770204: LocationName.iceberg_dedede,
-}
-
-consumable_locations = {
-    0x770300: LocationName.grass_land_1_u1,
-    0x770301: LocationName.grass_land_1_m1,
-    0x770302: LocationName.grass_land_2_u1,
-    0x770303: LocationName.grass_land_3_u1,
-    0x770304: LocationName.grass_land_3_m1,
-    0x770305: LocationName.grass_land_4_m1,
-    0x770306: LocationName.grass_land_4_u1,
-    0x770307: LocationName.grass_land_4_m2,
-    0x770308: LocationName.grass_land_4_m3,
-    0x770309: LocationName.grass_land_6_u1,
-    0x77030A: LocationName.grass_land_6_u2,
-    0x77030B: LocationName.ripple_field_2_u1,
-    0x77030C: LocationName.ripple_field_2_m1,
-    0x77030D: LocationName.ripple_field_3_m1,
-    0x77030E: LocationName.ripple_field_3_u1,
-    0x77030F: LocationName.ripple_field_4_m2,
-    0x770310: LocationName.ripple_field_4_u1,
-    0x770311: LocationName.ripple_field_4_m1,
-    0x770312: LocationName.ripple_field_5_u1,
-    0x770313: LocationName.ripple_field_5_m2,
-    0x770314: LocationName.ripple_field_5_m1,
-    0x770315: LocationName.sand_canyon_1_u1,
-    0x770316: LocationName.sand_canyon_2_u1,
-    0x770317: LocationName.sand_canyon_2_m1,
-    0x770318: LocationName.sand_canyon_4_m1,
-    0x770319: LocationName.sand_canyon_4_u1,
-    0x77031A: LocationName.sand_canyon_4_m2,
-    0x77031B: LocationName.sand_canyon_5_u1,
-    0x77031C: LocationName.sand_canyon_5_u3,
-    0x77031D: LocationName.sand_canyon_5_m1,
-    0x77031E: LocationName.sand_canyon_5_u4,
-    0x77031F: LocationName.sand_canyon_5_u2,
-    0x770320: LocationName.cloudy_park_1_m1,
-    0x770321: LocationName.cloudy_park_1_u1,
-    0x770322: LocationName.cloudy_park_4_u1,
-    0x770323: LocationName.cloudy_park_4_m1,
-    0x770324: LocationName.cloudy_park_5_m1,
-    0x770325: LocationName.cloudy_park_6_u1,
-    0x770326: LocationName.iceberg_3_m1,
-    0x770327: LocationName.iceberg_5_u1,
-    0x770328: LocationName.iceberg_5_u2,
-    0x770329: LocationName.iceberg_5_u3,
-    0x77032A: LocationName.iceberg_6_m1,
-    0x77032B: LocationName.iceberg_6_u1,
-}
-
-level_consumables = {
-    1: [0, 1],
-    2: [2],
-    3: [3, 4],
-    4: [5, 6, 7, 8],
-    6: [9, 10],
-    8: [11, 12],
-    9: [13, 14],
-    10: [15, 16, 17],
-    11: [18, 19, 20],
-    13: [21],
-    14: [22, 23],
-    16: [24, 25, 26],
-    17: [27, 28, 29, 30, 31],
-    19: [32, 33],
-    22: [34, 35],
-    23: [36],
-    24: [37],
-    27: [38],
-    29: [39, 40, 41],
-    30: [42, 43],
-}
-
-star_locations = {
-    0x770401: LocationName.grass_land_1_s1,
-    0x770402: LocationName.grass_land_1_s2,
-    0x770403: LocationName.grass_land_1_s3,
-    0x770404: LocationName.grass_land_1_s4,
-    0x770405: LocationName.grass_land_1_s5,
-    0x770406: LocationName.grass_land_1_s6,
-    0x770407: LocationName.grass_land_1_s7,
-    0x770408: LocationName.grass_land_1_s8,
-    0x770409: LocationName.grass_land_1_s9,
-    0x77040a: LocationName.grass_land_1_s10,
-    0x77040b: LocationName.grass_land_1_s11,
-    0x77040c: LocationName.grass_land_1_s12,
-    0x77040d: LocationName.grass_land_1_s13,
-    0x77040e: LocationName.grass_land_1_s14,
-    0x77040f: LocationName.grass_land_1_s15,
-    0x770410: LocationName.grass_land_1_s16,
-    0x770411: LocationName.grass_land_1_s17,
-    0x770412: LocationName.grass_land_1_s18,
-    0x770413: LocationName.grass_land_1_s19,
-    0x770414: LocationName.grass_land_1_s20,
-    0x770415: LocationName.grass_land_1_s21,
-    0x770416: LocationName.grass_land_1_s22,
-    0x770417: LocationName.grass_land_1_s23,
-    0x770418: LocationName.grass_land_2_s1,
-    0x770419: LocationName.grass_land_2_s2,
-    0x77041a: LocationName.grass_land_2_s3,
-    0x77041b: LocationName.grass_land_2_s4,
-    0x77041c: LocationName.grass_land_2_s5,
-    0x77041d: LocationName.grass_land_2_s6,
-    0x77041e: LocationName.grass_land_2_s7,
-    0x77041f: LocationName.grass_land_2_s8,
-    0x770420: LocationName.grass_land_2_s9,
-    0x770421: LocationName.grass_land_2_s10,
-    0x770422: LocationName.grass_land_2_s11,
-    0x770423: LocationName.grass_land_2_s12,
-    0x770424: LocationName.grass_land_2_s13,
-    0x770425: LocationName.grass_land_2_s14,
-    0x770426: LocationName.grass_land_2_s15,
-    0x770427: LocationName.grass_land_2_s16,
-    0x770428: LocationName.grass_land_2_s17,
-    0x770429: LocationName.grass_land_2_s18,
-    0x77042a: LocationName.grass_land_2_s19,
-    0x77042b: LocationName.grass_land_2_s20,
-    0x77042c: LocationName.grass_land_2_s21,
-    0x77042d: LocationName.grass_land_3_s1,
-    0x77042e: LocationName.grass_land_3_s2,
-    0x77042f: LocationName.grass_land_3_s3,
-    0x770430: LocationName.grass_land_3_s4,
-    0x770431: LocationName.grass_land_3_s5,
-    0x770432: LocationName.grass_land_3_s6,
-    0x770433: LocationName.grass_land_3_s7,
-    0x770434: LocationName.grass_land_3_s8,
-    0x770435: LocationName.grass_land_3_s9,
-    0x770436: LocationName.grass_land_3_s10,
-    0x770437: LocationName.grass_land_3_s11,
-    0x770438: LocationName.grass_land_3_s12,
-    0x770439: LocationName.grass_land_3_s13,
-    0x77043a: LocationName.grass_land_3_s14,
-    0x77043b: LocationName.grass_land_3_s15,
-    0x77043c: LocationName.grass_land_3_s16,
-    0x77043d: LocationName.grass_land_3_s17,
-    0x77043e: LocationName.grass_land_3_s18,
-    0x77043f: LocationName.grass_land_3_s19,
-    0x770440: LocationName.grass_land_3_s20,
-    0x770441: LocationName.grass_land_3_s21,
-    0x770442: LocationName.grass_land_3_s22,
-    0x770443: LocationName.grass_land_3_s23,
-    0x770444: LocationName.grass_land_3_s24,
-    0x770445: LocationName.grass_land_3_s25,
-    0x770446: LocationName.grass_land_3_s26,
-    0x770447: LocationName.grass_land_3_s27,
-    0x770448: LocationName.grass_land_3_s28,
-    0x770449: LocationName.grass_land_3_s29,
-    0x77044a: LocationName.grass_land_3_s30,
-    0x77044b: LocationName.grass_land_3_s31,
-    0x77044c: LocationName.grass_land_4_s1,
-    0x77044d: LocationName.grass_land_4_s2,
-    0x77044e: LocationName.grass_land_4_s3,
-    0x77044f: LocationName.grass_land_4_s4,
-    0x770450: LocationName.grass_land_4_s5,
-    0x770451: LocationName.grass_land_4_s6,
-    0x770452: LocationName.grass_land_4_s7,
-    0x770453: LocationName.grass_land_4_s8,
-    0x770454: LocationName.grass_land_4_s9,
-    0x770455: LocationName.grass_land_4_s10,
-    0x770456: LocationName.grass_land_4_s11,
-    0x770457: LocationName.grass_land_4_s12,
-    0x770458: LocationName.grass_land_4_s13,
-    0x770459: LocationName.grass_land_4_s14,
-    0x77045a: LocationName.grass_land_4_s15,
-    0x77045b: LocationName.grass_land_4_s16,
-    0x77045c: LocationName.grass_land_4_s17,
-    0x77045d: LocationName.grass_land_4_s18,
-    0x77045e: LocationName.grass_land_4_s19,
-    0x77045f: LocationName.grass_land_4_s20,
-    0x770460: LocationName.grass_land_4_s21,
-    0x770461: LocationName.grass_land_4_s22,
-    0x770462: LocationName.grass_land_4_s23,
-    0x770463: LocationName.grass_land_4_s24,
-    0x770464: LocationName.grass_land_4_s25,
-    0x770465: LocationName.grass_land_4_s26,
-    0x770466: LocationName.grass_land_4_s27,
-    0x770467: LocationName.grass_land_4_s28,
-    0x770468: LocationName.grass_land_4_s29,
-    0x770469: LocationName.grass_land_4_s30,
-    0x77046a: LocationName.grass_land_4_s31,
-    0x77046b: LocationName.grass_land_4_s32,
-    0x77046c: LocationName.grass_land_4_s33,
-    0x77046d: LocationName.grass_land_4_s34,
-    0x77046e: LocationName.grass_land_4_s35,
-    0x77046f: LocationName.grass_land_4_s36,
-    0x770470: LocationName.grass_land_4_s37,
-    0x770471: LocationName.grass_land_5_s1,
-    0x770472: LocationName.grass_land_5_s2,
-    0x770473: LocationName.grass_land_5_s3,
-    0x770474: LocationName.grass_land_5_s4,
-    0x770475: LocationName.grass_land_5_s5,
-    0x770476: LocationName.grass_land_5_s6,
-    0x770477: LocationName.grass_land_5_s7,
-    0x770478: LocationName.grass_land_5_s8,
-    0x770479: LocationName.grass_land_5_s9,
-    0x77047a: LocationName.grass_land_5_s10,
-    0x77047b: LocationName.grass_land_5_s11,
-    0x77047c: LocationName.grass_land_5_s12,
-    0x77047d: LocationName.grass_land_5_s13,
-    0x77047e: LocationName.grass_land_5_s14,
-    0x77047f: LocationName.grass_land_5_s15,
-    0x770480: LocationName.grass_land_5_s16,
-    0x770481: LocationName.grass_land_5_s17,
-    0x770482: LocationName.grass_land_5_s18,
-    0x770483: LocationName.grass_land_5_s19,
-    0x770484: LocationName.grass_land_5_s20,
-    0x770485: LocationName.grass_land_5_s21,
-    0x770486: LocationName.grass_land_5_s22,
-    0x770487: LocationName.grass_land_5_s23,
-    0x770488: LocationName.grass_land_5_s24,
-    0x770489: LocationName.grass_land_5_s25,
-    0x77048a: LocationName.grass_land_5_s26,
-    0x77048b: LocationName.grass_land_5_s27,
-    0x77048c: LocationName.grass_land_5_s28,
-    0x77048d: LocationName.grass_land_5_s29,
-    0x77048e: LocationName.grass_land_6_s1,
-    0x77048f: LocationName.grass_land_6_s2,
-    0x770490: LocationName.grass_land_6_s3,
-    0x770491: LocationName.grass_land_6_s4,
-    0x770492: LocationName.grass_land_6_s5,
-    0x770493: LocationName.grass_land_6_s6,
-    0x770494: LocationName.grass_land_6_s7,
-    0x770495: LocationName.grass_land_6_s8,
-    0x770496: LocationName.grass_land_6_s9,
-    0x770497: LocationName.grass_land_6_s10,
-    0x770498: LocationName.grass_land_6_s11,
-    0x770499: LocationName.grass_land_6_s12,
-    0x77049a: LocationName.grass_land_6_s13,
-    0x77049b: LocationName.grass_land_6_s14,
-    0x77049c: LocationName.grass_land_6_s15,
-    0x77049d: LocationName.grass_land_6_s16,
-    0x77049e: LocationName.grass_land_6_s17,
-    0x77049f: LocationName.grass_land_6_s18,
-    0x7704a0: LocationName.grass_land_6_s19,
-    0x7704a1: LocationName.grass_land_6_s20,
-    0x7704a2: LocationName.grass_land_6_s21,
-    0x7704a3: LocationName.grass_land_6_s22,
-    0x7704a4: LocationName.grass_land_6_s23,
-    0x7704a5: LocationName.grass_land_6_s24,
-    0x7704a6: LocationName.grass_land_6_s25,
-    0x7704a7: LocationName.grass_land_6_s26,
-    0x7704a8: LocationName.grass_land_6_s27,
-    0x7704a9: LocationName.grass_land_6_s28,
-    0x7704aa: LocationName.grass_land_6_s29,
-    0x7704ab: LocationName.ripple_field_1_s1,
-    0x7704ac: LocationName.ripple_field_1_s2,
-    0x7704ad: LocationName.ripple_field_1_s3,
-    0x7704ae: LocationName.ripple_field_1_s4,
-    0x7704af: LocationName.ripple_field_1_s5,
-    0x7704b0: LocationName.ripple_field_1_s6,
-    0x7704b1: LocationName.ripple_field_1_s7,
-    0x7704b2: LocationName.ripple_field_1_s8,
-    0x7704b3: LocationName.ripple_field_1_s9,
-    0x7704b4: LocationName.ripple_field_1_s10,
-    0x7704b5: LocationName.ripple_field_1_s11,
-    0x7704b6: LocationName.ripple_field_1_s12,
-    0x7704b7: LocationName.ripple_field_1_s13,
-    0x7704b8: LocationName.ripple_field_1_s14,
-    0x7704b9: LocationName.ripple_field_1_s15,
-    0x7704ba: LocationName.ripple_field_1_s16,
-    0x7704bb: LocationName.ripple_field_1_s17,
-    0x7704bc: LocationName.ripple_field_1_s18,
-    0x7704bd: LocationName.ripple_field_1_s19,
-    0x7704be: LocationName.ripple_field_2_s1,
-    0x7704bf: LocationName.ripple_field_2_s2,
-    0x7704c0: LocationName.ripple_field_2_s3,
-    0x7704c1: LocationName.ripple_field_2_s4,
-    0x7704c2: LocationName.ripple_field_2_s5,
-    0x7704c3: LocationName.ripple_field_2_s6,
-    0x7704c4: LocationName.ripple_field_2_s7,
-    0x7704c5: LocationName.ripple_field_2_s8,
-    0x7704c6: LocationName.ripple_field_2_s9,
-    0x7704c7: LocationName.ripple_field_2_s10,
-    0x7704c8: LocationName.ripple_field_2_s11,
-    0x7704c9: LocationName.ripple_field_2_s12,
-    0x7704ca: LocationName.ripple_field_2_s13,
-    0x7704cb: LocationName.ripple_field_2_s14,
-    0x7704cc: LocationName.ripple_field_2_s15,
-    0x7704cd: LocationName.ripple_field_2_s16,
-    0x7704ce: LocationName.ripple_field_2_s17,
-    0x7704cf: LocationName.ripple_field_3_s1,
-    0x7704d0: LocationName.ripple_field_3_s2,
-    0x7704d1: LocationName.ripple_field_3_s3,
-    0x7704d2: LocationName.ripple_field_3_s4,
-    0x7704d3: LocationName.ripple_field_3_s5,
-    0x7704d4: LocationName.ripple_field_3_s6,
-    0x7704d5: LocationName.ripple_field_3_s7,
-    0x7704d6: LocationName.ripple_field_3_s8,
-    0x7704d7: LocationName.ripple_field_3_s9,
-    0x7704d8: LocationName.ripple_field_3_s10,
-    0x7704d9: LocationName.ripple_field_3_s11,
-    0x7704da: LocationName.ripple_field_3_s12,
-    0x7704db: LocationName.ripple_field_3_s13,
-    0x7704dc: LocationName.ripple_field_3_s14,
-    0x7704dd: LocationName.ripple_field_3_s15,
-    0x7704de: LocationName.ripple_field_3_s16,
-    0x7704df: LocationName.ripple_field_3_s17,
-    0x7704e0: LocationName.ripple_field_3_s18,
-    0x7704e1: LocationName.ripple_field_3_s19,
-    0x7704e2: LocationName.ripple_field_3_s20,
-    0x7704e3: LocationName.ripple_field_3_s21,
-    0x7704e4: LocationName.ripple_field_4_s1,
-    0x7704e5: LocationName.ripple_field_4_s2,
-    0x7704e6: LocationName.ripple_field_4_s3,
-    0x7704e7: LocationName.ripple_field_4_s4,
-    0x7704e8: LocationName.ripple_field_4_s5,
-    0x7704e9: LocationName.ripple_field_4_s6,
-    0x7704ea: LocationName.ripple_field_4_s7,
-    0x7704eb: LocationName.ripple_field_4_s8,
-    0x7704ec: LocationName.ripple_field_4_s9,
-    0x7704ed: LocationName.ripple_field_4_s10,
-    0x7704ee: LocationName.ripple_field_4_s11,
-    0x7704ef: LocationName.ripple_field_4_s12,
-    0x7704f0: LocationName.ripple_field_4_s13,
-    0x7704f1: LocationName.ripple_field_4_s14,
-    0x7704f2: LocationName.ripple_field_4_s15,
-    0x7704f3: LocationName.ripple_field_4_s16,
-    0x7704f4: LocationName.ripple_field_4_s17,
-    0x7704f5: LocationName.ripple_field_4_s18,
-    0x7704f6: LocationName.ripple_field_4_s19,
-    0x7704f7: LocationName.ripple_field_4_s20,
-    0x7704f8: LocationName.ripple_field_4_s21,
-    0x7704f9: LocationName.ripple_field_4_s22,
-    0x7704fa: LocationName.ripple_field_4_s23,
-    0x7704fb: LocationName.ripple_field_4_s24,
-    0x7704fc: LocationName.ripple_field_4_s25,
-    0x7704fd: LocationName.ripple_field_4_s26,
-    0x7704fe: LocationName.ripple_field_4_s27,
-    0x7704ff: LocationName.ripple_field_4_s28,
-    0x770500: LocationName.ripple_field_4_s29,
-    0x770501: LocationName.ripple_field_4_s30,
-    0x770502: LocationName.ripple_field_4_s31,
-    0x770503: LocationName.ripple_field_4_s32,
-    0x770504: LocationName.ripple_field_4_s33,
-    0x770505: LocationName.ripple_field_4_s34,
-    0x770506: LocationName.ripple_field_4_s35,
-    0x770507: LocationName.ripple_field_4_s36,
-    0x770508: LocationName.ripple_field_4_s37,
-    0x770509: LocationName.ripple_field_4_s38,
-    0x77050a: LocationName.ripple_field_4_s39,
-    0x77050b: LocationName.ripple_field_4_s40,
-    0x77050c: LocationName.ripple_field_4_s41,
-    0x77050d: LocationName.ripple_field_4_s42,
-    0x77050e: LocationName.ripple_field_4_s43,
-    0x77050f: LocationName.ripple_field_4_s44,
-    0x770510: LocationName.ripple_field_4_s45,
-    0x770511: LocationName.ripple_field_4_s46,
-    0x770512: LocationName.ripple_field_4_s47,
-    0x770513: LocationName.ripple_field_4_s48,
-    0x770514: LocationName.ripple_field_4_s49,
-    0x770515: LocationName.ripple_field_4_s50,
-    0x770516: LocationName.ripple_field_4_s51,
-    0x770517: LocationName.ripple_field_5_s1,
-    0x770518: LocationName.ripple_field_5_s2,
-    0x770519: LocationName.ripple_field_5_s3,
-    0x77051a: LocationName.ripple_field_5_s4,
-    0x77051b: LocationName.ripple_field_5_s5,
-    0x77051c: LocationName.ripple_field_5_s6,
-    0x77051d: LocationName.ripple_field_5_s7,
-    0x77051e: LocationName.ripple_field_5_s8,
-    0x77051f: LocationName.ripple_field_5_s9,
-    0x770520: LocationName.ripple_field_5_s10,
-    0x770521: LocationName.ripple_field_5_s11,
-    0x770522: LocationName.ripple_field_5_s12,
-    0x770523: LocationName.ripple_field_5_s13,
-    0x770524: LocationName.ripple_field_5_s14,
-    0x770525: LocationName.ripple_field_5_s15,
-    0x770526: LocationName.ripple_field_5_s16,
-    0x770527: LocationName.ripple_field_5_s17,
-    0x770528: LocationName.ripple_field_5_s18,
-    0x770529: LocationName.ripple_field_5_s19,
-    0x77052a: LocationName.ripple_field_5_s20,
-    0x77052b: LocationName.ripple_field_5_s21,
-    0x77052c: LocationName.ripple_field_5_s22,
-    0x77052d: LocationName.ripple_field_5_s23,
-    0x77052e: LocationName.ripple_field_5_s24,
-    0x77052f: LocationName.ripple_field_5_s25,
-    0x770530: LocationName.ripple_field_5_s26,
-    0x770531: LocationName.ripple_field_5_s27,
-    0x770532: LocationName.ripple_field_5_s28,
-    0x770533: LocationName.ripple_field_5_s29,
-    0x770534: LocationName.ripple_field_5_s30,
-    0x770535: LocationName.ripple_field_5_s31,
-    0x770536: LocationName.ripple_field_5_s32,
-    0x770537: LocationName.ripple_field_5_s33,
-    0x770538: LocationName.ripple_field_5_s34,
-    0x770539: LocationName.ripple_field_5_s35,
-    0x77053a: LocationName.ripple_field_5_s36,
-    0x77053b: LocationName.ripple_field_5_s37,
-    0x77053c: LocationName.ripple_field_5_s38,
-    0x77053d: LocationName.ripple_field_5_s39,
-    0x77053e: LocationName.ripple_field_5_s40,
-    0x77053f: LocationName.ripple_field_5_s41,
-    0x770540: LocationName.ripple_field_5_s42,
-    0x770541: LocationName.ripple_field_5_s43,
-    0x770542: LocationName.ripple_field_5_s44,
-    0x770543: LocationName.ripple_field_5_s45,
-    0x770544: LocationName.ripple_field_5_s46,
-    0x770545: LocationName.ripple_field_5_s47,
-    0x770546: LocationName.ripple_field_5_s48,
-    0x770547: LocationName.ripple_field_5_s49,
-    0x770548: LocationName.ripple_field_5_s50,
-    0x770549: LocationName.ripple_field_5_s51,
-    0x77054a: LocationName.ripple_field_6_s1,
-    0x77054b: LocationName.ripple_field_6_s2,
-    0x77054c: LocationName.ripple_field_6_s3,
-    0x77054d: LocationName.ripple_field_6_s4,
-    0x77054e: LocationName.ripple_field_6_s5,
-    0x77054f: LocationName.ripple_field_6_s6,
-    0x770550: LocationName.ripple_field_6_s7,
-    0x770551: LocationName.ripple_field_6_s8,
-    0x770552: LocationName.ripple_field_6_s9,
-    0x770553: LocationName.ripple_field_6_s10,
-    0x770554: LocationName.ripple_field_6_s11,
-    0x770555: LocationName.ripple_field_6_s12,
-    0x770556: LocationName.ripple_field_6_s13,
-    0x770557: LocationName.ripple_field_6_s14,
-    0x770558: LocationName.ripple_field_6_s15,
-    0x770559: LocationName.ripple_field_6_s16,
-    0x77055a: LocationName.ripple_field_6_s17,
-    0x77055b: LocationName.ripple_field_6_s18,
-    0x77055c: LocationName.ripple_field_6_s19,
-    0x77055d: LocationName.ripple_field_6_s20,
-    0x77055e: LocationName.ripple_field_6_s21,
-    0x77055f: LocationName.ripple_field_6_s22,
-    0x770560: LocationName.ripple_field_6_s23,
-    0x770561: LocationName.sand_canyon_1_s1,
-    0x770562: LocationName.sand_canyon_1_s2,
-    0x770563: LocationName.sand_canyon_1_s3,
-    0x770564: LocationName.sand_canyon_1_s4,
-    0x770565: LocationName.sand_canyon_1_s5,
-    0x770566: LocationName.sand_canyon_1_s6,
-    0x770567: LocationName.sand_canyon_1_s7,
-    0x770568: LocationName.sand_canyon_1_s8,
-    0x770569: LocationName.sand_canyon_1_s9,
-    0x77056a: LocationName.sand_canyon_1_s10,
-    0x77056b: LocationName.sand_canyon_1_s11,
-    0x77056c: LocationName.sand_canyon_1_s12,
-    0x77056d: LocationName.sand_canyon_1_s13,
-    0x77056e: LocationName.sand_canyon_1_s14,
-    0x77056f: LocationName.sand_canyon_1_s15,
-    0x770570: LocationName.sand_canyon_1_s16,
-    0x770571: LocationName.sand_canyon_1_s17,
-    0x770572: LocationName.sand_canyon_1_s18,
-    0x770573: LocationName.sand_canyon_1_s19,
-    0x770574: LocationName.sand_canyon_1_s20,
-    0x770575: LocationName.sand_canyon_1_s21,
-    0x770576: LocationName.sand_canyon_1_s22,
-    0x770577: LocationName.sand_canyon_2_s1,
-    0x770578: LocationName.sand_canyon_2_s2,
-    0x770579: LocationName.sand_canyon_2_s3,
-    0x77057a: LocationName.sand_canyon_2_s4,
-    0x77057b: LocationName.sand_canyon_2_s5,
-    0x77057c: LocationName.sand_canyon_2_s6,
-    0x77057d: LocationName.sand_canyon_2_s7,
-    0x77057e: LocationName.sand_canyon_2_s8,
-    0x77057f: LocationName.sand_canyon_2_s9,
-    0x770580: LocationName.sand_canyon_2_s10,
-    0x770581: LocationName.sand_canyon_2_s11,
-    0x770582: LocationName.sand_canyon_2_s12,
-    0x770583: LocationName.sand_canyon_2_s13,
-    0x770584: LocationName.sand_canyon_2_s14,
-    0x770585: LocationName.sand_canyon_2_s15,
-    0x770586: LocationName.sand_canyon_2_s16,
-    0x770587: LocationName.sand_canyon_2_s17,
-    0x770588: LocationName.sand_canyon_2_s18,
-    0x770589: LocationName.sand_canyon_2_s19,
-    0x77058a: LocationName.sand_canyon_2_s20,
-    0x77058b: LocationName.sand_canyon_2_s21,
-    0x77058c: LocationName.sand_canyon_2_s22,
-    0x77058d: LocationName.sand_canyon_2_s23,
-    0x77058e: LocationName.sand_canyon_2_s24,
-    0x77058f: LocationName.sand_canyon_2_s25,
-    0x770590: LocationName.sand_canyon_2_s26,
-    0x770591: LocationName.sand_canyon_2_s27,
-    0x770592: LocationName.sand_canyon_2_s28,
-    0x770593: LocationName.sand_canyon_2_s29,
-    0x770594: LocationName.sand_canyon_2_s30,
-    0x770595: LocationName.sand_canyon_2_s31,
-    0x770596: LocationName.sand_canyon_2_s32,
-    0x770597: LocationName.sand_canyon_2_s33,
-    0x770598: LocationName.sand_canyon_2_s34,
-    0x770599: LocationName.sand_canyon_2_s35,
-    0x77059a: LocationName.sand_canyon_2_s36,
-    0x77059b: LocationName.sand_canyon_2_s37,
-    0x77059c: LocationName.sand_canyon_2_s38,
-    0x77059d: LocationName.sand_canyon_2_s39,
-    0x77059e: LocationName.sand_canyon_2_s40,
-    0x77059f: LocationName.sand_canyon_2_s41,
-    0x7705a0: LocationName.sand_canyon_2_s42,
-    0x7705a1: LocationName.sand_canyon_2_s43,
-    0x7705a2: LocationName.sand_canyon_2_s44,
-    0x7705a3: LocationName.sand_canyon_2_s45,
-    0x7705a4: LocationName.sand_canyon_2_s46,
-    0x7705a5: LocationName.sand_canyon_2_s47,
-    0x7705a6: LocationName.sand_canyon_2_s48,
-    0x7705a7: LocationName.sand_canyon_3_s1,
-    0x7705a8: LocationName.sand_canyon_3_s2,
-    0x7705a9: LocationName.sand_canyon_3_s3,
-    0x7705aa: LocationName.sand_canyon_3_s4,
-    0x7705ab: LocationName.sand_canyon_3_s5,
-    0x7705ac: LocationName.sand_canyon_3_s6,
-    0x7705ad: LocationName.sand_canyon_3_s7,
-    0x7705ae: LocationName.sand_canyon_3_s8,
-    0x7705af: LocationName.sand_canyon_3_s9,
-    0x7705b0: LocationName.sand_canyon_3_s10,
-    0x7705b1: LocationName.sand_canyon_4_s1,
-    0x7705b2: LocationName.sand_canyon_4_s2,
-    0x7705b3: LocationName.sand_canyon_4_s3,
-    0x7705b4: LocationName.sand_canyon_4_s4,
-    0x7705b5: LocationName.sand_canyon_4_s5,
-    0x7705b6: LocationName.sand_canyon_4_s6,
-    0x7705b7: LocationName.sand_canyon_4_s7,
-    0x7705b8: LocationName.sand_canyon_4_s8,
-    0x7705b9: LocationName.sand_canyon_4_s9,
-    0x7705ba: LocationName.sand_canyon_4_s10,
-    0x7705bb: LocationName.sand_canyon_4_s11,
-    0x7705bc: LocationName.sand_canyon_4_s12,
-    0x7705bd: LocationName.sand_canyon_4_s13,
-    0x7705be: LocationName.sand_canyon_4_s14,
-    0x7705bf: LocationName.sand_canyon_4_s15,
-    0x7705c0: LocationName.sand_canyon_4_s16,
-    0x7705c1: LocationName.sand_canyon_4_s17,
-    0x7705c2: LocationName.sand_canyon_4_s18,
-    0x7705c3: LocationName.sand_canyon_4_s19,
-    0x7705c4: LocationName.sand_canyon_4_s20,
-    0x7705c5: LocationName.sand_canyon_4_s21,
-    0x7705c6: LocationName.sand_canyon_4_s22,
-    0x7705c7: LocationName.sand_canyon_4_s23,
-    0x7705c8: LocationName.sand_canyon_5_s1,
-    0x7705c9: LocationName.sand_canyon_5_s2,
-    0x7705ca: LocationName.sand_canyon_5_s3,
-    0x7705cb: LocationName.sand_canyon_5_s4,
-    0x7705cc: LocationName.sand_canyon_5_s5,
-    0x7705cd: LocationName.sand_canyon_5_s6,
-    0x7705ce: LocationName.sand_canyon_5_s7,
-    0x7705cf: LocationName.sand_canyon_5_s8,
-    0x7705d0: LocationName.sand_canyon_5_s9,
-    0x7705d1: LocationName.sand_canyon_5_s10,
-    0x7705d2: LocationName.sand_canyon_5_s11,
-    0x7705d3: LocationName.sand_canyon_5_s12,
-    0x7705d4: LocationName.sand_canyon_5_s13,
-    0x7705d5: LocationName.sand_canyon_5_s14,
-    0x7705d6: LocationName.sand_canyon_5_s15,
-    0x7705d7: LocationName.sand_canyon_5_s16,
-    0x7705d8: LocationName.sand_canyon_5_s17,
-    0x7705d9: LocationName.sand_canyon_5_s18,
-    0x7705da: LocationName.sand_canyon_5_s19,
-    0x7705db: LocationName.sand_canyon_5_s20,
-    0x7705dc: LocationName.sand_canyon_5_s21,
-    0x7705dd: LocationName.sand_canyon_5_s22,
-    0x7705de: LocationName.sand_canyon_5_s23,
-    0x7705df: LocationName.sand_canyon_5_s24,
-    0x7705e0: LocationName.sand_canyon_5_s25,
-    0x7705e1: LocationName.sand_canyon_5_s26,
-    0x7705e2: LocationName.sand_canyon_5_s27,
-    0x7705e3: LocationName.sand_canyon_5_s28,
-    0x7705e4: LocationName.sand_canyon_5_s29,
-    0x7705e5: LocationName.sand_canyon_5_s30,
-    0x7705e6: LocationName.sand_canyon_5_s31,
-    0x7705e7: LocationName.sand_canyon_5_s32,
-    0x7705e8: LocationName.sand_canyon_5_s33,
-    0x7705e9: LocationName.sand_canyon_5_s34,
-    0x7705ea: LocationName.sand_canyon_5_s35,
-    0x7705eb: LocationName.sand_canyon_5_s36,
-    0x7705ec: LocationName.sand_canyon_5_s37,
-    0x7705ed: LocationName.sand_canyon_5_s38,
-    0x7705ee: LocationName.sand_canyon_5_s39,
-    0x7705ef: LocationName.sand_canyon_5_s40,
-    0x7705f0: LocationName.cloudy_park_1_s1,
-    0x7705f1: LocationName.cloudy_park_1_s2,
-    0x7705f2: LocationName.cloudy_park_1_s3,
-    0x7705f3: LocationName.cloudy_park_1_s4,
-    0x7705f4: LocationName.cloudy_park_1_s5,
-    0x7705f5: LocationName.cloudy_park_1_s6,
-    0x7705f6: LocationName.cloudy_park_1_s7,
-    0x7705f7: LocationName.cloudy_park_1_s8,
-    0x7705f8: LocationName.cloudy_park_1_s9,
-    0x7705f9: LocationName.cloudy_park_1_s10,
-    0x7705fa: LocationName.cloudy_park_1_s11,
-    0x7705fb: LocationName.cloudy_park_1_s12,
-    0x7705fc: LocationName.cloudy_park_1_s13,
-    0x7705fd: LocationName.cloudy_park_1_s14,
-    0x7705fe: LocationName.cloudy_park_1_s15,
-    0x7705ff: LocationName.cloudy_park_1_s16,
-    0x770600: LocationName.cloudy_park_1_s17,
-    0x770601: LocationName.cloudy_park_1_s18,
-    0x770602: LocationName.cloudy_park_1_s19,
-    0x770603: LocationName.cloudy_park_1_s20,
-    0x770604: LocationName.cloudy_park_1_s21,
-    0x770605: LocationName.cloudy_park_1_s22,
-    0x770606: LocationName.cloudy_park_1_s23,
-    0x770607: LocationName.cloudy_park_2_s1,
-    0x770608: LocationName.cloudy_park_2_s2,
-    0x770609: LocationName.cloudy_park_2_s3,
-    0x77060a: LocationName.cloudy_park_2_s4,
-    0x77060b: LocationName.cloudy_park_2_s5,
-    0x77060c: LocationName.cloudy_park_2_s6,
-    0x77060d: LocationName.cloudy_park_2_s7,
-    0x77060e: LocationName.cloudy_park_2_s8,
-    0x77060f: LocationName.cloudy_park_2_s9,
-    0x770610: LocationName.cloudy_park_2_s10,
-    0x770611: LocationName.cloudy_park_2_s11,
-    0x770612: LocationName.cloudy_park_2_s12,
-    0x770613: LocationName.cloudy_park_2_s13,
-    0x770614: LocationName.cloudy_park_2_s14,
-    0x770615: LocationName.cloudy_park_2_s15,
-    0x770616: LocationName.cloudy_park_2_s16,
-    0x770617: LocationName.cloudy_park_2_s17,
-    0x770618: LocationName.cloudy_park_2_s18,
-    0x770619: LocationName.cloudy_park_2_s19,
-    0x77061a: LocationName.cloudy_park_2_s20,
-    0x77061b: LocationName.cloudy_park_2_s21,
-    0x77061c: LocationName.cloudy_park_2_s22,
-    0x77061d: LocationName.cloudy_park_2_s23,
-    0x77061e: LocationName.cloudy_park_2_s24,
-    0x77061f: LocationName.cloudy_park_2_s25,
-    0x770620: LocationName.cloudy_park_2_s26,
-    0x770621: LocationName.cloudy_park_2_s27,
-    0x770622: LocationName.cloudy_park_2_s28,
-    0x770623: LocationName.cloudy_park_2_s29,
-    0x770624: LocationName.cloudy_park_2_s30,
-    0x770625: LocationName.cloudy_park_2_s31,
-    0x770626: LocationName.cloudy_park_2_s32,
-    0x770627: LocationName.cloudy_park_2_s33,
-    0x770628: LocationName.cloudy_park_2_s34,
-    0x770629: LocationName.cloudy_park_2_s35,
-    0x77062a: LocationName.cloudy_park_2_s36,
-    0x77062b: LocationName.cloudy_park_2_s37,
-    0x77062c: LocationName.cloudy_park_2_s38,
-    0x77062d: LocationName.cloudy_park_2_s39,
-    0x77062e: LocationName.cloudy_park_2_s40,
-    0x77062f: LocationName.cloudy_park_2_s41,
-    0x770630: LocationName.cloudy_park_2_s42,
-    0x770631: LocationName.cloudy_park_2_s43,
-    0x770632: LocationName.cloudy_park_2_s44,
-    0x770633: LocationName.cloudy_park_2_s45,
-    0x770634: LocationName.cloudy_park_2_s46,
-    0x770635: LocationName.cloudy_park_2_s47,
-    0x770636: LocationName.cloudy_park_2_s48,
-    0x770637: LocationName.cloudy_park_2_s49,
-    0x770638: LocationName.cloudy_park_2_s50,
-    0x770639: LocationName.cloudy_park_2_s51,
-    0x77063a: LocationName.cloudy_park_2_s52,
-    0x77063b: LocationName.cloudy_park_2_s53,
-    0x77063c: LocationName.cloudy_park_2_s54,
-    0x77063d: LocationName.cloudy_park_3_s1,
-    0x77063e: LocationName.cloudy_park_3_s2,
-    0x77063f: LocationName.cloudy_park_3_s3,
-    0x770640: LocationName.cloudy_park_3_s4,
-    0x770641: LocationName.cloudy_park_3_s5,
-    0x770642: LocationName.cloudy_park_3_s6,
-    0x770643: LocationName.cloudy_park_3_s7,
-    0x770644: LocationName.cloudy_park_3_s8,
-    0x770645: LocationName.cloudy_park_3_s9,
-    0x770646: LocationName.cloudy_park_3_s10,
-    0x770647: LocationName.cloudy_park_3_s11,
-    0x770648: LocationName.cloudy_park_3_s12,
-    0x770649: LocationName.cloudy_park_3_s13,
-    0x77064a: LocationName.cloudy_park_3_s14,
-    0x77064b: LocationName.cloudy_park_3_s15,
-    0x77064c: LocationName.cloudy_park_3_s16,
-    0x77064d: LocationName.cloudy_park_3_s17,
-    0x77064e: LocationName.cloudy_park_3_s18,
-    0x77064f: LocationName.cloudy_park_3_s19,
-    0x770650: LocationName.cloudy_park_3_s20,
-    0x770651: LocationName.cloudy_park_3_s21,
-    0x770652: LocationName.cloudy_park_3_s22,
-    0x770653: LocationName.cloudy_park_4_s1,
-    0x770654: LocationName.cloudy_park_4_s2,
-    0x770655: LocationName.cloudy_park_4_s3,
-    0x770656: LocationName.cloudy_park_4_s4,
-    0x770657: LocationName.cloudy_park_4_s5,
-    0x770658: LocationName.cloudy_park_4_s6,
-    0x770659: LocationName.cloudy_park_4_s7,
-    0x77065a: LocationName.cloudy_park_4_s8,
-    0x77065b: LocationName.cloudy_park_4_s9,
-    0x77065c: LocationName.cloudy_park_4_s10,
-    0x77065d: LocationName.cloudy_park_4_s11,
-    0x77065e: LocationName.cloudy_park_4_s12,
-    0x77065f: LocationName.cloudy_park_4_s13,
-    0x770660: LocationName.cloudy_park_4_s14,
-    0x770661: LocationName.cloudy_park_4_s15,
-    0x770662: LocationName.cloudy_park_4_s16,
-    0x770663: LocationName.cloudy_park_4_s17,
-    0x770664: LocationName.cloudy_park_4_s18,
-    0x770665: LocationName.cloudy_park_4_s19,
-    0x770666: LocationName.cloudy_park_4_s20,
-    0x770667: LocationName.cloudy_park_4_s21,
-    0x770668: LocationName.cloudy_park_4_s22,
-    0x770669: LocationName.cloudy_park_4_s23,
-    0x77066a: LocationName.cloudy_park_4_s24,
-    0x77066b: LocationName.cloudy_park_4_s25,
-    0x77066c: LocationName.cloudy_park_4_s26,
-    0x77066d: LocationName.cloudy_park_4_s27,
-    0x77066e: LocationName.cloudy_park_4_s28,
-    0x77066f: LocationName.cloudy_park_4_s29,
-    0x770670: LocationName.cloudy_park_4_s30,
-    0x770671: LocationName.cloudy_park_4_s31,
-    0x770672: LocationName.cloudy_park_4_s32,
-    0x770673: LocationName.cloudy_park_4_s33,
-    0x770674: LocationName.cloudy_park_4_s34,
-    0x770675: LocationName.cloudy_park_4_s35,
-    0x770676: LocationName.cloudy_park_4_s36,
-    0x770677: LocationName.cloudy_park_4_s37,
-    0x770678: LocationName.cloudy_park_4_s38,
-    0x770679: LocationName.cloudy_park_4_s39,
-    0x77067a: LocationName.cloudy_park_4_s40,
-    0x77067b: LocationName.cloudy_park_4_s41,
-    0x77067c: LocationName.cloudy_park_4_s42,
-    0x77067d: LocationName.cloudy_park_4_s43,
-    0x77067e: LocationName.cloudy_park_4_s44,
-    0x77067f: LocationName.cloudy_park_4_s45,
-    0x770680: LocationName.cloudy_park_4_s46,
-    0x770681: LocationName.cloudy_park_4_s47,
-    0x770682: LocationName.cloudy_park_4_s48,
-    0x770683: LocationName.cloudy_park_4_s49,
-    0x770684: LocationName.cloudy_park_4_s50,
-    0x770685: LocationName.cloudy_park_5_s1,
-    0x770686: LocationName.cloudy_park_5_s2,
-    0x770687: LocationName.cloudy_park_5_s3,
-    0x770688: LocationName.cloudy_park_5_s4,
-    0x770689: LocationName.cloudy_park_5_s5,
-    0x77068a: LocationName.cloudy_park_5_s6,
-    0x77068b: LocationName.cloudy_park_6_s1,
-    0x77068c: LocationName.cloudy_park_6_s2,
-    0x77068d: LocationName.cloudy_park_6_s3,
-    0x77068e: LocationName.cloudy_park_6_s4,
-    0x77068f: LocationName.cloudy_park_6_s5,
-    0x770690: LocationName.cloudy_park_6_s6,
-    0x770691: LocationName.cloudy_park_6_s7,
-    0x770692: LocationName.cloudy_park_6_s8,
-    0x770693: LocationName.cloudy_park_6_s9,
-    0x770694: LocationName.cloudy_park_6_s10,
-    0x770695: LocationName.cloudy_park_6_s11,
-    0x770696: LocationName.cloudy_park_6_s12,
-    0x770697: LocationName.cloudy_park_6_s13,
-    0x770698: LocationName.cloudy_park_6_s14,
-    0x770699: LocationName.cloudy_park_6_s15,
-    0x77069a: LocationName.cloudy_park_6_s16,
-    0x77069b: LocationName.cloudy_park_6_s17,
-    0x77069c: LocationName.cloudy_park_6_s18,
-    0x77069d: LocationName.cloudy_park_6_s19,
-    0x77069e: LocationName.cloudy_park_6_s20,
-    0x77069f: LocationName.cloudy_park_6_s21,
-    0x7706a0: LocationName.cloudy_park_6_s22,
-    0x7706a1: LocationName.cloudy_park_6_s23,
-    0x7706a2: LocationName.cloudy_park_6_s24,
-    0x7706a3: LocationName.cloudy_park_6_s25,
-    0x7706a4: LocationName.cloudy_park_6_s26,
-    0x7706a5: LocationName.cloudy_park_6_s27,
-    0x7706a6: LocationName.cloudy_park_6_s28,
-    0x7706a7: LocationName.cloudy_park_6_s29,
-    0x7706a8: LocationName.cloudy_park_6_s30,
-    0x7706a9: LocationName.cloudy_park_6_s31,
-    0x7706aa: LocationName.cloudy_park_6_s32,
-    0x7706ab: LocationName.cloudy_park_6_s33,
-    0x7706ac: LocationName.iceberg_1_s1,
-    0x7706ad: LocationName.iceberg_1_s2,
-    0x7706ae: LocationName.iceberg_1_s3,
-    0x7706af: LocationName.iceberg_1_s4,
-    0x7706b0: LocationName.iceberg_1_s5,
-    0x7706b1: LocationName.iceberg_1_s6,
-    0x7706b2: LocationName.iceberg_2_s1,
-    0x7706b3: LocationName.iceberg_2_s2,
-    0x7706b4: LocationName.iceberg_2_s3,
-    0x7706b5: LocationName.iceberg_2_s4,
-    0x7706b6: LocationName.iceberg_2_s5,
-    0x7706b7: LocationName.iceberg_2_s6,
-    0x7706b8: LocationName.iceberg_2_s7,
-    0x7706b9: LocationName.iceberg_2_s8,
-    0x7706ba: LocationName.iceberg_2_s9,
-    0x7706bb: LocationName.iceberg_2_s10,
-    0x7706bc: LocationName.iceberg_2_s11,
-    0x7706bd: LocationName.iceberg_2_s12,
-    0x7706be: LocationName.iceberg_2_s13,
-    0x7706bf: LocationName.iceberg_2_s14,
-    0x7706c0: LocationName.iceberg_2_s15,
-    0x7706c1: LocationName.iceberg_2_s16,
-    0x7706c2: LocationName.iceberg_2_s17,
-    0x7706c3: LocationName.iceberg_2_s18,
-    0x7706c4: LocationName.iceberg_2_s19,
-    0x7706c5: LocationName.iceberg_3_s1,
-    0x7706c6: LocationName.iceberg_3_s2,
-    0x7706c7: LocationName.iceberg_3_s3,
-    0x7706c8: LocationName.iceberg_3_s4,
-    0x7706c9: LocationName.iceberg_3_s5,
-    0x7706ca: LocationName.iceberg_3_s6,
-    0x7706cb: LocationName.iceberg_3_s7,
-    0x7706cc: LocationName.iceberg_3_s8,
-    0x7706cd: LocationName.iceberg_3_s9,
-    0x7706ce: LocationName.iceberg_3_s10,
-    0x7706cf: LocationName.iceberg_3_s11,
-    0x7706d0: LocationName.iceberg_3_s12,
-    0x7706d1: LocationName.iceberg_3_s13,
-    0x7706d2: LocationName.iceberg_3_s14,
-    0x7706d3: LocationName.iceberg_3_s15,
-    0x7706d4: LocationName.iceberg_3_s16,
-    0x7706d5: LocationName.iceberg_3_s17,
-    0x7706d6: LocationName.iceberg_3_s18,
-    0x7706d7: LocationName.iceberg_3_s19,
-    0x7706d8: LocationName.iceberg_3_s20,
-    0x7706d9: LocationName.iceberg_3_s21,
-    0x7706da: LocationName.iceberg_4_s1,
-    0x7706db: LocationName.iceberg_4_s2,
-    0x7706dc: LocationName.iceberg_4_s3,
-    0x7706dd: LocationName.iceberg_5_s1,
-    0x7706de: LocationName.iceberg_5_s2,
-    0x7706df: LocationName.iceberg_5_s3,
-    0x7706e0: LocationName.iceberg_5_s4,
-    0x7706e1: LocationName.iceberg_5_s5,
-    0x7706e2: LocationName.iceberg_5_s6,
-    0x7706e3: LocationName.iceberg_5_s7,
-    0x7706e4: LocationName.iceberg_5_s8,
-    0x7706e5: LocationName.iceberg_5_s9,
-    0x7706e6: LocationName.iceberg_5_s10,
-    0x7706e7: LocationName.iceberg_5_s11,
-    0x7706e8: LocationName.iceberg_5_s12,
-    0x7706e9: LocationName.iceberg_5_s13,
-    0x7706ea: LocationName.iceberg_5_s14,
-    0x7706eb: LocationName.iceberg_5_s15,
-    0x7706ec: LocationName.iceberg_5_s16,
-    0x7706ed: LocationName.iceberg_5_s17,
-    0x7706ee: LocationName.iceberg_5_s18,
-    0x7706ef: LocationName.iceberg_5_s19,
-    0x7706f0: LocationName.iceberg_5_s20,
-    0x7706f1: LocationName.iceberg_5_s21,
-    0x7706f2: LocationName.iceberg_5_s22,
-    0x7706f3: LocationName.iceberg_5_s23,
-    0x7706f4: LocationName.iceberg_5_s24,
-    0x7706f5: LocationName.iceberg_5_s25,
-    0x7706f6: LocationName.iceberg_5_s26,
-    0x7706f7: LocationName.iceberg_5_s27,
-    0x7706f8: LocationName.iceberg_5_s28,
-    0x7706f9: LocationName.iceberg_5_s29,
-    0x7706fa: LocationName.iceberg_5_s30,
-    0x7706fb: LocationName.iceberg_5_s31,
-    0x7706fc: LocationName.iceberg_5_s32,
-    0x7706fd: LocationName.iceberg_5_s33,
-    0x7706fe: LocationName.iceberg_5_s34,
-    0x7706ff: LocationName.iceberg_6_s1,
-
-}
-
-location_table = {
-    **stage_locations,
-    **heart_star_locations,
-    **boss_locations,
-    **consumable_locations,
-    **star_locations
-}

worlds/kdl3/Rom.py

@@ -1,577 +0,0 @@
-import typing
-from pkgutil import get_data
-
-import Utils
-from typing import Optional, TYPE_CHECKING
-import hashlib
-import os
-import struct
-
-import settings
-from worlds.Files import APDeltaPatch
-from .Aesthetics import get_palette_bytes, kirby_target_palettes, get_kirby_palette, gooey_target_palettes, \
-    get_gooey_palette
-from .Compression import hal_decompress
-import bsdiff4
-
-if TYPE_CHECKING:
-    from . import KDL3World
-
-KDL3UHASH = "201e7658f6194458a3869dde36bf8ec2"
-KDL3JHASH = "b2f2d004ea640c3db66df958fce122b2"
-
-level_pointers = {
-    0x770001: 0x0084,
-    0x770002: 0x009C,
-    0x770003: 0x00B8,
-    0x770004: 0x00D8,
-    0x770005: 0x0104,
-    0x770006: 0x0124,
-    0x770007: 0x014C,
-    0x770008: 0x0170,
-    0x770009: 0x0190,
-    0x77000A: 0x01B0,
-    0x77000B: 0x01E8,
-    0x77000C: 0x0218,
-    0x77000D: 0x024C,
-    0x77000E: 0x0270,
-    0x77000F: 0x02A0,
-    0x770010: 0x02C4,
-    0x770011: 0x02EC,
-    0x770012: 0x0314,
-    0x770013: 0x03CC,
-    0x770014: 0x0404,
-    0x770015: 0x042C,
-    0x770016: 0x044C,
-    0x770017: 0x0478,
-    0x770018: 0x049C,
-    0x770019: 0x04E4,
-    0x77001A: 0x0504,
-    0x77001B: 0x0530,
-    0x77001C: 0x0554,
-    0x77001D: 0x05A8,
-    0x77001E: 0x0640,
-    0x770200: 0x0148,
-    0x770201: 0x0248,
-    0x770202: 0x03C8,
-    0x770203: 0x04E0,
-    0x770204: 0x06A4,
-    0x770205: 0x06A8,
-}
-
-bb_bosses = {
-    0x770200: 0xED85F1,
-    0x770201: 0xF01360,
-    0x770202: 0xEDA3DF,
-    0x770203: 0xEDC2B9,
-    0x770204: 0xED7C3F,
-    0x770205: 0xEC29D2,
-}
-
-level_sprites = {
-    0x19B2C6: 1827,
-    0x1A195C: 1584,
-    0x19F6F3: 1679,
-    0x19DC8B: 1717,
-    0x197900: 1872
-}
-
-stage_tiles = {
-    0: [
-        0, 1, 2,
-        16, 17, 18,
-        32, 33, 34,
-        48, 49, 50
-    ],
-    1: [
-        3, 4, 5,
-        19, 20, 21,
-        35, 36, 37,
-        51, 52, 53
-    ],
-    2: [
-        6, 7, 8,
-        22, 23, 24,
-        38, 39, 40,
-        54, 55, 56
-    ],
-    3: [
-        9, 10, 11,
-        25, 26, 27,
-        41, 42, 43,
-        57, 58, 59,
-    ],
-    4: [
-        12, 13, 64,
-        28, 29, 65,
-        44, 45, 66,
-        60, 61, 67
-    ],
-    5: [
-        14, 15, 68,
-        30, 31, 69,
-        46, 47, 70,
-        62, 63, 71
-    ]
-}
-
-heart_star_address = 0x2D0000
-heart_star_size = 456
-consumable_address = 0x2F91DD
-consumable_size = 698
-
-stage_palettes = [0x60964, 0x60B64, 0x60D64, 0x60F64, 0x61164]
-
-music_choices = [
-    2,  # Boss 1
-    3,  # Boss 2 (Unused)
-    4,  # Boss 3 (Miniboss)
-    7,  # Dedede
-    9,  # Event 2 (used once)
-    10,  # Field 1
-    11,  # Field 2
-    12,  # Field 3
-    13,  # Field 4
-    14,  # Field 5
-    15,  # Field 6
-    16,  # Field 7
-    17,  # Field 8
-    18,  # Field 9
-    19,  # Field 10
-    20,  # Field 11
-    21,  # Field 12 (Gourmet Race)
-    23,  # Dark Matter in the Hyper Zone
-    24,  # Zero
-    25,  # Level 1
-    26,  # Level 2
-    27,  # Level 4
-    28,  # Level 3
-    29,  # Heart Star Failed
-    30,  # Level 5
-    31,  # Minigame
-    38,  # Animal Friend 1
-    39,  # Animal Friend 2
-    40,  # Animal Friend 3
-]
-# extra room pointers we don't want to track other than for music
-room_pointers = [
-    3079990,  # Zero
-    2983409,  # BB Whispy
-    3150688,  # BB Acro
-    2991071,  # BB PonCon
-    2998969,  # BB Ado
-    2980927,  # BB Dedede
-    2894290  # BB Zero
-]
-
-enemy_remap = {
-    "Waddle Dee": 0,
-    "Bronto Burt": 2,
-    "Rocky": 3,
-    "Bobo": 5,
-    "Chilly": 6,
-    "Poppy Bros Jr.": 7,
-    "Sparky": 8,
-    "Polof": 9,
-    "Broom Hatter": 11,
-    "Cappy": 12,
-    "Bouncy": 13,
-    "Nruff": 15,
-    "Glunk": 16,
-    "Togezo": 18,
-    "Kabu": 19,
-    "Mony": 20,
-    "Blipper": 21,
-    "Squishy": 22,
-    "Gabon": 24,
-    "Oro": 25,
-    "Galbo": 26,
-    "Sir Kibble": 27,
-    "Nidoo": 28,
-    "Kany": 29,
-    "Sasuke": 30,
-    "Yaban": 32,
-    "Boten": 33,
-    "Coconut": 34,
-    "Doka": 35,
-    "Icicle": 36,
-    "Pteran": 39,
-    "Loud": 40,
-    "Como": 41,
-    "Klinko": 42,
-    "Babut": 43,
-    "Wappa": 44,
-    "Mariel": 45,
-    "Tick": 48,
-    "Apolo": 49,
-    "Popon Ball": 50,
-    "KeKe": 51,
-    "Magoo": 53,
-    "Raft Waddle Dee": 57,
-    "Madoo": 58,
-    "Corori": 60,
-    "Kapar": 67,
-    "Batamon": 68,
-    "Peran": 72,
-    "Bobin": 73,
-    "Mopoo": 74,
-    "Gansan": 75,
-    "Bukiset (Burning)": 76,
-    "Bukiset (Stone)": 77,
-    "Bukiset (Ice)": 78,
-    "Bukiset (Needle)": 79,
-    "Bukiset (Clean)": 80,
-    "Bukiset (Parasol)": 81,
-    "Bukiset (Spark)": 82,
-    "Bukiset (Cutter)": 83,
-    "Waddle Dee Drawing": 84,
-    "Bronto Burt Drawing": 85,
-    "Bouncy Drawing": 86,
-    "Kabu (Dekabu)": 87,
-    "Wapod": 88,
-    "Propeller": 89,
-    "Dogon": 90,
-    "Joe": 91
-}
-
-miniboss_remap = {
-    "Captain Stitch": 0,
-    "Yuki": 1,
-    "Blocky": 2,
-    "Jumper Shoot": 3,
-    "Boboo": 4,
-    "Haboki": 5
-}
-
-ability_remap = {
-    "No Ability": 0,
-    "Burning Ability": 1,
-    "Stone Ability": 2,
-    "Ice Ability": 3,
-    "Needle Ability": 4,
-    "Clean Ability": 5,
-    "Parasol Ability": 6,
-    "Spark Ability": 7,
-    "Cutter Ability": 8,
-}
-
-
-class RomData:
-    def __init__(self, file: str, name: typing.Optional[str] = None):
-        self.file = bytearray()
-        self.read_from_file(file)
-        self.name = name
-
-    def read_byte(self, offset: int):
-        return self.file[offset]
-
-    def read_bytes(self, offset: int, length: int):
-        return self.file[offset:offset + length]
-
-    def write_byte(self, offset: int, value: int):
-        self.file[offset] = value
-
-    def write_bytes(self, offset: int, values: typing.Sequence) -> None:
-        self.file[offset:offset + len(values)] = values
-
-    def write_to_file(self, file: str):
-        with open(file, 'wb') as outfile:
-            outfile.write(self.file)
-
-    def read_from_file(self, file: str):
-        with open(file, 'rb') as stream:
-            self.file = bytearray(stream.read())
-
-    def apply_patch(self, patch: bytes):
-        self.file = bytearray(bsdiff4.patch(bytes(self.file), patch))
-
-    def write_crc(self):
-        crc = (sum(self.file[:0x7FDC] + self.file[0x7FE0:]) + 0x01FE) & 0xFFFF
-        inv = crc ^ 0xFFFF
-        self.write_bytes(0x7FDC, [inv & 0xFF, (inv >> 8) & 0xFF, crc & 0xFF, (crc >> 8) & 0xFF])
-
-
-def handle_level_sprites(stages, sprites, palettes):
-    palette_by_level = list()
-    for palette in palettes:
-        palette_by_level.extend(palette[10:16])
-    for i in range(5):
-        for j in range(6):
-            palettes[i][10 + j] = palette_by_level[stages[i][j] - 1]
-        palettes[i] = [x for palette in palettes[i] for x in palette]
-    tiles_by_level = list()
-    for spritesheet in sprites:
-        decompressed = hal_decompress(spritesheet)
-        tiles = [decompressed[i:i + 32] for i in range(0, 2304, 32)]
-        tiles_by_level.extend([[tiles[x] for x in stage_tiles[stage]] for stage in stage_tiles])
-    for world in range(5):
-        levels = [stages[world][x] - 1 for x in range(6)]
-        world_tiles: typing.List[typing.Optional[bytes]] = [None for _ in range(72)]
-        for i in range(6):
-            for x in range(12):
-                world_tiles[stage_tiles[i][x]] = tiles_by_level[levels[i]][x]
-        sprites[world] = list()
-        for tile in world_tiles:
-            sprites[world].extend(tile)
-        # insert our fake compression
-        sprites[world][0:0] = [0xe3, 0xff]
-        sprites[world][1026:1026] = [0xe3, 0xff]
-        sprites[world][2052:2052] = [0xe0, 0xff]
-        sprites[world].append(0xff)
-    return sprites, palettes
-
-
-def write_heart_star_sprites(rom: RomData):
-    compressed = rom.read_bytes(heart_star_address, heart_star_size)
-    decompressed = hal_decompress(compressed)
-    patch = get_data(__name__, os.path.join("data", "APHeartStar.bsdiff4"))
-    patched = bytearray(bsdiff4.patch(decompressed, patch))
-    rom.write_bytes(0x1AF7DF, patched)
-    patched[0:0] = [0xE3, 0xFF]
-    patched.append(0xFF)
-    rom.write_bytes(0x1CD000, patched)
-    rom.write_bytes(0x3F0EBF, [0x00, 0xD0, 0x39])
-
-
-def write_consumable_sprites(rom: RomData, consumables: bool, stars: bool):
-    compressed = rom.read_bytes(consumable_address, consumable_size)
-    decompressed = hal_decompress(compressed)
-    patched = bytearray(decompressed)
-    if consumables:
-        patch = get_data(__name__, os.path.join("data", "APConsumable.bsdiff4"))
-        patched = bytearray(bsdiff4.patch(bytes(patched), patch))
-    if stars:
-        patch = get_data(__name__, os.path.join("data", "APStars.bsdiff4"))
-        patched = bytearray(bsdiff4.patch(bytes(patched), patch))
-    patched[0:0] = [0xE3, 0xFF]
-    patched.append(0xFF)
-    rom.write_bytes(0x1CD500, patched)
-    rom.write_bytes(0x3F0DAE, [0x00, 0xD5, 0x39])
-
-
-class KDL3DeltaPatch(APDeltaPatch):
-    hash = [KDL3UHASH, KDL3JHASH]
-    game = "Kirby's Dream Land 3"
-    patch_file_ending = ".apkdl3"
-
-    @classmethod
-    def get_source_data(cls) -> bytes:
-        return get_base_rom_bytes()
-
-    def patch(self, target: str):
-        super().patch(target)
-        rom = RomData(target)
-        target_language = rom.read_byte(0x3C020)
-        rom.write_byte(0x7FD9, target_language)
-        write_heart_star_sprites(rom)
-        if rom.read_bytes(0x3D014, 1)[0] > 0:
-            stages = [struct.unpack("HHHHHHH", rom.read_bytes(0x3D020 + x * 14, 14)) for x in range(5)]
-            palettes = [rom.read_bytes(full_pal, 512) for full_pal in stage_palettes]
-            palettes = [[palette[i:i + 32] for i in range(0, 512, 32)] for palette in palettes]
-            sprites = [rom.read_bytes(offset, level_sprites[offset]) for offset in level_sprites]
-            sprites, palettes = handle_level_sprites(stages, sprites, palettes)
-            for addr, palette in zip(stage_palettes, palettes):
-                rom.write_bytes(addr, palette)
-            for addr, level_sprite in zip([0x1CA000, 0x1CA920, 0x1CB230, 0x1CBB40, 0x1CC450], sprites):
-                rom.write_bytes(addr, level_sprite)
-            rom.write_bytes(0x460A, [0x00, 0xA0, 0x39, 0x20, 0xA9, 0x39, 0x30, 0xB2, 0x39, 0x40, 0xBB, 0x39,
-                                     0x50, 0xC4, 0x39])
-        write_consumable_sprites(rom, rom.read_byte(0x3D018) > 0, rom.read_byte(0x3D01A) > 0)
-        rom_name = rom.read_bytes(0x3C000, 21)
-        rom.write_bytes(0x7FC0, rom_name)
-        rom.write_crc()
-        rom.write_to_file(target)
-
-
-def patch_rom(world: "KDL3World", rom: RomData):
-    rom.apply_patch(get_data(__name__, os.path.join("data", "kdl3_basepatch.bsdiff4")))
-    tiles = get_data(__name__, os.path.join("data", "APPauseIcons.dat"))
-    rom.write_bytes(0x3F000, tiles)
-
-    # Write open world patch
-    if world.options.open_world:
-        rom.write_bytes(0x143C7, [0xAD, 0xC1, 0x5A, 0xCD, 0xC1, 0x5A, ])
-        # changes the stage flag function to compare $5AC1 to $5AC1,
-        # always running the "new stage" function
-        # This has further checks present for bosses already, so we just
-        # need to handle regular stages
-        # write check for boss to be unlocked
-
-    if world.options.consumables:
-        # reroute maxim tomatoes to use the 1-UP function, then null out the function
-        rom.write_bytes(0x3002F, [0x37, 0x00])
-        rom.write_bytes(0x30037, [0xA9, 0x26, 0x00,  # LDA #$0026
-                                  0x22, 0x27, 0xD9, 0x00,  # JSL $00D927
-                                  0xA4, 0xD2,  # LDY $D2
-                                  0x6B,  # RTL
-                                  0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA, 0xEA,  # NOP #10
-                                  ])
-
-    # stars handling is built into the rom, so no changes there
-
-    rooms = world.rooms
-    if world.options.music_shuffle > 0:
-        if world.options.music_shuffle == 1:
-            shuffled_music = music_choices.copy()
-            world.random.shuffle(shuffled_music)
-            music_map = dict(zip(music_choices, shuffled_music))
-            # Avoid putting star twinkle in the pool
-            music_map[5] = world.random.choice(music_choices)
-            # Heart Star music doesn't work on regular stages
-            music_map[8] = world.random.choice(music_choices)
-            for room in rooms:
-                room.music = music_map[room.music]
-            for room in room_pointers:
-                old_music = rom.read_byte(room + 2)
-                rom.write_byte(room + 2, music_map[old_music])
-            for i in range(5):
-                # level themes
-                old_music = rom.read_byte(0x133F2 + i)
-                rom.write_byte(0x133F2 + i, music_map[old_music])
-            # Zero
-            rom.write_byte(0x9AE79, music_map[0x18])
-            # Heart Star success and fail
-            rom.write_byte(0x4A388, music_map[0x08])
-            rom.write_byte(0x4A38D, music_map[0x1D])
-        elif world.options.music_shuffle == 2:
-            for room in rooms:
-                room.music = world.random.choice(music_choices)
-            for room in room_pointers:
-                rom.write_byte(room + 2, world.random.choice(music_choices))
-            for i in range(5):
-                # level themes
-                rom.write_byte(0x133F2 + i, world.random.choice(music_choices))
-            # Zero
-            rom.write_byte(0x9AE79, world.random.choice(music_choices))
-            # Heart Star success and fail
-            rom.write_byte(0x4A388, world.random.choice(music_choices))
-            rom.write_byte(0x4A38D, world.random.choice(music_choices))
-
-    for room in rooms:
-        room.patch(rom)
-
-    if world.options.virtual_console in [1, 3]:
-        # Flash Reduction
-        rom.write_byte(0x9AE68, 0x10)
-        rom.write_bytes(0x9AE8E, [0x08, 0x00, 0x22, 0x5D, 0xF7, 0x00, 0xA2, 0x08, ])
-        rom.write_byte(0x9AEA1, 0x08)
-        rom.write_byte(0x9AEC9, 0x01)
-        rom.write_bytes(0x9AED2, [0xA9, 0x1F])
-        rom.write_byte(0x9AEE1, 0x08)
-
-    if world.options.virtual_console in [2, 3]:
-        # Hyper Zone BB colors
-        rom.write_bytes(0x2C5E16, [0xEE, 0x1B, 0x18, 0x5B, 0xD3, 0x4A, 0xF4, 0x3B, ])
-        rom.write_bytes(0x2C8217, [0xFF, 0x1E, ])
-
-    # boss requirements
-    rom.write_bytes(0x3D000, struct.pack("HHHHH", world.boss_requirements[0], world.boss_requirements[1],
-                                         world.boss_requirements[2], world.boss_requirements[3],
-                                         world.boss_requirements[4]))
-    rom.write_bytes(0x3D00A, struct.pack("H", world.required_heart_stars if world.options.goal_speed == 1 else 0xFFFF))
-    rom.write_byte(0x3D00C, world.options.goal_speed.value)
-    rom.write_byte(0x3D00E, world.options.open_world.value)
-    rom.write_byte(0x3D010, world.options.death_link.value)
-    rom.write_byte(0x3D012, world.options.goal.value)
-    rom.write_byte(0x3D014, world.options.stage_shuffle.value)
-    rom.write_byte(0x3D016, world.options.ow_boss_requirement.value)
-    rom.write_byte(0x3D018, world.options.consumables.value)
-    rom.write_byte(0x3D01A, world.options.starsanity.value)
-    rom.write_byte(0x3D01C, world.options.gifting.value if world.multiworld.players > 1 else 0)
-    rom.write_byte(0x3D01E, world.options.strict_bosses.value)
-    # don't write gifting for solo game, since there's no one to send anything to
-
-    for level in world.player_levels:
-        for i in range(len(world.player_levels[level])):
-            rom.write_bytes(0x3F002E + ((level - 1) * 14) + (i * 2),
-                            struct.pack("H", level_pointers[world.player_levels[level][i]]))
-            rom.write_bytes(0x3D020 + (level - 1) * 14 + (i * 2),
-                            struct.pack("H", world.player_levels[level][i] & 0x00FFFF))
-            if (i == 0) or (i > 0 and i % 6 != 0):
-                rom.write_bytes(0x3D080 + (level - 1) * 12 + (i * 2),
-                                struct.pack("H", (world.player_levels[level][i] & 0x00FFFF) % 6))
-
-    for i in range(6):
-        if world.boss_butch_bosses[i]:
-            rom.write_bytes(0x3F0000 + (level_pointers[0x770200 + i]), struct.pack("I", bb_bosses[0x770200 + i]))
-
-    # copy ability shuffle
-    if world.options.copy_ability_randomization.value > 0:
-        for enemy in world.copy_abilities:
-            if enemy in miniboss_remap:
-                rom.write_bytes(0xB417E + (miniboss_remap[enemy] << 1),
-                                struct.pack("H", ability_remap[world.copy_abilities[enemy]]))
-            else:
-                rom.write_bytes(0xB3CAC + (enemy_remap[enemy] << 1),
-                                struct.pack("H", ability_remap[world.copy_abilities[enemy]]))
-        # following only needs done on non-door rando
-        # incredibly lucky this follows the same order (including 5E == star block)
-        rom.write_byte(0x2F77EA, 0x5E + (ability_remap[world.copy_abilities["Sparky"]] << 1))
-        rom.write_byte(0x2F7811, 0x5E + (ability_remap[world.copy_abilities["Sparky"]] << 1))
-        rom.write_byte(0x2F9BC4, 0x5E + (ability_remap[world.copy_abilities["Blocky"]] << 1))
-        rom.write_byte(0x2F9BEB, 0x5E + (ability_remap[world.copy_abilities["Blocky"]] << 1))
-        rom.write_byte(0x2FAC06, 0x5E + (ability_remap[world.copy_abilities["Jumper Shoot"]] << 1))
-        rom.write_byte(0x2FAC2D, 0x5E + (ability_remap[world.copy_abilities["Jumper Shoot"]] << 1))
-        rom.write_byte(0x2F9E7B, 0x5E + (ability_remap[world.copy_abilities["Yuki"]] << 1))
-        rom.write_byte(0x2F9EA2, 0x5E + (ability_remap[world.copy_abilities["Yuki"]] << 1))
-        rom.write_byte(0x2FA951, 0x5E + (ability_remap[world.copy_abilities["Sir Kibble"]] << 1))
-        rom.write_byte(0x2FA978, 0x5E + (ability_remap[world.copy_abilities["Sir Kibble"]] << 1))
-        rom.write_byte(0x2FA132, 0x5E + (ability_remap[world.copy_abilities["Haboki"]] << 1))
-        rom.write_byte(0x2FA159, 0x5E + (ability_remap[world.copy_abilities["Haboki"]] << 1))
-        rom.write_byte(0x2FA3E8, 0x5E + (ability_remap[world.copy_abilities["Boboo"]] << 1))
-        rom.write_byte(0x2FA40F, 0x5E + (ability_remap[world.copy_abilities["Boboo"]] << 1))
-        rom.write_byte(0x2F90E2, 0x5E + (ability_remap[world.copy_abilities["Captain Stitch"]] << 1))
-        rom.write_byte(0x2F9109, 0x5E + (ability_remap[world.copy_abilities["Captain Stitch"]] << 1))
-
-        if world.options.copy_ability_randomization == 2:
-            for enemy in enemy_remap:
-                # we just won't include it for minibosses
-                rom.write_bytes(0xB3E40 + (enemy_remap[enemy] << 1), struct.pack("h", world.random.randint(-1, 2)))
-
-    # write jumping goal
-    rom.write_bytes(0x94F8, struct.pack("H", world.options.jumping_target))
-    rom.write_bytes(0x944E, struct.pack("H", world.options.jumping_target))
-
-    from Utils import __version__
-    rom.name = bytearray(
-        f'KDL3{__version__.replace(".", "")[0:3]}_{world.player}_{world.multiworld.seed:11}\0', 'utf8')[:21]
-    rom.name.extend([0] * (21 - len(rom.name)))
-    rom.write_bytes(0x3C000, rom.name)
-    rom.write_byte(0x3C020, world.options.game_language.value)
-
-    # handle palette
-    if world.options.kirby_flavor_preset.value != 0:
-        for addr in kirby_target_palettes:
-            target = kirby_target_palettes[addr]
-            palette = get_kirby_palette(world)
-            rom.write_bytes(addr, get_palette_bytes(palette, target[0], target[1], target[2]))
-
-    if world.options.gooey_flavor_preset.value != 0:
-        for addr in gooey_target_palettes:
-            target = gooey_target_palettes[addr]
-            palette = get_gooey_palette(world)
-            rom.write_bytes(addr, get_palette_bytes(palette, target[0], target[1], target[2]))
-
-
-def get_base_rom_bytes() -> bytes:
-    rom_file: str = get_base_rom_path()
-    base_rom_bytes: Optional[bytes] = getattr(get_base_rom_bytes, "base_rom_bytes", None)
-    if not base_rom_bytes:
-        base_rom_bytes = bytes(Utils.read_snes_rom(open(rom_file, "rb")))
-
-        basemd5 = hashlib.md5()
-        basemd5.update(base_rom_bytes)
-        if basemd5.hexdigest() not in {KDL3UHASH, KDL3JHASH}:
-            raise Exception("Supplied Base Rom does not match known MD5 for US or JP release. "
-                            "Get the correct game and version, then dump it")
-        get_base_rom_bytes.base_rom_bytes = base_rom_bytes
-    return base_rom_bytes
-
-
-def get_base_rom_path(file_name: str = "") -> str:
-    options: settings.Settings = settings.get_settings()
-    if not file_name:
-        file_name = options["kdl3_options"]["rom_file"]
-    if not os.path.exists(file_name):
-        file_name = Utils.user_path(file_name)
-    return file_name

worlds/kdl3/Room.py

@@ -1,95 +0,0 @@
-import struct
-import typing
-from BaseClasses import Region, ItemClassification
-
-if typing.TYPE_CHECKING:
-    from .Rom import RomData
-
-animal_map = {
-    "Rick Spawn": 0,
-    "Kine Spawn": 1,
-    "Coo Spawn": 2,
-    "Nago Spawn": 3,
-    "ChuChu Spawn": 4,
-    "Pitch Spawn": 5
-}
-
-
-class KDL3Room(Region):
-    pointer: int = 0
-    level: int = 0
-    stage: int = 0
-    room: int = 0
-    music: int = 0
-    default_exits: typing.List[typing.Dict[str, typing.Union[int, typing.List[str]]]]
-    animal_pointers: typing.List[int]
-    enemies: typing.List[str]
-    entity_load: typing.List[typing.List[int]]
-    consumables: typing.List[typing.Dict[str, typing.Union[int, str]]]
-
-    def __init__(self, name, player, multiworld, hint, level, stage, room, pointer, music, default_exits,
-                 animal_pointers, enemies, entity_load, consumables, consumable_pointer):
-        super().__init__(name, player, multiworld, hint)
-        self.level = level
-        self.stage = stage
-        self.room = room
-        self.pointer = pointer
-        self.music = music
-        self.default_exits = default_exits
-        self.animal_pointers = animal_pointers
-        self.enemies = enemies
-        self.entity_load = entity_load
-        self.consumables = consumables
-        self.consumable_pointer = consumable_pointer
-
-    def patch(self, rom: "RomData"):
-        rom.write_byte(self.pointer + 2, self.music)
-        animals = [x.item.name for x in self.locations if "Animal" in x.name]
-        if len(animals) > 0:
-            for current_animal, address in zip(animals, self.animal_pointers):
-                rom.write_byte(self.pointer + address + 7, animal_map[current_animal])
-        if self.multiworld.worlds[self.player].options.consumables:
-            load_len = len(self.entity_load)
-            for consumable in self.consumables:
-                location = next(x for x in self.locations if x.name == consumable["name"])
-                assert location.item
-                is_progression = location.item.classification & ItemClassification.progression
-                if load_len == 8:
-                    # edge case, there is exactly 1 room with 8 entities and only 1 consumable among them
-                    if not (any(x in self.entity_load for x in [[0, 22], [1, 22]])
-                            and any(x in self.entity_load for x in [[2, 22], [3, 22]])):
-                        replacement_target = self.entity_load.index(
-                            next(x for x in self.entity_load if x in [[0, 22], [1, 22], [2, 22], [3, 22]]))
-                        if is_progression:
-                            vtype = 0
-                        else:
-                            vtype = 2
-                        rom.write_byte(self.pointer + 88 + (replacement_target * 2), vtype)
-                        self.entity_load[replacement_target] = [vtype, 22]
-                else:
-                    if is_progression:
-                        # we need to see if 1-ups are in our load list
-                        if any(x not in self.entity_load for x in [[0, 22], [1, 22]]):
-                            self.entity_load.append([0, 22])
-                    else:
-                        if any(x not in self.entity_load for x in [[2, 22], [3, 22]]):
-                            # edge case: if (1, 22) is in, we need to load (3, 22) instead
-                            if [1, 22] in self.entity_load:
-                                self.entity_load.append([3, 22])
-                            else:
-                                self.entity_load.append([2, 22])
-                if load_len < len(self.entity_load):
-                    rom.write_bytes(self.pointer + 88 + (load_len * 2), bytes(self.entity_load[load_len]))
-                    rom.write_bytes(self.pointer + 104 + (load_len * 2),
-                                    bytes(struct.pack("H", self.consumable_pointer)))
-                if is_progression:
-                    if [1, 22] in self.entity_load:
-                        vtype = 1
-                    else:
-                        vtype = 0
-                else:
-                    if [3, 22] in self.entity_load:
-                        vtype = 3
-                    else:
-                        vtype = 2
-                rom.write_byte(self.pointer + consumable["pointer"] + 7, vtype)

worlds/kdl3/__init__.py

@@ -1,25 +1,25 @@
 import logging
-import typing
 
-from BaseClasses import Tutorial, ItemClassification, MultiWorld
+from BaseClasses import Tutorial, ItemClassification, MultiWorld, CollectionState, Item
 from Fill import fill_restrictive
 from Options import PerGameCommonOptions
 from worlds.AutoWorld import World, WebWorld
-from .Items import item_table, item_names, copy_ability_table, animal_friend_table, filler_item_weights, KDL3Item, \
-    trap_item_table, copy_ability_access_table, star_item_weights, total_filler_weights
-from .Locations import location_table, KDL3Location, level_consumables, consumable_locations, star_locations
-from .Names.AnimalFriendSpawns import animal_friend_spawns
-from .Names.EnemyAbilities import vanilla_enemies, enemy_mapping, enemy_restrictive
-from .Regions import create_levels, default_levels
-from .Options import KDL3Options
-from .Presets import kdl3_options_presets
-from .Names import LocationName
-from .Room import KDL3Room
-from .Rules import set_rules
-from .Rom import KDL3DeltaPatch, get_base_rom_path, RomData, patch_rom, KDL3JHASH, KDL3UHASH
-from .Client import KDL3SNIClient
+from .items import item_table, item_names, copy_ability_table, animal_friend_table, filler_item_weights, KDL3Item, \
+    trap_item_table, copy_ability_access_table, star_item_weights, total_filler_weights, animal_friend_spawn_table,\
+    lookup_item_to_id
+from .locations import location_table, KDL3Location, level_consumables, consumable_locations, star_locations
+from .names.animal_friend_spawns import animal_friend_spawns, problematic_sets
+from .names.enemy_abilities import vanilla_enemies, enemy_mapping, enemy_restrictive
+from .regions import create_levels, default_levels
+from .options import KDL3Options, kdl3_option_groups
+from .presets import kdl3_options_presets
+from .names import location_name
+from .room import KDL3Room
+from .rules import set_rules
+from .rom import KDL3ProcedurePatch, get_base_rom_path, patch_rom, KDL3JHASH, KDL3UHASH
+from .client import KDL3SNIClient
 
-from typing import Dict, TextIO, Optional, List
+from typing import Dict, TextIO, Optional, List, Any, Mapping, ClassVar, Type
 import os
 import math
 import threading
@@ -53,6 +53,7 @@ class KDL3WebWorld(WebWorld):
         )
     ]
     options_presets = kdl3_options_presets
+    option_groups = kdl3_option_groups
 
 
 class KDL3World(World):
@@ -61,35 +62,35 @@ class KDL3World(World):
     """
 
     game = "Kirby's Dream Land 3"
-    options_dataclass: typing.ClassVar[typing.Type[PerGameCommonOptions]] = KDL3Options
+    options_dataclass: ClassVar[Type[PerGameCommonOptions]] = KDL3Options
     options: KDL3Options
-    item_name_to_id = {item: item_table[item].code for item in item_table}
+    item_name_to_id = lookup_item_to_id
     location_name_to_id = {location_table[location]: location for location in location_table}
     item_name_groups = item_names
     web = KDL3WebWorld()
-    settings: typing.ClassVar[KDL3Settings]
+    settings: ClassVar[KDL3Settings]
 
     def __init__(self, multiworld: MultiWorld, player: int):
-        self.rom_name = None
+        self.rom_name: bytes = bytes()
         self.rom_name_available_event = threading.Event()
         super().__init__(multiworld, player)
         self.copy_abilities: Dict[str, str] = vanilla_enemies.copy()
         self.required_heart_stars: int = 0  # we fill this during create_items
-        self.boss_requirements: Dict[int, int] = dict()
+        self.boss_requirements: List[int] = []
         self.player_levels = default_levels.copy()
         self.stage_shuffle_enabled = False
-        self.boss_butch_bosses: List[Optional[bool]] = list()
-        self.rooms: Optional[List[KDL3Room]] = None
-
-    @classmethod
-    def stage_assert_generate(cls, multiworld: MultiWorld) -> None:
-        rom_file: str = get_base_rom_path()
-        if not os.path.exists(rom_file):
-            raise FileNotFoundError(f"Could not find base ROM for {cls.game}: {rom_file}")
+        self.boss_butch_bosses: List[Optional[bool]] = []
+        self.rooms: List[KDL3Room] = []
 
     create_regions = create_levels
 
-    def create_item(self, name: str, force_non_progression=False) -> KDL3Item:
+    def generate_early(self) -> None:
+        if self.options.total_heart_stars != -1:
+            logger.warning(f"Kirby's Dream Land 3 ({self.player_name}): Use of \"total_heart_stars\" is deprecated. "
+                           f"Please use \"max_heart_stars\" instead.")
+            self.options.max_heart_stars.value = self.options.total_heart_stars.value
+
+    def create_item(self, name: str, force_non_progression: bool = False) -> KDL3Item:
         item = item_table[name]
         classification = ItemClassification.filler
         if item.progression and not force_non_progression:
@@ -99,7 +100,7 @@ class KDL3World(World):
             classification = ItemClassification.trap
         return KDL3Item(name, classification, item.code, self.player)
 
-    def get_filler_item_name(self, include_stars=True) -> str:
+    def get_filler_item_name(self, include_stars: bool = True) -> str:
         if include_stars:
             return self.random.choices(list(total_filler_weights.keys()),
                                        weights=list(total_filler_weights.values()))[0]
@@ -112,8 +113,8 @@ class KDL3World(World):
                                             self.options.slow_trap_weight.value,
                                             self.options.ability_trap_weight.value])[0]
 
-    def get_restrictive_copy_ability_placement(self, copy_ability: str, enemies_to_set: typing.List[str],
-                                               level: int, stage: int):
+    def get_restrictive_copy_ability_placement(self, copy_ability: str, enemies_to_set: List[str],
+                                               level: int, stage: int) -> Optional[str]:
         valid_rooms = [room for room in self.rooms if (room.level < level)
                        or (room.level == level and room.stage < stage)]  # leave out the stage in question to avoid edge
         valid_enemies = set()
@@ -124,6 +125,10 @@ class KDL3World(World):
             return None  # a valid enemy got placed by a more restrictive placement
         return self.random.choice(sorted([enemy for enemy in valid_enemies if enemy not in placed_enemies]))
 
+    def get_pre_fill_items(self) -> List[Item]:
+        return [self.create_item(item)
+                for item in [*copy_ability_access_table.keys(), *animal_friend_spawn_table.keys()]]
+
     def pre_fill(self) -> None:
         if self.options.copy_ability_randomization:
             # randomize copy abilities
@@ -196,21 +201,40 @@ class KDL3World(World):
             else:
                 animal_base = ["Rick Spawn", "Kine Spawn", "Coo Spawn", "Nago Spawn", "ChuChu Spawn", "Pitch Spawn"]
                 animal_pool = [self.random.choice(animal_base)
-                               for _ in range(len(animal_friend_spawns) - 9)]
+                               for _ in range(len(animal_friend_spawns) - 10)]
                 # have to guarantee one of each animal
                 animal_pool.extend(animal_base)
             if guaranteed_animal == "Kine Spawn":
                 animal_pool.append("Coo Spawn")
             else:
                 animal_pool.append("Kine Spawn")
-            # Weird fill hack, this forces ChuChu to be the last animal friend placed
-            # If Kine is ever the last animal friend placed, he will cause fill errors on closed world
-            animal_pool.sort()
             locations = [self.multiworld.get_location(spawn, self.player) for spawn in spawns]
-            items = [self.create_item(animal) for animal in animal_pool]
-            allstate = self.multiworld.get_all_state(False)
+            items: List[Item] = [self.create_item(animal) for animal in animal_pool]
+            allstate = CollectionState(self.multiworld)
+            for item in [*copy_ability_table, *animal_friend_table, *["Heart Star" for _ in range(99)]]:
+                self.collect(allstate, self.create_item(item))
             self.random.shuffle(locations)
             fill_restrictive(self.multiworld, allstate, locations, items, True, True)
+
+            # Need to ensure all of these are unique items, and replace them if they aren't
+            for spawns in problematic_sets:
+                placed = [self.get_location(spawn).item for spawn in spawns]
+                placed_names = set([item.name for item in placed])
+                if len(placed_names) != len(placed):
+                    # have a duplicate
+                    animals = []
+                    for spawn in spawns:
+                        spawn_location = self.get_location(spawn)
+                        if spawn_location.item.name not in animals:
+                            animals.append(spawn_location.item.name)
+                        else:
+                            new_animal = self.random.choice([x for x in ["Rick Spawn", "Coo Spawn", "Kine Spawn",
+                                                                         "ChuChu Spawn", "Nago Spawn", "Pitch Spawn"]
+                                                             if x not in placed_names and x not in animals])
+                            spawn_location.item = None
+                            spawn_location.place_locked_item(self.create_item(new_animal))
+                            animals.append(new_animal)
+                            # logically, this should be sound pre-ER. May need to adjust around it with ER in the future
         else:
             animal_friends = animal_friend_spawns.copy()
             for animal in animal_friends:
@@ -225,21 +249,20 @@ class KDL3World(World):
         remaining_items = len(location_table) - len(itempool)
         if not self.options.consumables:
             remaining_items -= len(consumable_locations)
-        remaining_items -= len(star_locations)
-        if self.options.starsanity:
-            # star fill, keep consumable pool locked to consumable and fill 767 stars specifically
-            star_items = list(star_item_weights.keys())
-            star_weights = list(star_item_weights.values())
-            itempool.extend([self.create_item(item) for item in self.random.choices(star_items, weights=star_weights,
-                                                                                    k=767)])
-        total_heart_stars = self.options.total_heart_stars
+        if not self.options.starsanity:
+            remaining_items -= len(star_locations)
+        max_heart_stars = self.options.max_heart_stars.value
+        if max_heart_stars > remaining_items:
+            max_heart_stars = remaining_items
         # ensure at least 1 heart star required per world
-        required_heart_stars = max(int(total_heart_stars * required_percentage), 5)
-        filler_items = total_heart_stars - required_heart_stars
-        filler_amount = math.floor(filler_items * (self.options.filler_percentage / 100.0))
-        trap_amount = math.floor(filler_amount * (self.options.trap_percentage / 100.0))
-        filler_amount -= trap_amount
-        non_required_heart_stars = filler_items - filler_amount - trap_amount
+        required_heart_stars = min(max(int(max_heart_stars * required_percentage), 5), 99)
+        filler_items = remaining_items - required_heart_stars
+        converted_heart_stars = math.floor((max_heart_stars - required_heart_stars) * (self.options.filler_percentage / 100.0))
+        non_required_heart_stars = max_heart_stars - converted_heart_stars - required_heart_stars
+        filler_items -= non_required_heart_stars
+        trap_amount = math.floor(filler_items * (self.options.trap_percentage / 100.0))
+
+        filler_items -= trap_amount
         self.required_heart_stars = required_heart_stars
         # handle boss requirements here
         requirements = [required_heart_stars]
@@ -261,8 +284,8 @@ class KDL3World(World):
                 requirements.insert(i - 1, quotient * i)
         self.boss_requirements = requirements
         itempool.extend([self.create_item("Heart Star") for _ in range(required_heart_stars)])
-        itempool.extend([self.create_item(self.get_filler_item_name(False))
-                         for _ in range(filler_amount + (remaining_items - total_heart_stars))])
+        itempool.extend([self.create_item(self.get_filler_item_name(bool(self.options.starsanity.value)))
+                         for _ in range(filler_items)])
         itempool.extend([self.create_item(self.get_trap_item_name())
                          for _ in range(trap_amount)])
         itempool.extend([self.create_item("Heart Star", True) for _ in range(non_required_heart_stars)])
@@ -273,15 +296,15 @@ class KDL3World(World):
                     self.multiworld.get_location(location_table[self.player_levels[level][stage]]
                                                  .replace("Complete", "Stage Completion"), self.player) \
                         .place_locked_item(KDL3Item(
-                            f"{LocationName.level_names_inverse[level]} - Stage Completion",
+                            f"{location_name.level_names_inverse[level]} - Stage Completion",
                             ItemClassification.progression, None, self.player))
 
     set_rules = set_rules
 
     def generate_basic(self) -> None:
         self.stage_shuffle_enabled = self.options.stage_shuffle > 0
-        goal = self.options.goal
-        goal_location = self.multiworld.get_location(LocationName.goals[goal], self.player)
+        goal = self.options.goal.value
+        goal_location = self.multiworld.get_location(location_name.goals[goal], self.player)
         goal_location.place_locked_item(KDL3Item("Love-Love Rod", ItemClassification.progression, None, self.player))
         for level in range(1, 6):
             self.multiworld.get_location(f"Level {level} Boss - Defeated", self.player) \
@@ -300,60 +323,65 @@ class KDL3World(World):
         else:
             self.boss_butch_bosses = [False for _ in range(6)]
 
-    def generate_output(self, output_directory: str):
-        rom_path = ""
+    def generate_output(self, output_directory: str) -> None:
         try:
-            rom = RomData(get_base_rom_path())
-            patch_rom(self, rom)
+            patch = KDL3ProcedurePatch()
+            patch_rom(self, patch)
 
-            rom_path = os.path.join(output_directory, f"{self.multiworld.get_out_file_name_base(self.player)}.sfc")
-            rom.write_to_file(rom_path)
-            self.rom_name = rom.name
+            self.rom_name = patch.name
 
-            patch = KDL3DeltaPatch(os.path.splitext(rom_path)[0] + KDL3DeltaPatch.patch_file_ending, player=self.player,
-                                   player_name=self.multiworld.player_name[self.player], patched_path=rom_path)
-            patch.write()
+            patch.write(os.path.join(output_directory,
+                                     f"{self.multiworld.get_out_file_name_base(self.player)}{patch.patch_file_ending}"))
         except Exception:
             raise
         finally:
             self.rom_name_available_event.set()  # make sure threading continues and errors are collected
-            if os.path.exists(rom_path):
-                os.unlink(rom_path)
 
-    def modify_multidata(self, multidata: dict):
+    def modify_multidata(self, multidata: Dict[str, Any]) -> None:
         # wait for self.rom_name to be available.
         self.rom_name_available_event.wait()
+        assert isinstance(self.rom_name, bytes)
         rom_name = getattr(self, "rom_name", None)
         # we skip in case of error, so that the original error in the output thread is the one that gets raised
         if rom_name:
-            new_name = base64.b64encode(bytes(self.rom_name)).decode()
+            new_name = base64.b64encode(self.rom_name).decode()
             multidata["connect_names"][new_name] = multidata["connect_names"][self.multiworld.player_name[self.player]]
 
+    def fill_slot_data(self) -> Mapping[str, Any]:
+        # UT support
+        return {"player_levels": self.player_levels}
+
+    def interpret_slot_data(self, slot_data: Mapping[str, Any]):
+        # UT support
+        player_levels = {int(key): value for key, value in slot_data["player_levels"].items()}
+        return {"player_levels": player_levels}
+
     def write_spoiler(self, spoiler_handle: TextIO) -> None:
         if self.stage_shuffle_enabled:
             spoiler_handle.write(f"\nLevel Layout ({self.multiworld.get_player_name(self.player)}):\n")
-            for level in LocationName.level_names:
-                for stage, i in zip(self.player_levels[LocationName.level_names[level]], range(1, 7)):
+            for level in location_name.level_names:
+                for stage, i in zip(self.player_levels[location_name.level_names[level]], range(1, 7)):
                     spoiler_handle.write(f"{level} {i}: {location_table[stage].replace(' - Complete', '')}\n")
         if self.options.animal_randomization:
             spoiler_handle.write(f"\nAnimal Friends ({self.multiworld.get_player_name(self.player)}):\n")
-            for level in self.player_levels:
+            for lvl in self.player_levels:
                 for stage in range(6):
-                    rooms = [room for room in self.rooms if room.level == level and room.stage == stage]
+                    rooms = [room for room in self.rooms if room.level == lvl and room.stage == stage]
                     animals = []
                     for room in rooms:
                         animals.extend([location.item.name.replace(" Spawn", "")
-                                        for location in room.locations if "Animal" in location.name])
-                    spoiler_handle.write(f"{location_table[self.player_levels[level][stage]].replace(' - Complete','')}"
+                                        for location in room.locations if "Animal" in location.name
+                                        and location.item is not None])
+                    spoiler_handle.write(f"{location_table[self.player_levels[lvl][stage]].replace(' - Complete','')}"
                                          f": {', '.join(animals)}\n")
         if self.options.copy_ability_randomization:
             spoiler_handle.write(f"\nCopy Abilities ({self.multiworld.get_player_name(self.player)}):\n")
             for enemy in self.copy_abilities:
                 spoiler_handle.write(f"{enemy}: {self.copy_abilities[enemy].replace('No Ability', 'None').replace(' Ability', '')}\n")
 
-    def extend_hint_information(self, hint_data: Dict[int, Dict[int, str]]):
+    def extend_hint_information(self, hint_data: Dict[int, Dict[int, str]]) -> None:
         if self.stage_shuffle_enabled:
-            regions = {LocationName.level_names[level]: level for level in LocationName.level_names}
+            regions = {location_name.level_names[level]: level for level in location_name.level_names}
             level_hint_data = {}
             for level in regions:
                 for stage in range(7):
@@ -361,6 +389,6 @@ class KDL3World(World):
                                                               self.player).name.replace(" - Complete", "")
                     stage_regions = [room for room in self.rooms if stage_name in room.name]
                     for region in stage_regions:
-                        for location in [location for location in region.locations if location.address]:
+                        for location in [location for location in list(region.get_locations()) if location.address]:
                             level_hint_data[location.address] = f"{regions[level]} {stage + 1 if stage < 6 else 'Boss'}"
             hint_data[self.player] = level_hint_data

worlds/kdl3/aesthetics.py

@@ -1,5 +1,9 @@
 import struct
-from .Options import KirbyFlavorPreset, GooeyFlavorPreset
+from .options import KirbyFlavorPreset, GooeyFlavorPreset
+from typing import TYPE_CHECKING, Optional, Dict, List, Tuple
+
+if TYPE_CHECKING:
+    from . import KDL3World
 
 kirby_flavor_presets = {
     1: {
@@ -223,6 +227,23 @@ kirby_flavor_presets = {
         "14": "E6E6FA",
         "15": "976FBD",
     },
+    14: {
+      "1": "373B3E",
+      "2": "98d5d3",
+      "3": "1aa5ab",
+      "4": "168f95",
+      "5": "4f5559",
+      "6": "1dbac2",
+      "7": "137a7f",
+      "8": "093a3c",
+      "9": "86cecb",
+      "10": "a0afbc",
+      "11": "62bfbb",
+      "12": "50b8b4",
+      "13": "bec8d1",
+      "14": "bce4e2",
+      "15": "91a2b1",
+  }
 }
 
 gooey_flavor_presets = {
@@ -398,21 +419,21 @@ gooey_target_palettes = {
 }
 
 
-def get_kirby_palette(world):
+def get_kirby_palette(world: "KDL3World") -> Optional[Dict[str, str]]:
     palette = world.options.kirby_flavor_preset.value
     if palette == KirbyFlavorPreset.option_custom:
         return world.options.kirby_flavor.value
     return kirby_flavor_presets.get(palette, None)
 
 
-def get_gooey_palette(world):
+def get_gooey_palette(world: "KDL3World") -> Optional[Dict[str, str]]:
     palette = world.options.gooey_flavor_preset.value
     if palette == GooeyFlavorPreset.option_custom:
         return world.options.gooey_flavor.value
     return gooey_flavor_presets.get(palette, None)
 
 
-def rgb888_to_bgr555(red, green, blue) -> bytes:
+def rgb888_to_bgr555(red: int, green: int, blue: int) -> bytes:
     red = red >> 3
     green = green >> 3
     blue = blue >> 3
@@ -420,15 +441,15 @@ def rgb888_to_bgr555(red, green, blue) -> bytes:
     return struct.pack("H", outcol)
 
 
-def get_palette_bytes(palette, target, offset, factor):
+def get_palette_bytes(palette: Dict[str, str], target: List[str], offset: int, factor: float) -> bytes:
     output_data = bytearray()
     for color in target:
         hexcol = palette[color]
         if hexcol.startswith("#"):
             hexcol = hexcol.replace("#", "")
         colint = int(hexcol, 16)
-        col = ((colint & 0xFF0000) >> 16, (colint & 0xFF00) >> 8, colint & 0xFF)
+        col: Tuple[int, ...] = ((colint & 0xFF0000) >> 16, (colint & 0xFF00) >> 8, colint & 0xFF)
         col = tuple(int(int(factor*x) + offset) for x in col)
         byte_data = rgb888_to_bgr555(col[0], col[1], col[2])
         output_data.extend(bytearray(byte_data))
-    return output_data
+    return bytes(output_data)

worlds/kdl3/client.py

@@ -11,13 +11,13 @@ from MultiServer import mark_raw
 from NetUtils import ClientStatus, color
 from Utils import async_start
 from worlds.AutoSNIClient import SNIClient
-from .Locations import boss_locations
-from .Gifting import kdl3_gifting_options, kdl3_trap_gifts, kdl3_gifts, update_object, pop_object, initialize_giftboxes
-from .ClientAddrs import consumable_addrs, star_addrs
+from .locations import boss_locations
+from .gifting import kdl3_gifting_options, kdl3_trap_gifts, kdl3_gifts, update_object, pop_object, initialize_giftboxes
+from .client_addrs import consumable_addrs, star_addrs
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from SNIClient import SNIClientCommandProcessor
+    from SNIClient import SNIClientCommandProcessor, SNIContext
 
 snes_logger = logging.getLogger("SNES")
 
@@ -81,17 +81,16 @@ deathlink_messages = defaultdict(lambda: " was defeated.", {
 
 
 @mark_raw
-def cmd_gift(self: "SNIClientCommandProcessor"):
+def cmd_gift(self: "SNIClientCommandProcessor") -> None:
     """Toggles gifting for the current game."""
-    if not getattr(self.ctx, "gifting", None):
-        self.ctx.gifting = True
-    else:
-        self.ctx.gifting = not self.ctx.gifting
-    self.output(f"Gifting set to {self.ctx.gifting}")
+    handler = self.ctx.client_handler
+    assert isinstance(handler, KDL3SNIClient)
+    handler.gifting = not handler.gifting
+    self.output(f"Gifting set to {handler.gifting}")
     async_start(update_object(self.ctx, f"Giftboxes;{self.ctx.team}", {
         f"{self.ctx.slot}":
             {
-                "IsOpen": self.ctx.gifting,
+                "IsOpen": handler.gifting,
                 **kdl3_gifting_options
             }
     }))
@@ -100,16 +99,17 @@ def cmd_gift(self: "SNIClientCommandProcessor"):
 class KDL3SNIClient(SNIClient):
     game = "Kirby's Dream Land 3"
     patch_suffix = ".apkdl3"
-    levels = None
-    consumables = None
-    stars = None
-    item_queue: typing.List = []
-    initialize_gifting = False
+    levels: typing.Dict[int, typing.List[int]] = {}
+    consumables: typing.Optional[bool] = None
+    stars: typing.Optional[bool] = None
+    item_queue: typing.List[int] = []
+    initialize_gifting: bool = False
+    gifting: bool = False
     giftbox_key: str = ""
     motherbox_key: str = ""
     client_random: random.Random = random.Random()
 
-    async def deathlink_kill_player(self, ctx) -> None:
+    async def deathlink_kill_player(self, ctx: "SNIContext") -> None:
         from SNIClient import DeathState, snes_buffered_write, snes_flush_writes, snes_read
         game_state = await snes_read(ctx, KDL3_GAME_STATE, 1)
         if game_state[0] == 0xFF:
@@ -131,7 +131,7 @@ class KDL3SNIClient(SNIClient):
         ctx.death_state = DeathState.dead
         ctx.last_death_link = time.time()
 
-    async def validate_rom(self, ctx) -> bool:
+    async def validate_rom(self, ctx: "SNIContext") -> bool:
         from SNIClient import snes_read
         rom_name = await snes_read(ctx, KDL3_ROMNAME, 0x15)
         if rom_name is None or rom_name == bytes([0] * 0x15) or rom_name[:4] != b"KDL3":
@@ -141,7 +141,7 @@ class KDL3SNIClient(SNIClient):
 
         ctx.game = self.game
         ctx.rom = rom_name
-        ctx.items_handling = 0b111  # always remote items
+        ctx.items_handling = 0b101  # default local items with remote start inventory
         ctx.allow_collect = True
         if "gift" not in ctx.command_processor.commands:
             ctx.command_processor.commands["gift"] = cmd_gift
@@ -149,9 +149,10 @@ class KDL3SNIClient(SNIClient):
         death_link = await snes_read(ctx, KDL3_DEATH_LINK_ADDR, 1)
         if death_link:
             await ctx.update_death_link(bool(death_link[0] & 0b1))
+            ctx.items_handling |= (death_link[0] & 0b10)  # set local items if enabled
         return True
 
-    async def pop_item(self, ctx, in_stage):
+    async def pop_item(self, ctx: "SNIContext", in_stage: bool) -> None:
         from SNIClient import snes_buffered_write, snes_read
         if len(self.item_queue) > 0:
             item = self.item_queue.pop()
@@ -168,8 +169,8 @@ class KDL3SNIClient(SNIClient):
             else:
                 self.item_queue.append(item)  # no more slots, get it next go around
 
-    async def pop_gift(self, ctx):
-        if ctx.stored_data[self.giftbox_key]:
+    async def pop_gift(self, ctx: "SNIContext") -> None:
+        if self.giftbox_key in ctx.stored_data and ctx.stored_data[self.giftbox_key]:
             from SNIClient import snes_read, snes_buffered_write
             key, gift = ctx.stored_data[self.giftbox_key].popitem()
             await pop_object(ctx, self.giftbox_key, key)
@@ -214,7 +215,7 @@ class KDL3SNIClient(SNIClient):
                     quality = min(10, quality * 2)
                 else:
                     # it's not really edible, but he'll eat it anyway
-                    quality = self.client_random.choices(range(0, 2), {0: 75, 1: 25})[0]
+                    quality = self.client_random.choices(range(0, 2), [75, 25])[0]
                 kirby_hp = await snes_read(ctx, KDL3_KIRBY_HP, 1)
                 gooey_hp = await snes_read(ctx, KDL3_KIRBY_HP + 2, 1)
                 snes_buffered_write(ctx, KDL3_SOUND_FX, bytes([0x26]))
@@ -224,7 +225,8 @@ class KDL3SNIClient(SNIClient):
                 else:
                     snes_buffered_write(ctx, KDL3_KIRBY_HP, struct.pack("H", min(kirby_hp[0] + quality, 10)))
 
-    async def pick_gift_recipient(self, ctx, gift):
+    async def pick_gift_recipient(self, ctx: "SNIContext", gift: int) -> None:
+        assert ctx.slot
         if gift != 4:
             gift_base = kdl3_gifts[gift]
         else:
@@ -238,7 +240,7 @@ class KDL3SNIClient(SNIClient):
             if desire > most_applicable:
                 most_applicable = desire
                 most_applicable_slot = int(slot)
-            elif most_applicable_slot == ctx.slot and info["AcceptsAnyGift"]:
+            elif most_applicable_slot != ctx.slot and most_applicable == -1 and info["AcceptsAnyGift"]:
                 # only send to ourselves if no one else will take it
                 most_applicable_slot = int(slot)
         # print(most_applicable, most_applicable_slot)
@@ -257,7 +259,7 @@ class KDL3SNIClient(SNIClient):
             item_uuid: item,
         })
 
-    async def game_watcher(self, ctx) -> None:
+    async def game_watcher(self, ctx: "SNIContext") -> None:
         try:
             from SNIClient import snes_buffered_write, snes_flush_writes, snes_read
             rom = await snes_read(ctx, KDL3_ROMNAME, 0x15)
@@ -278,11 +280,12 @@ class KDL3SNIClient(SNIClient):
                 await initialize_giftboxes(ctx, self.giftbox_key, self.motherbox_key, bool(enable_gifting[0]))
                 self.initialize_gifting = True
             # can't check debug anymore, without going and copying the value. might be important later.
-            if self.levels is None:
+            if not self.levels:
                 self.levels = dict()
                 for i in range(5):
                     level_data = await snes_read(ctx, KDL3_LEVEL_ADDR + (14 * i), 14)
-                    self.levels[i] = unpack("HHHHHHH", level_data)
+                    self.levels[i] = [int.from_bytes(level_data[idx:idx+1], "little")
+                                      for idx in range(0, len(level_data), 2)]
                 self.levels[5] = [0x0205,  # Hyper Zone
                                   0,  # MG-5, can't send from here
                                   0x0300,  # Boss Butch
@@ -371,7 +374,7 @@ class KDL3SNIClient(SNIClient):
             stages_raw = await snes_read(ctx, KDL3_COMPLETED_STAGES, 60)
             stages = struct.unpack("HHHHHHHHHHHHHHHHHHHHHHHHHHHHHH", stages_raw)
             for i in range(30):
-                loc_id = 0x770000 + i + 1
+                loc_id = 0x770000 + i
                 if stages[i] == 1 and loc_id not in ctx.checked_locations:
                     new_checks.append(loc_id)
                 elif loc_id in ctx.checked_locations:
@@ -381,8 +384,8 @@ class KDL3SNIClient(SNIClient):
             heart_stars = await snes_read(ctx, KDL3_HEART_STARS, 35)
             for i in range(5):
                 start_ind = i * 7
-                for j in range(1, 7):
-                    level_ind = start_ind + j - 1
+                for j in range(6):
+                    level_ind = start_ind + j
                     loc_id = 0x770100 + (6 * i) + j
                     if heart_stars[level_ind] and loc_id not in ctx.checked_locations:
                         new_checks.append(loc_id)
@@ -401,6 +404,9 @@ class KDL3SNIClient(SNIClient):
                     if star not in ctx.checked_locations and stars[star_addrs[star]] == 0x01:
                         new_checks.append(star)
 
+            if not game_state:
+                return
+
             if game_state[0] != 0xFF:
                 await self.pop_gift(ctx)
             await self.pop_item(ctx, game_state[0] != 0xFF)
@@ -408,7 +414,7 @@ class KDL3SNIClient(SNIClient):
 
             # boss status
             boss_flag_bytes = await snes_read(ctx, KDL3_BOSS_STATUS, 2)
-            boss_flag = unpack("H", boss_flag_bytes)[0]
+            boss_flag = int.from_bytes(boss_flag_bytes, "little")
             for bitmask, boss in zip(range(1, 11, 2), boss_locations.keys()):
                 if boss_flag & (1 << bitmask) > 0 and boss not in ctx.checked_locations:
                     new_checks.append(boss)