Use world.web.options_presets directly instead of creating an empty dict first

.github/workflows/unittests.yml

@@ -24,7 +24,7 @@ on:
       - '.github/workflows/unittests.yml'
 
 jobs:
-  unit:
+  build:
     runs-on: ${{ matrix.os }}
     name: Test Python ${{ matrix.python.version }} ${{ matrix.os }}
 
@@ -60,32 +60,3 @@ jobs:
     - name: Unittests
       run: |
         pytest -n auto
-
-  hosting:
-    runs-on: ${{ matrix.os }}
-    name: Test hosting with ${{ matrix.python.version }} on ${{ matrix.os }}
-
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-        python:
-          - {version: '3.11'}  # current
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Set up Python ${{ matrix.python.version }}
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python.version }}
-    - name: Install dependencies
-      run: |
-        python -m venv venv
-        source venv/bin/activate
-        python -m pip install --upgrade pip
-        python ModuleUpdate.py --yes --force --append "WebHostLib/requirements.txt"
-    - name: Test hosting
-      run: |
-        source venv/bin/activate
-        export PYTHONPATH=$(pwd)
-        python test/hosting/__main__.py

.gitignore

@@ -62,7 +62,6 @@ Output Logs/
 /installdelete.iss
 /data/user.kv
 /datapackage
-/custom_worlds
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

AHITClient.py

@@ -1,8 +0,0 @@
-from worlds.ahit.Client import launch
-import Utils
-import ModuleUpdate
-ModuleUpdate.update()
-
-if __name__ == "__main__":
-    Utils.init_logging("AHITClient", exception_logger="Client")
-    launch()

AdventureClient.py

@@ -112,7 +112,7 @@ class AdventureContext(CommonContext):
             if ': !' not in msg:
                 self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "ReceivedItems":
-            msg = f"Received {', '.join([self.item_names.lookup_in_slot(item.item) for item in args['items']])}"
+            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
             if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:

BaseClasses.py

@@ -728,7 +728,7 @@ class CollectionState():
                 return True
         return False
     
-    def has_from_list_unique(self, items: Iterable[str], player: int, count: int) -> bool:
+    def has_from_list_exclusive(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."""
         found: int = 0
@@ -743,7 +743,7 @@ class CollectionState():
         """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:
+    def count_from_list_exclusive(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)
 
@@ -758,7 +758,7 @@ class CollectionState():
                 return True
         return False
 
-    def has_group_unique(self, item_name_group: str, player: int, count: int = 1) -> bool:
+    def has_group_exclusive(self, item_name_group: str, player: int, count: int = 1) -> bool:
         """Returns True if the state contains at least `count` items present in a specified item group.
         Ignores duplicates of the same item.
         """
@@ -778,7 +778,7 @@ class CollectionState():
             for item_name in self.multiworld.worlds[player].item_name_groups[item_name_group]
         )
 
-    def count_group_unique(self, item_name_group: str, player: int) -> int:
+    def count_group_exclusive(self, item_name_group: str, player: int) -> int:
         """Returns the cumulative count of items from an item group present in state.
         Ignores duplicates of the same item."""
         player_prog_items = self.prog_items[player]

CommonClient.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import collections
 import copy
 import logging
 import asyncio
@@ -9,7 +8,6 @@ import sys
 import typing
 import time
 import functools
-import warnings
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -175,74 +173,10 @@ class CommonContext:
     items_handling: typing.Optional[int] = None
     want_slot_data: bool = True  # should slot_data be retrieved via Connect
 
-    class NameLookupDict:
-        """A specialized dict, with helper methods, for id -> name item/location data package lookups by game."""
-        def __init__(self, ctx: CommonContext, lookup_type: typing.Literal["item", "location"]):
-            self.ctx: CommonContext = ctx
-            self.lookup_type: typing.Literal["item", "location"] = lookup_type
-            self._unknown_item: typing.Callable[[int], str] = lambda key: f"Unknown {lookup_type} (ID: {key})"
-            self._archipelago_lookup: typing.Dict[int, str] = {}
-            self._flat_store: typing.Dict[int, str] = Utils.KeyedDefaultDict(self._unknown_item)
-            self._game_store: typing.Dict[str, typing.ChainMap[int, str]] = collections.defaultdict(
-                lambda: collections.ChainMap(self._archipelago_lookup, Utils.KeyedDefaultDict(self._unknown_item)))
-            self.warned: bool = False
-
-        # noinspection PyTypeChecker
-        def __getitem__(self, key: str) -> typing.Mapping[int, str]:
-            # TODO: In a future version (0.6.0?) this should be simplified by removing implicit id lookups support.
-            if isinstance(key, int):
-                if not self.warned:
-                    # Use warnings instead of logger to avoid deprecation message from appearing on user side.
-                    self.warned = True
-                    warnings.warn(f"Implicit name lookup by id only is deprecated and only supported to maintain "
-                                  f"backwards compatibility for now. If multiple games share the same id for a "
-                                  f"{self.lookup_type}, name could be incorrect. Please use "
-                                  f"`{self.lookup_type}_names.lookup_in_game()` or "
-                                  f"`{self.lookup_type}_names.lookup_in_slot()` instead.")
-                return self._flat_store[key]  # type: ignore
-
-            return self._game_store[key]
-
-        def __len__(self) -> int:
-            return len(self._game_store)
-
-        def __iter__(self) -> typing.Iterator[str]:
-            return iter(self._game_store)
-
-        def __repr__(self) -> str:
-            return self._game_store.__repr__()
-
-        def lookup_in_game(self, code: int, game_name: typing.Optional[str] = None) -> str:
-            """Returns the name for an item/location id in the context of a specific game or own game if `game` is
-            omitted.
-            """
-            if game_name is None:
-                game_name = self.ctx.game
-                assert game_name is not None, f"Attempted to lookup {self.lookup_type} with no game name available."
-
-            return self._game_store[game_name][code]
-
-        def lookup_in_slot(self, code: int, slot: typing.Optional[int] = None) -> str:
-            """Returns the name for an item/location id in the context of a specific slot or own slot if `slot` is
-            omitted.
-            """
-            if slot is None:
-                slot = self.ctx.slot
-                assert slot is not None, f"Attempted to lookup {self.lookup_type} with no slot info available."
-
-            return self.lookup_in_game(code, self.ctx.slot_info[slot].game)
-
-        def update_game(self, game: str, name_to_id_lookup_table: typing.Dict[str, int]) -> None:
-            """Overrides existing lookup tables for a particular game."""
-            id_to_name_lookup_table = Utils.KeyedDefaultDict(self._unknown_item)
-            id_to_name_lookup_table.update({code: name for name, code in name_to_id_lookup_table.items()})
-            self._game_store[game] = collections.ChainMap(self._archipelago_lookup, id_to_name_lookup_table)
-            self._flat_store.update(id_to_name_lookup_table)  # Only needed for legacy lookup method.
-            if game == "Archipelago":
-                # Keep track of the Archipelago data package separately so if it gets updated in a custom datapackage,
-                # it updates in all chain maps automatically.
-                self._archipelago_lookup.clear()
-                self._archipelago_lookup.update(id_to_name_lookup_table)
+    # data package
+    # Contents in flux until connection to server is made, to download correct data for this multiworld.
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
 
     # defaults
     starting_reconnect_delay: int = 5
@@ -297,7 +231,7 @@ class CommonContext:
     # message box reporting a loss of connection
     _messagebox_connection_loss: typing.Optional["kvui.MessageBox"] = None
 
-    def __init__(self, server_address: typing.Optional[str] = None, password: typing.Optional[str] = None) -> None:
+    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str]) -> None:
         # server state
         self.server_address = server_address
         self.username = None
@@ -337,9 +271,6 @@ class CommonContext:
         self.exit_event = asyncio.Event()
         self.watcher_event = asyncio.Event()
 
-        self.item_names = self.NameLookupDict(self, "item")
-        self.location_names = self.NameLookupDict(self, "location")
-
         self.jsontotextparser = JSONtoTextParser(self)
         self.rawjsontotextparser = RawJSONtoTextParser(self)
         self.update_data_package(network_data_package)
@@ -555,17 +486,19 @@ class CommonContext:
                         or remote_checksum != cache_checksum:
                     needed_updates.add(game)
                 else:
-                    self.update_game(cached_game, game)
+                    self.update_game(cached_game)
         if needed_updates:
             await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
 
-    def update_game(self, game_package: dict, game: str):
-        self.item_names.update_game(game, game_package["item_name_to_id"])
-        self.location_names.update_game(game, game_package["location_name_to_id"])
+    def update_game(self, game_package: dict):
+        for item_name, item_id in game_package["item_name_to_id"].items():
+            self.item_names[item_id] = item_name
+        for location_name, location_id in game_package["location_name_to_id"].items():
+            self.location_names[location_id] = location_name
 
     def update_data_package(self, data_package: dict):
         for game, game_data in data_package["games"].items():
-            self.update_game(game_data, game)
+            self.update_game(game_data)
 
     def consume_network_data_package(self, data_package: dict):
         self.update_data_package(data_package)

Fill.py

@@ -35,8 +35,8 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
     """
     :param multiworld: Multiworld to be filled.
     :param base_state: State assumed before fill.
-    :param locations: Locations to be filled with item_pool, gets mutated by removing locations that get filled.
-    :param item_pool: Items to fill into the locations, gets mutated by removing items that get placed.
+    :param locations: Locations to be filled with item_pool
+    :param item_pool: Items to fill into the locations
     :param single_player_placement: if true, can speed up placement if everything belongs to a single player
     :param lock: locations are set to locked as they are filled
     :param swap: if true, swaps of already place items are done in the event of a dead end
@@ -220,8 +220,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
 def remaining_fill(multiworld: MultiWorld,
                    locations: typing.List[Location],
                    itempool: typing.List[Item],
-                   name: str = "Remaining", 
-                   move_unplaceable_to_start_inventory: bool = False) -> None:
+                   name: str = "Remaining") -> None:
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
@@ -285,21 +284,13 @@ def remaining_fill(multiworld: MultiWorld,
 
     if unplaced_items and locations:
         # There are leftover unplaceable items and locations that won't accept them
-        if move_unplaceable_to_start_inventory:
-            last_batch = []
-            for item in unplaced_items:
-                logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
-                multiworld.push_precollected(item)
-                last_batch.append(multiworld.worlds[item.player].create_filler())
-            remaining_fill(multiworld, locations, unplaced_items, name + " Start Inventory Retry")
-        else:
-            raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
-                            f"Unplaced items:\n"
-                            f"{', '.join(str(item) for item in unplaced_items)}\n"
-                            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)}")
+        raise FillError(f"No more spots to place {len(unplaced_items)} items. Remaining locations are invalid.\n"
+                        f"Unplaced items:\n"
+                        f"{', '.join(str(item) for item in unplaced_items)}\n"
+                        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)}")
 
     itempool.extend(unplaced_items)
 
@@ -429,8 +420,7 @@ def distribute_early_items(multiworld: MultiWorld,
     return fill_locations, itempool
 
 
-def distribute_items_restrictive(multiworld: MultiWorld,
-                                 panic_method: typing.Literal["swap", "raise", "start_inventory"] = "swap") -> None:
+def distribute_items_restrictive(multiworld: MultiWorld) -> None:
     fill_locations = sorted(multiworld.get_unfilled_locations())
     multiworld.random.shuffle(fill_locations)
     # get items to distribute
@@ -480,29 +470,8 @@ def distribute_items_restrictive(multiworld: MultiWorld,
 
     if progitempool:
         # "advancement/progression fill"
-        if panic_method == "swap":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=True,
-                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
-        elif panic_method == "raise":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=False,
-                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
-        elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
-                             swap=False, allow_partial=True,
-                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
-            if progitempool:
-                for item in progitempool:
-                    logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
-                    multiworld.push_precollected(item)
-                    filleritempool.append(multiworld.worlds[item.player].create_filler())
-                logging.warning(f"{len(progitempool)} items moved to start inventory,"
-                                f" due to failure in Progression fill step.")
-                progitempool[:] = []
-
-        else:
-            raise ValueError(f"Generator Panic Method {panic_method} not recognized.")
+        fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, single_player_placement=multiworld.players == 1,
+                         name="Progression")
         if progitempool:
             raise FillError(
                 f"Not enough locations for progression items. "
@@ -517,9 +486,7 @@ def distribute_items_restrictive(multiworld: MultiWorld,
 
     inaccessible_location_rules(multiworld, multiworld.state, defaultlocations)
 
-    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded",
-                   move_unplaceable_to_start_inventory=panic_method=="start_inventory")
-
+    remaining_fill(multiworld, excludedlocations, filleritempool, "Remaining Excluded")
     if excludedlocations:
         raise FillError(
             f"Not enough filler items for excluded locations. "
@@ -528,8 +495,7 @@ def distribute_items_restrictive(multiworld: MultiWorld,
 
     restitempool = filleritempool + usefulitempool
 
-    remaining_fill(multiworld, defaultlocations, restitempool,
-                   move_unplaceable_to_start_inventory=panic_method=="start_inventory")
+    remaining_fill(multiworld, defaultlocations, restitempool)
 
     unplaced = restitempool
     unfilled = defaultlocations

Generate.py

@@ -9,7 +9,6 @@ import urllib.parse
 import urllib.request
 from collections import Counter
 from typing import Any, Dict, Tuple, Union
-from itertools import chain
 
 import ModuleUpdate
 
@@ -23,7 +22,9 @@ from Main import main as ERmain
 from settings import get_settings
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
 from worlds.alttp.EntranceRandomizer import parse_arguments
+from worlds.alttp.Text import TextTable
 from worlds.AutoWorld import AutoWorldRegister
+from worlds.generic import PlandoConnection
 from worlds import failed_world_loads
 
 
@@ -318,34 +319,18 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
     logging.debug(f'Applying {new_weights}')
     cleaned_weights = {}
     for option in new_weights:
-        option_name = option.lstrip("+-")
+        option_name = option.lstrip("+")
         if option.startswith("+") and option_name in weights:
             cleaned_value = weights[option_name]
             new_value = new_weights[option]
-            if isinstance(new_value, set):
+            if isinstance(new_value, (set, dict)):
                 cleaned_value.update(new_value)
             elif isinstance(new_value, list):
                 cleaned_value.extend(new_value)
-            elif isinstance(new_value, dict):
-                cleaned_value = dict(Counter(cleaned_value) + Counter(new_value))
             else:
                 raise Exception(f"Cannot apply merge to non-dict, set, or list type {option_name},"
                                 f" received {type(new_value).__name__}.")
             cleaned_weights[option_name] = cleaned_value
-        elif option.startswith("-") and option_name in weights:
-            cleaned_value = weights[option_name]
-            new_value = new_weights[option]
-            if isinstance(new_value, set):
-                cleaned_value.difference_update(new_value)
-            elif isinstance(new_value, list):
-                for element in new_value:
-                    cleaned_value.remove(element)
-            elif isinstance(new_value, dict):
-                cleaned_value = dict(Counter(cleaned_value) - Counter(new_value))
-            else:
-                raise Exception(f"Cannot apply remove to non-dict, set, or list type {option_name},"
-                                f" received {type(new_value).__name__}.")
-            cleaned_weights[option_name] = cleaned_value
         else:
             cleaned_weights[option_name] = new_weights[option]
     new_options = set(cleaned_weights) - set(weights)
@@ -430,6 +415,7 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
                 player_option = option.from_any(game_weights[option_key])
             else:
                 player_option = option.from_any(get_choice(option_key, game_weights))
+            del game_weights[option_key]
         else:
             player_option = option.from_any(option.default)  # call the from_any here to support default "random"
         setattr(ret, option_key, player_option)
@@ -443,9 +429,9 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
-    valid_keys = set()
+    valid_trigger_names = set()
     if "triggers" in weights:
-        weights = roll_triggers(weights, weights["triggers"], valid_keys)
+        weights = roll_triggers(weights, weights["triggers"], valid_trigger_names)
 
     requirements = weights.get("requires", {})
     if requirements:
@@ -480,14 +466,12 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
     world_type = AutoWorldRegister.world_types[ret.game]
     game_weights = weights[ret.game]
 
-    for weight in chain(game_weights, weights):
-        if weight.startswith("+"):
-            raise Exception(f"Merge tag cannot be used outside of trigger contexts. Found {weight}")
-        if weight.startswith("-"):
-            raise Exception(f"Remove tag cannot be used outside of trigger contexts. Found {weight}")
+    if any(weight.startswith("+") for weight in game_weights) or \
+       any(weight.startswith("+") for weight in weights):
+        raise Exception(f"Merge tag cannot be used outside of trigger contexts.")
 
     if "triggers" in game_weights:
-        weights = roll_triggers(weights, game_weights["triggers"], valid_keys)
+        weights = roll_triggers(weights, game_weights["triggers"], valid_trigger_names)
         game_weights = weights[ret.game]
 
     ret.name = get_choice('name', weights)
@@ -496,20 +480,42 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
 
     for option_key, option in world_type.options_dataclass.type_hints.items():
         handle_option(ret, game_weights, option_key, option, plando_options)
-        valid_keys.add(option_key)
     for option_key in game_weights:
-        if option_key in {"triggers", *valid_keys}:
+        if option_key in {"triggers", *valid_trigger_names}:
             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", [])
     if ret.game == "A Link to the Past":
-        roll_alttp_settings(ret, game_weights)
+        roll_alttp_settings(ret, game_weights, plando_options)
+    if PlandoOptions.connections in plando_options:
+        ret.plando_connections = []
+        options = game_weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice("entrance", placement),
+                    get_choice("exit", placement),
+                    get_choice("direction", placement, "both")
+                ))
 
     return ret
 
 
-def roll_alttp_settings(ret: argparse.Namespace, weights):
+def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
+
+    ret.plando_texts = {}
+    if PlandoOptions.texts in plando_options:
+        tt = TextTable()
+        tt.removeUnwantedText()
+        options = weights.get("plando_texts", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                at = str(get_choice_legacy("at", placement))
+                if at not in tt:
+                    raise Exception(f"No text target \"{at}\" found.")
+                ret.plando_texts[at] = str(get_choice_legacy("text", placement))
+
     ret.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:

Launcher.py

@@ -19,7 +19,7 @@ import sys
 import webbrowser
 from os.path import isfile
 from shutil import which
-from typing import Callable, Sequence, Union, Optional
+from typing import Sequence, Union, Optional
 
 import Utils
 import settings
@@ -160,12 +160,8 @@ def launch(exe, in_terminal=False):
     subprocess.Popen(exe)
 
 
-refresh_components: Optional[Callable[[], None]] = None
-
-
 def run_gui():
     from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
-    from kivy.core.window import Window
     from kivy.uix.image import AsyncImage
     from kivy.uix.relativelayout import RelativeLayout
 
@@ -173,8 +169,11 @@ def run_gui():
         base_title: str = "Archipelago Launcher"
         container: ContainerLayout
         grid: GridLayout
-        _tool_layout: Optional[ScrollBox] = None
-        _client_layout: Optional[ScrollBox] = None
+
+        _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
+        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
+        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
+        _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
 
         def __init__(self, ctx=None):
             self.title = self.base_title
@@ -182,7 +181,18 @@ def run_gui():
             self.icon = r"data/icon.png"
             super().__init__()
 
-        def _refresh_components(self) -> None:
+        def build(self):
+            self.container = ContainerLayout()
+            self.grid = GridLayout(cols=2)
+            self.container.add_widget(self.grid)
+            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
+            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
+            tool_layout = ScrollBox()
+            tool_layout.layout.orientation = "vertical"
+            self.grid.add_widget(tool_layout)
+            client_layout = ScrollBox()
+            client_layout.layout.orientation = "vertical"
+            self.grid.add_widget(client_layout)
 
             def build_button(component: Component) -> Widget:
                 """
@@ -207,49 +217,14 @@ def run_gui():
                     return box_layout
                 return button
 
-            # clear before repopulating
-            assert self._tool_layout and self._client_layout, "must call `build` first"
-            tool_children = reversed(self._tool_layout.layout.children)
-            for child in tool_children:
-                self._tool_layout.layout.remove_widget(child)
-            client_children = reversed(self._client_layout.layout.children)
-            for child in client_children:
-                self._client_layout.layout.remove_widget(child)
-
-            _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
-            _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
-            _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
-            _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
-
             for (tool, client) in itertools.zip_longest(itertools.chain(
-                _tools.items(), _miscs.items(), _adjusters.items()
-            ), _clients.items()):
+                    self._tools.items(), self._miscs.items(), self._adjusters.items()), self._clients.items()):
                 # column 1
                 if tool:
-                    self._tool_layout.layout.add_widget(build_button(tool[1]))
+                    tool_layout.layout.add_widget(build_button(tool[1]))
                 # column 2
                 if client:
-                    self._client_layout.layout.add_widget(build_button(client[1]))
-
-        def build(self):
-            self.container = ContainerLayout()
-            self.grid = GridLayout(cols=2)
-            self.container.add_widget(self.grid)
-            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
-            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
-            self._tool_layout = ScrollBox()
-            self._tool_layout.layout.orientation = "vertical"
-            self.grid.add_widget(self._tool_layout)
-            self._client_layout = ScrollBox()
-            self._client_layout.layout.orientation = "vertical"
-            self.grid.add_widget(self._client_layout)
-
-            self._refresh_components()
-
-            global refresh_components
-            refresh_components = self._refresh_components
-
-            Window.bind(on_drop_file=self._on_drop_file)
+                    client_layout.layout.add_widget(build_button(client[1]))
 
             return self.container
 
@@ -260,14 +235,6 @@ def run_gui():
             else:
                 launch(get_exe(button.component), button.component.cli)
 
-        def _on_drop_file(self, window: Window, filename: bytes, x: int, y: int) -> None:
-            """ When a patch file is dropped into the window, run the associated component. """
-            file, component = identify(filename.decode())
-            if file and component:
-                run_component(component, file)
-            else:
-                logging.warning(f"unable to identify component for {filename}")
-
         def _stop(self, *largs):
             # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
             # Closing the window explicitly cleans it up.
@@ -276,17 +243,10 @@ def run_gui():
 
     Launcher().run()
 
-    # avoiding Launcher reference leak
-    # and don't try to do something with widgets after window closed
-    global refresh_components
-    refresh_components = None
-
 
 def run_component(component: Component, *args):
     if component.func:
         component.func(*args)
-        if refresh_components:
-            refresh_components()
     elif component.script_name:
         subprocess.run([*get_exe(component.script_name), *args])
     else:

Main.py

@@ -13,7 +13,7 @@ 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 Options import StartInventoryPool
-from Utils import __version__, output_path, version_tuple, get_settings
+from Utils import __version__, output_path, version_tuple
 from settings import get_settings
 from worlds import AutoWorld
 from worlds.generic.Rules import exclusion_rules, locality_rules
@@ -272,7 +272,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     if multiworld.algorithm == 'flood':
         flood_items(multiworld)  # different algo, biased towards early game progress items
     elif multiworld.algorithm == 'balanced':
-        distribute_items_restrictive(multiworld, get_settings().generator.panic_method)
+        distribute_items_restrictive(multiworld)
 
     AutoWorld.call_all(multiworld, 'post_fill')
 
@@ -372,17 +372,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
 
                 checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
 
-                # get spheres -> filter address==None -> skip empty
-                spheres: List[Dict[int, Set[int]]] = []
-                for sphere in multiworld.get_spheres():
-                    current_sphere: Dict[int, Set[int]] = collections.defaultdict(set)
-                    for sphere_location in sphere:
-                        if type(sphere_location.address) is int:
-                            current_sphere[sphere_location.player].add(sphere_location.address)
-
-                    if current_sphere:
-                        spheres.append(dict(current_sphere))
-
                 multidata = {
                     "slot_data": slot_data,
                     "slot_info": slot_info,
@@ -397,7 +386,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                     "tags": ["AP"],
                     "minimum_versions": minimum_versions,
                     "seed_name": multiworld.seed_name,
-                    "spheres": spheres,
                     "datapackage": data_package,
                 }
                 AutoWorld.call_all(multiworld, "modify_multidata", multidata)

MultiServer.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import argparse
 import asyncio
 import collections
-import contextlib
 import copy
 import datetime
 import functools
@@ -38,7 +37,7 @@ except ImportError:
 
 import NetUtils
 import Utils
-from Utils import version_tuple, restricted_loads, Version, async_start, get_intended_text
+from Utils import version_tuple, restricted_loads, Version, async_start
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
     SlotType, LocationStore
 
@@ -169,20 +168,15 @@ class Context:
     slot_info: typing.Dict[int, NetworkSlot]
     generator_version = Version(0, 0, 0)
     checksums: typing.Dict[str, str]
-    item_names: typing.Dict[str, typing.Dict[int, str]] = (
-        collections.defaultdict(lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')))
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
     item_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
-    location_names: typing.Dict[str, typing.Dict[int, str]] = (
-        collections.defaultdict(lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')))
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
     location_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
     all_item_and_group_names: typing.Dict[str, typing.Set[str]]
     all_location_and_group_names: typing.Dict[str, typing.Set[str]]
-    non_hintable_names: typing.Dict[str, typing.AbstractSet[str]]
-    spheres: typing.List[typing.Dict[int, typing.Set[int]]]
-    """ each sphere is { player: { location_id, ... } } """
+    non_hintable_names: typing.Dict[str, typing.Set[str]]
     logger: logging.Logger
 
-
     def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                  hint_cost: int, item_cheat: bool, release_mode: str = "disabled", collect_mode="disabled",
                  remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
@@ -232,7 +226,7 @@ class Context:
         self.embedded_blacklist = {"host", "port"}
         self.client_ids: typing.Dict[typing.Tuple[int, int], datetime.datetime] = {}
         self.auto_save_interval = 60  # in seconds
-        self.auto_saver_thread: typing.Optional[threading.Thread] = None
+        self.auto_saver_thread = None
         self.save_dirty = False
         self.tags = ['AP']
         self.games: typing.Dict[int, str] = {}
@@ -244,7 +238,6 @@ class Context:
         self.stored_data = {}
         self.stored_data_notification_clients = collections.defaultdict(weakref.WeakSet)
         self.read_data = {}
-        self.spheres = []
 
         # init empty to satisfy linter, I suppose
         self.gamespackage = {}
@@ -269,31 +262,19 @@ class Context:
         for world_name, world in worlds.AutoWorldRegister.world_types.items():
             self.non_hintable_names[world_name] = world.hint_blacklist
 
-        for game_package in self.gamespackage.values():
-            # remove groups from data sent to clients
-            del game_package["item_name_groups"]
-            del game_package["location_name_groups"]
-
     def _init_game_data(self):
         for game_name, game_package in self.gamespackage.items():
             if "checksum" in game_package:
                 self.checksums[game_name] = game_package["checksum"]
             for item_name, item_id in game_package["item_name_to_id"].items():
-                self.item_names[game_name][item_id] = item_name
+                self.item_names[item_id] = item_name
             for location_name, location_id in game_package["location_name_to_id"].items():
-                self.location_names[game_name][location_id] = location_name
+                self.location_names[location_id] = location_name
             self.all_item_and_group_names[game_name] = \
                 set(game_package["item_name_to_id"]) | set(self.item_name_groups[game_name])
             self.all_location_and_group_names[game_name] = \
                 set(game_package["location_name_to_id"]) | set(self.location_name_groups.get(game_name, []))
 
-        archipelago_item_names = self.item_names["Archipelago"]
-        archipelago_location_names = self.location_names["Archipelago"]
-        for game in [game_name for game_name in self.gamespackage if game_name != "Archipelago"]:
-            # Add Archipelago items and locations to each data package.
-            self.item_names[game].update(archipelago_item_names)
-            self.location_names[game].update(archipelago_location_names)
-
     def item_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
         return self.gamespackage[game]["item_name_to_id"] if game in self.gamespackage else None
 
@@ -485,9 +466,6 @@ class Context:
         for game_name, data in self.location_name_groups.items():
             self.read_data[f"location_name_groups_{game_name}"] = lambda lgame=game_name: self.location_name_groups[lgame]
 
-        # sorted access spheres
-        self.spheres = decoded_obj.get("spheres", [])
-
     # saving
 
     def save(self, now=False) -> bool:
@@ -646,16 +624,6 @@ class Context:
         self.recheck_hints(team, slot)
         return self.hints[team, slot]
 
-    def get_sphere(self, player: int, location_id: int) -> int:
-        """Get sphere of a location, -1 if spheres are not available."""
-        if self.spheres:
-            for i, sphere in enumerate(self.spheres):
-                if location_id in sphere.get(player, set()):
-                    return i
-            raise KeyError(f"No Sphere found for location ID {location_id} belonging to player {player}. "
-                           f"Location or player may not exist.")
-        return -1
-
     def get_players_package(self):
         return [NetworkPlayer(t, p, self.get_aliased_name(t, p), n) for (t, p), n in self.player_names.items()]
 
@@ -798,7 +766,10 @@ async def on_client_connected(ctx: Context, client: Client):
         for slot, connected_clients in clients.items():
             if connected_clients:
                 name = ctx.player_names[team, slot]
-                players.append(NetworkPlayer(team, slot, ctx.name_aliases.get((team, slot), name), name))
+                players.append(
+                    NetworkPlayer(team, slot,
+                                  ctx.name_aliases.get((team, slot), name), name)
+                )
     games = {ctx.games[x] for x in range(1, len(ctx.games) + 1)}
     games.add("Archipelago")
     await ctx.send_msgs(client, [{
@@ -813,6 +784,8 @@ async def on_client_connected(ctx: Context, client: Client):
         'permissions': get_permissions(ctx),
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
+        'datapackage_versions': {game: game_data["version"] for game, game_data
+                                 in ctx.gamespackage.items() if game in games},
         'datapackage_checksums': {game: game_data["checksum"] for game, game_data
                                   in ctx.gamespackage.items() if game in games and "checksum" in game_data},
         'seed_name': ctx.seed_name,
@@ -1016,8 +989,8 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
             send_items_to(ctx, team, target_player, new_item)
 
             ctx.logger.info('(Team #%d) %s sent %s to %s (%s)' % (
-                team + 1, ctx.player_names[(team, slot)], ctx.item_names[ctx.slot_info[target_player].game][item_id],
-                ctx.player_names[(team, target_player)], ctx.location_names[ctx.slot_info[slot].game][location]))
+                team + 1, ctx.player_names[(team, slot)], ctx.item_names[item_id],
+                ctx.player_names[(team, target_player)], ctx.location_names[location]))
             info_text = json_format_send_event(new_item, target_player)
             ctx.broadcast_team(team, [info_text])
 
@@ -1071,8 +1044,8 @@ def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location
 
 def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
     text = f"[Hint]: {ctx.player_names[team, hint.receiving_player]}'s " \
-           f"{ctx.item_names[ctx.slot_info[hint.receiving_player].game][hint.item]} is " \
-           f"at {ctx.location_names[ctx.slot_info[hint.finding_player].game][hint.location]} " \
+           f"{ctx.item_names[hint.item]} is " \
+           f"at {ctx.location_names[hint.location]} " \
            f"in {ctx.player_names[team, hint.finding_player]}'s World"
 
     if hint.entrance:
@@ -1101,6 +1074,28 @@ def json_format_send_event(net_item: NetworkItem, receiving_player: int):
             "item": net_item}
 
 
+def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bool, str]:
+    picks = Utils.get_fuzzy_results(input_text, possible_answers, limit=2)
+    if len(picks) > 1:
+        dif = picks[0][1] - picks[1][1]
+        if picks[0][1] == 100:
+            return picks[0][0], True, "Perfect Match"
+        elif picks[0][1] < 75:
+            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+        elif dif > 5:
+            return picks[0][0], True, "Close Match"
+        else:
+            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+    else:
+        if picks[0][1] > 90:
+            return picks[0][0], True, "Only Option Match"
+        else:
+            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+
+
 class CommandMeta(type):
     def __new__(cls, name, bases, attrs):
         commands = attrs["commands"] = {}
@@ -1352,7 +1347,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         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.client.slot.game][item_id]
+                self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
                                                             for item_id in remaining_item_ids))
             else:
                 self.output("No remaining items found.")
@@ -1365,7 +1360,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
             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.client.slot.game][item_id]
+                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
                                                                 for item_id in remaining_item_ids))
                 else:
                     self.output("No remaining items found.")
@@ -1383,8 +1378,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            game = self.ctx.slot_info[self.client.slot].game
-            names = [self.ctx.location_names[game][location] for location in locations]
+            names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
                 location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
                 if filter_text in location_groups:  # location group name
@@ -1409,8 +1403,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            game = self.ctx.slot_info[self.client.slot].game
-            names = [self.ctx.location_names[game][location] for location in locations]
+            names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
                 location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
                 if filter_text in location_groups:  # location group name
@@ -1491,10 +1484,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
         elif input_text.isnumeric():
             game = self.ctx.games[self.client.slot]
             hint_id = int(input_text)
-            hint_name = self.ctx.item_names[game][hint_id] \
-                if not for_location and hint_id in self.ctx.item_names[game] \
-                else self.ctx.location_names[game][hint_id] \
-                if for_location and hint_id in self.ctx.location_names[game] \
+            hint_name = self.ctx.item_names[hint_id] \
+                if not for_location and hint_id in self.ctx.item_names \
+                else self.ctx.location_names[hint_id] \
+                if for_location and hint_id in self.ctx.location_names \
                 else None
             if hint_name in self.ctx.non_hintable_names[game]:
                 self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
@@ -1556,9 +1549,6 @@ class ClientMessageProcessor(CommonCommandProcessor):
                 self.ctx.random.shuffle(not_found_hints)
                 # By popular vote, make hints prefer non-local placements
                 not_found_hints.sort(key=lambda hint: int(hint.receiving_player != hint.finding_player))
-                # By another popular vote, prefer early sphere
-                not_found_hints.sort(key=lambda hint: self.ctx.get_sphere(hint.finding_player, hint.location),
-                                     reverse=True)
 
                 hints = found_hints + old_hints
                 while can_pay > 0:
@@ -1568,10 +1558,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
                     hints.append(hint)
                     can_pay -= 1
                     self.ctx.hints_used[self.client.team, self.client.slot] += 1
+                    points_available = get_client_points(self.ctx, self.client)
 
                 self.ctx.notify_hints(self.client.team, hints)
                 if not_found_hints:
-                    points_available = get_client_points(self.ctx, self.client)
                     if hints and cost and int((points_available // cost) == 0):
                         self.output(
                             f"There may be more hintables, however, you cannot afford to pay for any more. "
@@ -1932,6 +1922,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
     def _cmd_exit(self) -> bool:
         """Shutdown the server"""
         self.ctx.server.ws_server.close()
+        if self.ctx.shutdown_task:
+            self.ctx.shutdown_task.cancel()
         self.ctx.exit_event.set()
         return True
 
@@ -2289,8 +2281,7 @@ def parse_args() -> argparse.Namespace:
 
 
 async def auto_shutdown(ctx, to_cancel=None):
-    with contextlib.suppress(asyncio.TimeoutError):
-        await asyncio.wait_for(ctx.exit_event.wait(), ctx.auto_shutdown)
+    await asyncio.sleep(ctx.auto_shutdown)
 
     def inactivity_shutdown():
         ctx.server.ws_server.close()
@@ -2310,8 +2301,7 @@ async def auto_shutdown(ctx, to_cancel=None):
             if seconds < 0:
                 inactivity_shutdown()
             else:
-                with contextlib.suppress(asyncio.TimeoutError):
-                    await asyncio.wait_for(ctx.exit_event.wait(), seconds)
+                await asyncio.sleep(seconds)
 
 
 def load_server_cert(path: str, cert_key: typing.Optional[str]) -> "ssl.SSLContext":

NetUtils.py

@@ -247,7 +247,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_item_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.item_names.lookup_in_slot(item_id, node["player"])
+        node["text"] = self.ctx.item_names[item_id]
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
@@ -255,8 +255,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
-        location_id = int(node["text"])
-        node["text"] = self.ctx.location_names.lookup_in_slot(location_id, node["player"])
+        item_id = int(node["text"])
+        node["text"] = self.ctx.location_names[item_id]
         return self._handle_location_name(node)
 
     def _handle_entrance_name(self, node: JSONMessagePart):

Options.py

@@ -12,7 +12,6 @@ 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
 
@@ -897,228 +896,6 @@ class ItemSet(OptionSet):
     convert_name_groups = True
 
 
-class PlandoText(typing.NamedTuple):
-    at: str
-    text: typing.List[str]
-    percentage: int = 100
-
-
-PlandoTextsFromAnyType = typing.Union[
-    typing.Iterable[typing.Union[typing.Mapping[str, typing.Any], PlandoText, typing.Any]], typing.Any
-]
-
-
-class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
-    default = ()
-    supports_weighting = False
-    display_name = "Plando Texts"
-
-    def __init__(self, value: typing.Iterable[PlandoText]) -> None:
-        self.value = list(deepcopy(value))
-        super().__init__()
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        from BaseClasses import PlandoOptions
-        if self.value and not (PlandoOptions.texts & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando texts module is turned off, "
-                            f"so text for {player_name} will be ignored.")
-
-    @classmethod
-    def from_any(cls, data: PlandoTextsFromAnyType) -> Self:
-        texts: typing.List[PlandoText] = []
-        if isinstance(data, typing.Iterable):
-            for text in data:
-                if isinstance(text, typing.Mapping):
-                    if random.random() < float(text.get("percentage", 100)/100):
-                        at = text.get("at", None)
-                        if at is not None:
-                            given_text = text.get("text", [])
-                            if isinstance(given_text, str):
-                                given_text = [given_text]
-                            texts.append(PlandoText(
-                                at,
-                                given_text,
-                                text.get("percentage", 100)
-                            ))
-                elif isinstance(text, PlandoText):
-                    if random.random() < float(text.percentage/100):
-                        texts.append(text)
-                else:
-                    raise Exception(f"Cannot create plando text from non-dictionary type, got {type(text)}")
-            cls.verify_keys([text.at for text in texts])
-            return cls(texts)
-        else:
-            raise NotImplementedError(f"Cannot Convert from non-list, got {type(data)}")
-
-    @classmethod
-    def get_option_name(cls, value: typing.List[PlandoText]) -> str:
-        return str({text.at: " ".join(text.text) for text in value})
-
-    def __iter__(self) -> typing.Iterator[PlandoText]:
-        yield from self.value
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoText:
-        return self.value.__getitem__(index)
-
-    def __len__(self) -> int:
-        return self.value.__len__()
-
-
-class ConnectionsMeta(AssembleOptions):
-    def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, typing.Any]):
-        if name != "PlandoConnections":
-            assert "entrances" in attrs, f"Please define valid entrances for {name}"
-            attrs["entrances"] = frozenset((connection.lower() for connection in attrs["entrances"]))
-            assert "exits" in attrs, f"Please define valid exits for {name}"
-            attrs["exits"] = frozenset((connection.lower() for connection in attrs["exits"]))
-        if "__doc__" not in attrs:
-            attrs["__doc__"] = PlandoConnections.__doc__
-        cls = super().__new__(mcs, name, bases, attrs)
-        return cls
-
-
-class PlandoConnection(typing.NamedTuple):
-    class Direction:
-        entrance = "entrance"
-        exit = "exit"
-        both = "both"
-
-    entrance: str
-    exit: str
-    direction: typing.Literal["entrance", "exit", "both"]  # TODO: convert Direction to StrEnum once 3.8 is dropped
-    percentage: int = 100
-
-
-PlandoConFromAnyType = typing.Union[
-    typing.Iterable[typing.Union[typing.Mapping[str, typing.Any], PlandoConnection, typing.Any]], typing.Any
-]
-
-
-class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=ConnectionsMeta):
-    """Generic connections plando. Format is:
-    - entrance: "Entrance Name"
-      exit: "Exit Name"
-      direction: "Direction"
-      percentage: 100
-    Direction must be one of 'entrance', 'exit', or 'both', and defaults to 'both' if omitted.
-    Percentage is an integer from 1 to 100, and defaults to 100 when omitted."""
-
-    display_name = "Plando Connections"
-
-    default = ()
-    supports_weighting = False
-
-    entrances: typing.ClassVar[typing.AbstractSet[str]]
-    exits: typing.ClassVar[typing.AbstractSet[str]]
-
-    duplicate_exits: bool = False
-    """Whether or not exits should be allowed to be duplicate."""
-
-    def __init__(self, value: typing.Iterable[PlandoConnection]):
-        self.value = list(deepcopy(value))
-        super(PlandoConnections, self).__init__()
-
-    @classmethod
-    def validate_entrance_name(cls, entrance: str) -> bool:
-        return entrance.lower() in cls.entrances
-
-    @classmethod
-    def validate_exit_name(cls, exit: str) -> bool:
-        return exit.lower() in cls.exits
-
-    @classmethod
-    def can_connect(cls, entrance: str, exit: str) -> bool:
-        """Checks that a given entrance can connect to a given exit.
-        By default, this will always return true unless overridden."""
-        return True
-
-    @classmethod
-    def validate_plando_connections(cls, connections: typing.Iterable[PlandoConnection]) -> None:
-        used_entrances: typing.List[str] = []
-        used_exits: typing.List[str] = []
-        for connection in connections:
-            entrance = connection.entrance
-            exit = connection.exit
-            direction = connection.direction
-            if direction not in (PlandoConnection.Direction.entrance,
-                                 PlandoConnection.Direction.exit,
-                                 PlandoConnection.Direction.both):
-                raise ValueError(f"Unknown direction: {direction}")
-            if entrance in used_entrances:
-                raise ValueError(f"Duplicate Entrance {entrance} not allowed.")
-            if not cls.duplicate_exits and exit in used_exits:
-                raise ValueError(f"Duplicate Exit {exit} not allowed.")
-            used_entrances.append(entrance)
-            used_exits.append(exit)
-            if not cls.validate_entrance_name(entrance):
-                raise ValueError(f"{entrance.title()} is not a valid entrance.")
-            if not cls.validate_exit_name(exit):
-                raise ValueError(f"{exit.title()} is not a valid exit.")
-            if not cls.can_connect(entrance, exit):
-                raise ValueError(f"Connection between {entrance.title()} and {exit.title()} is invalid.")
-
-    @classmethod
-    def from_any(cls, data: PlandoConFromAnyType) -> Self:
-        if not isinstance(data, typing.Iterable):
-            raise Exception(f"Cannot create plando connections from non-List value, got {type(data)}.")
-
-        value: typing.List[PlandoConnection] = []
-        for connection in data:
-            if isinstance(connection, typing.Mapping):
-                percentage = connection.get("percentage", 100)
-                if random.random() < float(percentage / 100):
-                    entrance = connection.get("entrance", None)
-                    if is_iterable_except_str(entrance):
-                        entrance = random.choice(sorted(entrance))
-                    exit = connection.get("exit", None)
-                    if is_iterable_except_str(exit):
-                        exit = random.choice(sorted(exit))
-                    direction = connection.get("direction", "both")
-
-                    if not entrance or not exit:
-                        raise Exception("Plando connection must have an entrance and an exit.")
-                    value.append(PlandoConnection(
-                        entrance,
-                        exit,
-                        direction,
-                        percentage
-                    ))
-            elif isinstance(connection, PlandoConnection):
-                if random.random() < float(connection.percentage / 100):
-                    value.append(connection)
-            else:
-                raise Exception(f"Cannot create connection from non-Dict type, got {type(connection)}.")
-        cls.validate_plando_connections(value)
-        return cls(value)
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        from BaseClasses import PlandoOptions
-        if self.value and not (PlandoOptions.connections & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando connections module is turned off, "
-                            f"so connections for {player_name} will be ignored.")
-
-    @classmethod
-    def get_option_name(cls, value: typing.List[PlandoConnection]) -> str:
-        return ", ".join(["%s %s %s" % (connection.entrance,
-                                        "<=>" if connection.direction == PlandoConnection.Direction.both else
-                                        "<=" if connection.direction == PlandoConnection.Direction.exit else
-                                        "=>",
-                                        connection.exit) for connection in value])
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoConnection:
-        return self.value.__getitem__(index)
-
-    def __iter__(self) -> typing.Iterator[PlandoConnection]:
-        yield from self.value
-
-    def __len__(self) -> int:
-        return len(self.value)
-
-
 class Accessibility(Choice):
     """Set rules for reachability of your items/locations.
     Locations: ensure everything can be reached and acquired.
@@ -1133,10 +910,8 @@ class Accessibility(Choice):
 
 
 class ProgressionBalancing(NamedRange):
-    """
-    A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
-    A lower setting means more getting stuck. A higher setting means less getting stuck.
-    """
+    """A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
+    A lower setting means more getting stuck. A higher setting means less getting stuck."""
     default = 50
     range_start = 0
     range_end = 99
@@ -1209,7 +984,7 @@ class LocalItems(ItemSet):
 
 class NonLocalItems(ItemSet):
     """Forces these items to be outside their native world."""
-    display_name = "Non-local Items"
+    display_name = "Not Local Items"
 
 
 class StartInventory(ItemDict):
@@ -1272,8 +1047,7 @@ class ItemLinks(OptionList):
     ])
 
     @staticmethod
-    def verify_items(items: typing.List[str], item_link: str, pool_name: str, world,
-                     allow_item_groups: bool = True) -> typing.Set:
+    def verify_items(items: typing.List[str], item_link: str, pool_name: str, world, allow_item_groups: bool = True) -> typing.Set:
         pool = set()
         for item_name in items:
             if item_name not in world.item_names and (not allow_item_groups or item_name not in world.item_name_groups):
@@ -1356,41 +1130,9 @@ class OptionGroup(typing.NamedTuple):
     """Name of the group to categorize these options in for display on the WebHost and in generated YAMLS."""
     options: typing.List[typing.Type[Option[typing.Any]]]
     """Options to be in the defined group."""
-    start_collapsed: bool = False
-    """Whether the group will start collapsed on the WebHost options pages."""
 
 
-item_and_loc_options = [LocalItems, NonLocalItems, StartInventory, StartInventoryPool, StartHints,
-                        StartLocationHints, ExcludeLocations, PriorityLocations, ItemLinks]
-"""
-Options that are always populated in "Item & Location Options" Option Group. Cannot be moved to another group.
-If desired, a custom "Item & Location Options" Option Group can be defined, but only for adding additional options to
-it.
-"""
-
-
-def get_option_groups(world: typing.Type[World], visibility_level: Visibility = Visibility.template) -> typing.Dict[
-        str, typing.Dict[str, typing.Type[Option[typing.Any]]]]:
-    """Generates and returns a dictionary for the option groups of a specified world."""
-    option_groups = {option: option_group.name
-                     for option_group in world.web.option_groups
-                     for option in option_group.options}
-    # add a default option group for uncategorized options to get thrown into
-    ordered_groups = ["Game Options"]
-    [ordered_groups.append(group) for group in option_groups.values() if group not in ordered_groups]
-    grouped_options = {group: {} for group in ordered_groups}
-    for option_name, option in world.options_dataclass.type_hints.items():
-        if visibility_level & option.visibility:
-            grouped_options[option_groups.get(option, "Game Options")][option_name] = option
-
-    # if the world doesn't have any ungrouped options, this group will be empty so just remove it
-    if not grouped_options["Game Options"]:
-        del grouped_options["Game Options"]
-
-    return grouped_options
-
-
-def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True) -> None:
+def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True):
     import os
 
     import yaml
@@ -1428,7 +1170,17 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
-            grouped_options = get_option_groups(world)
+
+            option_groups = {option: option_group.name
+                             for option_group in world.web.option_groups
+                             for option in option_group.options}
+            ordered_groups = ["Game Options"]
+            [ordered_groups.append(group) for group in option_groups.values() if group not in ordered_groups]
+            grouped_options = {group: {} for group in ordered_groups}
+            for option_name, option in world.options_dataclass.type_hints.items():
+                if option.visibility >= Visibility.template:
+                    grouped_options[option_groups.get(option, "Game Options")][option_name] = option
+
             with open(local_path("data", "options.yaml")) as f:
                 file_data = f.read()
             res = Template(file_data).render(

README.md

@@ -1,10 +1,8 @@
 # [Archipelago](https://archipelago.gg) ![Discord Shield](https://discordapp.com/api/guilds/731205301247803413/widget.png?style=shield) | [Install](https://github.com/ArchipelagoMW/Archipelago/releases)
 
-Archipelago provides a generic framework for developing multiworld capability for game randomizers. In all cases,
-presently, Archipelago is also the randomizer itself.
+Archipelago provides a generic framework for developing multiworld capability for game randomizers. In all cases, presently, Archipelago is also the randomizer itself.
 
 Currently, the following games are supported:
-
 * The Legend of Zelda: A Link to the Past
 * Factorio
 * Minecraft
@@ -69,9 +67,7 @@ Currently, the following games are supported:
 * Yoshi's Island
 * Mario & Luigi: Superstar Saga
 * Bomb Rush Cyberfunk
-* Aquaria
 * Yu-Gi-Oh! Ultimate Masters: World Championship Tournament 2006
-* A Hat in Time
 
 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
@@ -79,57 +75,36 @@ windows binaries.
 
 ## History
 
-Archipelago is built upon a strong legacy of brilliant hobbyists. We want to honor that legacy by showing it here.
-The repositories which Archipelago is built upon, inspired by, or otherwise owes its gratitude to are:
+Archipelago is built upon a strong legacy of brilliant hobbyists. We want to honor that legacy by showing it here. The repositories which Archipelago is built upon, inspired by, or otherwise owes its gratitude to are:
 
 * [bonta0's MultiWorld](https://github.com/Bonta0/ALttPEntranceRandomizer/tree/multiworld_31)
 * [AmazingAmpharos' Entrance Randomizer](https://github.com/AmazingAmpharos/ALttPEntranceRandomizer)
 * [VT Web Randomizer](https://github.com/sporchia/alttp_vt_randomizer)
 * [Dessyreqt's alttprandomizer](https://github.com/Dessyreqt/alttprandomizer)
-* [Zarby89's](https://github.com/Ijwu/Enemizer/commits?author=Zarby89)
-  and [sosuke3's](https://github.com/Ijwu/Enemizer/commits?author=sosuke3) contributions to Enemizer, which make up the
-  vast majority of Enemizer contributions.
+* [Zarby89's](https://github.com/Ijwu/Enemizer/commits?author=Zarby89) and [sosuke3's](https://github.com/Ijwu/Enemizer/commits?author=sosuke3) contributions to Enemizer, which make the vast majority of Enemizer contributions.
 
-We recognize that there is a strong community of incredibly smart people that have come before us and helped pave the
-path. Just because one person's name may be in a repository title does not mean that only one person made that project
-happen. We can't hope to perfectly cover every single contribution that lead up to Archipelago, but we hope to honor
-them fairly.
+We recognize that there is a strong community of incredibly smart people that have come before us and helped pave the path. Just because one person's name may be in a repository title does not mean that only one person made that project happen. We can't hope to perfectly cover every single contribution that lead up to Archipelago but we hope to honor them fairly.
 
 ### Path to the Archipelago
-
-Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEntranceRandomizer (this project has a
-long legacy of its own, please check it out linked above) on January 12, 2020. The repository was then named to
-_MultiWorld-Utilities_ to better encompass its intended function. As Archipelago matured, then known as
-"Berserker's MultiWorld" by some, we found it necessary to transform our repository into a root level repository
-(as opposed to a 'forked repo') and change the name (which came later) to better reflect our project.
+Archipelago was directly forked from bonta0's `multiworld_31` branch of ALttPEntranceRandomizer (this project has a long legacy of its own, please check it out linked above) on January 12, 2020. The repository was then named to _MultiWorld-Utilities_ to better encompass its intended function. As Archipelago matured, then known as "Berserker's MultiWorld" by some, we found it necessary to transform our repository into a root level repository (as opposed to a 'forked repo') and change the name (which came later) to better reflect our project.
 
 ## Running Archipelago
+For most people, all you need to do is head over to the [releases](https://github.com/ArchipelagoMW/Archipelago/releases) page then download and run the appropriate installer, or AppImage for Linux-based systems.
 
-For most people, all you need to do is head over to
-the [releases page](https://github.com/ArchipelagoMW/Archipelago/releases), then download and run the appropriate
-installer, or AppImage for Linux-based systems.
-
-If you are a developer or are running on a platform with no compiled releases available, please see our doc on
-[running Archipelago from source](docs/running%20from%20source.md).
+If you are a developer or are running on a platform with no compiled releases available, please see our doc on [running Archipelago from source](docs/running%20from%20source.md).
 
 ## Related Repositories
-
-This project makes use of multiple other projects. We wouldn't be here without these other repositories and the
-contributions of their developers, past and present.
+This project makes use of multiple other projects. We wouldn't be here without these other repositories and the contributions of their developers, past and present.
 
 * [z3randomizer](https://github.com/ArchipelagoMW/z3randomizer)
 * [Enemizer](https://github.com/Ijwu/Enemizer)
 * [Ocarina of Time Randomizer](https://github.com/TestRunnerSRL/OoT-Randomizer)
 
 ## Contributing
-
-To contribute to Archipelago, including the WebHost, core program, or by adding a new game, see our
-[Contributing guidelines](/docs/contributing.md).
+For contribution guidelines, please see our [Contributing doc.](/docs/contributing.md)
 
 ## FAQ
-
-For Frequently asked questions, please see the website's [FAQ Page](https://archipelago.gg/faq/en/).
+For Frequently asked questions, please see the website's [FAQ Page.](https://archipelago.gg/faq/en/)
 
 ## Code of Conduct
-
-Please refer to our [code of conduct](/docs/code_of_conduct.md).
+Please refer to our [code of conduct.](/docs/code_of_conduct.md)

UndertaleClient.py

@@ -247,8 +247,8 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
             with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
                 toDraw = ""
                 for i in range(20):
-                    if i < len(str(ctx.item_names.lookup_in_slot(l.item))):
-                        toDraw += str(ctx.item_names.lookup_in_slot(l.item))[i]
+                    if i < len(str(ctx.item_names[l.item])):
+                        toDraw += str(ctx.item_names[l.item])[i]
                     else:
                         break
                 f.write(toDraw)

Utils.py

@@ -46,7 +46,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.5.0"
+__version__ = "0.4.6"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -101,7 +101,8 @@ def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[
 
     @functools.wraps(function)
     def wrap(self: S, arg: T) -> RetType:
-        cache: Optional[Dict[T, RetType]] = getattr(self, cache_name, None)
+        cache: Optional[Dict[T, RetType]] = typing.cast(Optional[Dict[T, RetType]],
+                                                        getattr(self, cache_name, None))
         if cache is None:
             res = function(self, arg)
             setattr(self, cache_name, {arg: res})
@@ -208,11 +209,10 @@ def output_path(*path: str) -> str:
 
 def open_file(filename: typing.Union[str, "pathlib.Path"]) -> None:
     if is_windows:
-        os.startfile(filename)  # type: ignore
+        os.startfile(filename)
     else:
         from shutil import which
         open_command = which("open") if is_macos else (which("xdg-open") or which("gnome-open") or which("kde-open"))
-        assert open_command, "Didn't find program for open_file! Please report this together with system details."
         subprocess.call([open_command, filename])
 
 
@@ -300,21 +300,21 @@ def get_options() -> Settings:
     return get_settings()
 
 
-def persistent_store(category: str, key: str, value: typing.Any):
+def persistent_store(category: str, key: typing.Any, value: typing.Any):
     path = user_path("_persistent_storage.yaml")
-    storage = persistent_load()
-    category_dict = storage.setdefault(category, {})
-    category_dict[key] = value
+    storage: dict = persistent_load()
+    category = storage.setdefault(category, {})
+    category[key] = value
     with open(path, "wt") as f:
         f.write(dump(storage, Dumper=Dumper))
 
 
-def persistent_load() -> Dict[str, Dict[str, Any]]:
-    storage: Union[Dict[str, Dict[str, Any]], None] = getattr(persistent_load, "storage", None)
+def persistent_load() -> typing.Dict[str, dict]:
+    storage = getattr(persistent_load, "storage", None)
     if storage:
         return storage
     path = user_path("_persistent_storage.yaml")
-    storage = {}
+    storage: dict = {}
     if os.path.exists(path):
         try:
             with open(path, "r") as f:
@@ -323,7 +323,7 @@ def persistent_load() -> Dict[str, Dict[str, Any]]:
             logging.debug(f"Could not read store: {e}")
     if storage is None:
         storage = {}
-    setattr(persistent_load, "storage", storage)
+    persistent_load.storage = storage
     return storage
 
 
@@ -365,7 +365,6 @@ def store_data_package_for_checksum(game: str, data: typing.Dict[str, Any]) -> N
         except Exception as e:
             logging.debug(f"Could not store data package: {e}")
 
-
 def get_default_adjuster_settings(game_name: str) -> Namespace:
     import LttPAdjuster
     adjuster_settings = Namespace()
@@ -384,9 +383,7 @@ def get_adjuster_settings(game_name: str) -> Namespace:
     default_settings = get_default_adjuster_settings(game_name)
 
     # Fill in any arguments from the argparser that we haven't seen before
-    return Namespace(**vars(adjuster_settings), **{
-        k: v for k, v in vars(default_settings).items() if k not in vars(adjuster_settings)
-    })
+    return Namespace(**vars(adjuster_settings), **{k:v for k,v in vars(default_settings).items() if k not in vars(adjuster_settings)})
 
 
 @cache_argsless
@@ -410,13 +407,13 @@ safe_builtins = frozenset((
 class RestrictedUnpickler(pickle.Unpickler):
     generic_properties_module: Optional[object]
 
-    def __init__(self, *args: Any, **kwargs: Any) -> None:
+    def __init__(self, *args, **kwargs):
         super(RestrictedUnpickler, self).__init__(*args, **kwargs)
         self.options_module = importlib.import_module("Options")
         self.net_utils_module = importlib.import_module("NetUtils")
         self.generic_properties_module = None
 
-    def find_class(self, module: str, name: str) -> type:
+    def find_class(self, module, name):
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
         # used by MultiServer -> savegame/multidata
@@ -440,7 +437,7 @@ class RestrictedUnpickler(pickle.Unpickler):
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
 
 
-def restricted_loads(s: bytes) -> Any:
+def restricted_loads(s):
     """Helper function analogous to pickle.loads()."""
     return RestrictedUnpickler(io.BytesIO(s)).load()
 
@@ -458,15 +455,6 @@ class KeyedDefaultDict(collections.defaultdict):
     """defaultdict variant that uses the missing key as argument to default_factory"""
     default_factory: typing.Callable[[typing.Any], typing.Any]
 
-    def __init__(self,
-                 default_factory: typing.Callable[[Any], Any] = None,
-                 seq: typing.Union[typing.Mapping, typing.Iterable, None] = None,
-                 **kwargs):
-        if seq is not None:
-            super().__init__(default_factory, seq, **kwargs)
-        else:
-            super().__init__(default_factory, **kwargs)
-
     def __missing__(self, key):
         self[key] = value = self.default_factory(key)
         return value
@@ -505,7 +493,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
     file_handler.setFormatter(logging.Formatter(log_format))
 
     class Filter(logging.Filter):
-        def __init__(self, filter_name: str, condition: typing.Callable[[logging.LogRecord], bool]) -> None:
+        def __init__(self, filter_name, condition):
             super().__init__(filter_name)
             self.condition = condition
 
@@ -556,7 +544,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
     )
 
 
-def stream_input(stream: typing.TextIO, queue: "asyncio.Queue[str]"):
+def stream_input(stream, queue):
     def queuer():
         while 1:
             try:
@@ -584,7 +572,7 @@ class VersionException(Exception):
     pass
 
 
-def chaining_prefix(index: int, labels: typing.Sequence[str]) -> str:
+def chaining_prefix(index: int, labels: typing.Tuple[str]) -> str:
     text = ""
     max_label = len(labels) - 1
     while index > max_label:
@@ -607,7 +595,7 @@ def format_SI_prefix(value, power=1000, power_labels=("", "k", "M", "G", "T", "P
     return f"{value.quantize(decimal.Decimal('1.00'))} {chaining_prefix(n, power_labels)}"
 
 
-def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit: typing.Optional[int] = None) \
+def get_fuzzy_results(input_word: str, wordlist: typing.Sequence[str], limit: typing.Optional[int] = None) \
         -> typing.List[typing.Tuple[str, int]]:
     import jellyfish
 
@@ -615,55 +603,21 @@ def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit:
         return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
                 / max(len(word1), len(word2)))
 
-    limit = limit if limit else len(word_list)
+    limit: int = limit if limit else len(wordlist)
     return list(
         map(
             lambda container: (container[0], int(container[1]*100)),  # convert up to limit to int %
             sorted(
-                map(lambda candidate: (candidate, get_fuzzy_ratio(input_word, candidate)), word_list),
+                map(lambda candidate:
+                    (candidate,  get_fuzzy_ratio(input_word, candidate)),
+                    wordlist),
                 key=lambda element: element[1],
-                reverse=True
-            )[0:limit]
+                reverse=True)[0:limit]
         )
     )
 
 
-def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bool, str]:
-    picks = get_fuzzy_results(input_text, possible_answers, limit=2)
-    if len(picks) > 1:
-        dif = picks[0][1] - picks[1][1]
-        if picks[0][1] == 100:
-            return picks[0][0], True, "Perfect Match"
-        elif picks[0][1] < 75:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-        elif dif > 5:
-            return picks[0][0], True, "Close Match"
-        else:
-            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-    else:
-        if picks[0][1] > 90:
-            return picks[0][0], True, "Only Option Match"
-        else:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-
-
-def get_input_text_from_response(text: str, command: str) -> typing.Optional[str]:
-    if "did you mean " in text:
-        for question in ("Didn't find something that closely matches",
-                         "Too many close matches"):
-            if text.startswith(question):
-                name = get_text_between(text, "did you mean '",
-                                        "'? (")
-                return f"!{command} {name}"
-    elif text.startswith("Missing: "):
-        return text.replace("Missing: ", "!hint_location ")
-    return None
-
-
-def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
+def open_filename(title: str, filetypes: typing.Sequence[typing.Tuple[str, typing.Sequence[str]]], suggest: str = "") \
         -> typing.Optional[str]:
     logging.info(f"Opening file input dialog for {title}.")
 
@@ -780,7 +734,7 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
         root.update()
 
 
-def title_sorted(data: typing.Iterable, key=None, ignore: typing.AbstractSet[str] = frozenset(("a", "the"))):
+def title_sorted(data: typing.Sequence, key=None, ignore: typing.Set = frozenset(("a", "the"))):
     """Sorts a sequence of text ignoring typical articles like "a" or "the" in the beginning."""
     def sorter(element: Union[str, Dict[str, Any]]) -> str:
         if (not isinstance(element, str)):
@@ -834,7 +788,7 @@ class DeprecateDict(dict):
     log_message: str
     should_error: bool
 
-    def __init__(self, message: str, error: bool = False) -> None:
+    def __init__(self, message, error: bool = False) -> None:
         self.log_message = message
         self.should_error = error
         super().__init__()

WargrooveClient.py

@@ -176,7 +176,7 @@ class WargrooveContext(CommonContext):
                 if not os.path.isfile(path):
                     open(path, 'w').close()
                     # Announcing commander unlocks
-                    item_name = self.item_names.lookup_in_slot(network_item.item)
+                    item_name = self.item_names[network_item.item]
                     if item_name in faction_table.keys():
                         for commander in faction_table[item_name]:
                             logger.info(f"{commander.name} has been unlocked!")
@@ -197,7 +197,7 @@ class WargrooveContext(CommonContext):
                     open(print_path, 'w').close()
                     with open(print_path, 'w') as f:
                         f.write("Received " +
-                                self.item_names.lookup_in_slot(network_item.item) +
+                                self.item_names[network_item.item] +
                                 " from " +
                                 self.player_names[network_item.player])
                         f.close()
@@ -342,7 +342,7 @@ class WargrooveContext(CommonContext):
             faction_items = 0
             faction_item_names = [faction + ' Commanders' for faction in faction_table.keys()]
             for network_item in self.items_received:
-                if self.item_names.lookup_in_slot(network_item.item) in faction_item_names:
+                if self.item_names[network_item.item] in faction_item_names:
                     faction_items += 1
             starting_groove = (faction_items - 1) * self.starting_groove_multiplier
             # Must be an integer larger than 0

WebHost.py

@@ -12,9 +12,6 @@ ModuleUpdate.update()
 import Utils
 import settings
 
-if typing.TYPE_CHECKING:
-    from flask import Flask
-
 Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
@@ -22,7 +19,7 @@ if not os.path.exists(configpath):  # fall back to config.yaml in home
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
-def get_app() -> "Flask":
+def get_app():
     from WebHostLib import register, cache, app as raw_app
     from WebHostLib.models import db
 

WebHostLib/api/__init__.py

@@ -56,6 +56,15 @@ def get_datapackage():
     return network_data_package
 
 
+@api_endpoints.route('/datapackage_version')
+@cache.cached()
+def get_datapackage_versions():
+    from worlds import AutoWorldRegister
+
+    version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
+    return version_package
+
+
 @api_endpoints.route('/datapackage_checksum')
 @cache.cached()
 def get_datapackage_checksums():

WebHostLib/customserver.py

@@ -106,9 +106,9 @@ class WebHostContext(Context):
         static_gamespackage = self.gamespackage  # this is shared across all rooms
         static_item_name_groups = self.item_name_groups
         static_location_name_groups = self.location_name_groups
-        self.gamespackage = {"Archipelago": static_gamespackage.get("Archipelago", {})}  # this may be modified by _load
-        self.item_name_groups = {"Archipelago": static_item_name_groups.get("Archipelago", {})}
-        self.location_name_groups = {"Archipelago": static_location_name_groups.get("Archipelago", {})}
+        self.gamespackage = {"Archipelago": static_gamespackage["Archipelago"]}  # this may be modified by _load
+        self.item_name_groups = {}
+        self.location_name_groups = {}
 
         for game in list(multidata.get("datapackage", {})):
             game_data = multidata["datapackage"][game]
@@ -168,28 +168,17 @@ def get_random_port():
 def get_static_server_data() -> dict:
     import worlds
     data = {
-        "non_hintable_names": {
-            world_name: world.hint_blacklist
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
-        "gamespackage": {
-            world_name: {
-                key: value
-                for key, value in game_package.items()
-                if key not in ("item_name_groups", "location_name_groups")
-            }
-            for world_name, game_package in worlds.network_data_package["games"].items()
-        },
-        "item_name_groups": {
-            world_name: world.item_name_groups
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
-        "location_name_groups": {
-            world_name: world.location_name_groups
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
+        "non_hintable_names": {},
+        "gamespackage": worlds.network_data_package["games"],
+        "item_name_groups": {world_name: world.item_name_groups for world_name, world in
+                             worlds.AutoWorldRegister.world_types.items()},
+        "location_name_groups": {world_name: world.location_name_groups for world_name, world in
+                                 worlds.AutoWorldRegister.world_types.items()},
     }
 
+    for world_name, world in worlds.AutoWorldRegister.world_types.items():
+        data["non_hintable_names"][world_name] = world.hint_blacklist
+
     return data
 
 
@@ -277,30 +266,19 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     ctx.logger.exception("Could not determine port. Likely hosting failure.")
                 with db_session:
                     ctx.auto_shutdown = Room.get(id=room_id).timeout
-                if ctx.saving:
-                    setattr(asyncio.current_task(), "save", lambda: ctx._save(True))
                 ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
                 await ctx.shutdown_task
 
             except (KeyboardInterrupt, SystemExit):
-                if ctx.saving:
-                    ctx._save()
-                    setattr(asyncio.current_task(), "save", None)
-            except Exception as e:
+                pass
+            except Exception:
                 with db_session:
                     room = Room.get(id=room_id)
                     room.last_port = -1
-                logger.exception(e)
                 raise
-            else:
-                if ctx.saving:
-                    ctx._save()
-                    setattr(asyncio.current_task(), "save", None)
             finally:
                 try:
-                    ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
-                    ctx.exit_event.set()  # make sure the saving thread stops at some point
-                    # NOTE: async saving should probably be an async task and could be merged with shutdown_task
+                    ctx._save()
                     with (db_session):
                         # ensure the Room does not spin up again on its own, minute of safety buffer
                         room = Room.get(id=room_id)
@@ -312,32 +290,13 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     rooms_shutting_down.put(room_id)
 
     class Starter(threading.Thread):
-        _tasks: typing.List[asyncio.Future]
-
-        def __init__(self):
-            super().__init__()
-            self._tasks = []
-
-        def _done(self, task: asyncio.Future):
-            self._tasks.remove(task)
-            task.result()
-
         def run(self):
             while 1:
                 next_room = rooms_to_run.get(block=True,  timeout=None)
-                task = asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
-                self._tasks.append(task)
-                task.add_done_callback(self._done)
+                asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
                 logging.info(f"Starting room {next_room} on {name}.")
 
     starter = Starter()
     starter.daemon = True
     starter.start()
-    try:
-        loop.run_forever()
-    finally:
-        # save all tasks that want to be saved during shutdown
-        for task in asyncio.all_tasks(loop):
-            save: typing.Optional[typing.Callable[[], typing.Any]] = getattr(task, "save", None)
-            if save:
-                save()
+    loop.run_forever()

WebHostLib/generate.py

@@ -6,7 +6,7 @@ import random
 import tempfile
 import zipfile
 from collections import Counter
-from typing import Any, Dict, List, Optional, Union, Set
+from typing import Any, Dict, List, Optional, Union
 
 from flask import flash, redirect, render_template, request, session, url_for
 from pony.orm import commit, db_session
@@ -16,7 +16,6 @@ from Generate import PlandoOptions, handle_name
 from Main import main as ERmain
 from Utils import __version__
 from WebHostLib import app
-from settings import ServerOptions, GeneratorOptions
 from worlds.alttp.EntranceRandomizer import parse_arguments
 from .check import get_yaml_data, roll_options
 from .models import Generation, STATE_ERROR, STATE_QUEUED, Seed, UUID
@@ -24,22 +23,25 @@ from .upload import upload_zip_to_db
 
 
 def get_meta(options_source: dict, race: bool = False) -> Dict[str, Union[List[str], Dict[str, Any]]]:
-    plando_options: Set[str] = set()
-    for substr in ("bosses", "items", "connections", "texts"):
-        if options_source.get(f"plando_{substr}", substr in GeneratorOptions.plando_options):
-            plando_options.add(substr)
+    plando_options = {
+        options_source.get("plando_bosses", ""),
+        options_source.get("plando_items", ""),
+        options_source.get("plando_connections", ""),
+        options_source.get("plando_texts", "")
+    }
+    plando_options -= {""}
 
     server_options = {
-        "hint_cost": int(options_source.get("hint_cost", ServerOptions.hint_cost)),
-        "release_mode": options_source.get("release_mode", ServerOptions.release_mode),
-        "remaining_mode": options_source.get("remaining_mode", ServerOptions.remaining_mode),
-        "collect_mode": options_source.get("collect_mode", ServerOptions.collect_mode),
-        "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
+        "hint_cost": int(options_source.get("hint_cost", 10)),
+        "release_mode": options_source.get("release_mode", "goal"),
+        "remaining_mode": options_source.get("remaining_mode", "disabled"),
+        "collect_mode": options_source.get("collect_mode", "disabled"),
+        "item_cheat": bool(int(options_source.get("item_cheat", 1))),
         "server_password": options_source.get("server_password", None),
     }
     generator_options = {
-        "spoiler": int(options_source.get("spoiler", GeneratorOptions.spoiler)),
-        "race": race,
+        "spoiler": int(options_source.get("spoiler", 0)),
+        "race": race
     }
 
     if race:

WebHostLib/options.py

@@ -11,7 +11,6 @@ import Options
 from Utils import local_path
 from worlds.AutoWorld import AutoWorldRegister
 from . import app, cache
-from .generate import get_meta
 
 
 def create() -> None:
@@ -28,21 +27,26 @@ def get_world_theme(game_name: str) -> str:
 
 
 def render_options_page(template: str, world_name: str, is_complex: bool = False) -> Union[Response, str]:
+    visibility_flag = Options.Visibility.complex_ui if is_complex else Options.Visibility.simple_ui
     world = AutoWorldRegister.world_types[world_name]
     if world.hidden or world.web.options_page is False:
         return redirect("games")
-    visibility_flag = Options.Visibility.complex_ui if is_complex else Options.Visibility.simple_ui
 
-    start_collapsed = {"Game Options": False}
-    for group in world.web.option_groups:
-        start_collapsed[group.name] = group.start_collapsed
+    option_groups = {option: option_group.name
+                     for option_group in world.web.option_groups
+                     for option in option_group.options}
+    ordered_groups = ["Game Options", *[group.name for group in world.web.option_groups]]
+    grouped_options = {group: {} for group in ordered_groups}
+    for option_name, option in world.options_dataclass.type_hints.items():
+        # Exclude settings from options pages if their visibility is disabled
+        if visibility_flag in option.visibility:
+            grouped_options[option_groups.get(option, "Game Options")][option_name] = option
 
     return render_template(
         template,
         world_name=world_name,
         world=world,
-        option_groups=Options.get_option_groups(world, visibility_level=visibility_flag),
-        start_collapsed=start_collapsed,
+        option_groups=grouped_options,
         issubclass=issubclass,
         Options=Options,
         theme=get_world_theme(world_name),
@@ -51,7 +55,7 @@ def render_options_page(template: str, world_name: str, is_complex: bool = False
 
 def generate_game(options: Dict[str, Union[dict, str]]) -> Union[Response, str]:
     from .generate import start_generation
-    return start_generation(options, get_meta({}))
+    return start_generation(options, {"plando_options": ["items", "connections", "texts", "bosses"]})
 
 
 def send_yaml(player_name: str, formatted_options: dict) -> Response:
@@ -76,34 +80,6 @@ def test_ordered(obj):
 def option_presets(game: str) -> Response:
     world = AutoWorldRegister.world_types[game]
 
-    presets = {}
-    for preset_name, preset in world.web.options_presets.items():
-        presets[preset_name] = {}
-        for preset_option_name, preset_option in preset.items():
-            if preset_option == "random":
-                presets[preset_name][preset_option_name] = preset_option
-                continue
-
-            option = world.options_dataclass.type_hints[preset_option_name].from_any(preset_option)
-            if isinstance(option, Options.NamedRange) and isinstance(preset_option, str):
-                assert preset_option in option.special_range_names, \
-                    f"Invalid preset value '{preset_option}' for '{preset_option_name}' in '{preset_name}'. " \
-                    f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
-
-                presets[preset_name][preset_option_name] = option.value
-            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.ItemDict)):
-                presets[preset_name][preset_option_name] = option.value
-            elif isinstance(preset_option, str):
-                # Ensure the option value is valid for Choice and Toggle options
-                assert option.name_lookup[option.value] == preset_option, \
-                    f"Invalid option value '{preset_option}' for '{preset_option_name}' in preset '{preset_name}'. " \
-                    f"Values must not be resolved to a different option via option.from_text (or an alias)."
-                # Use the name of the option
-                presets[preset_name][preset_option_name] = option.current_key
-            else:
-                # Use the name of the option
-                presets[preset_name][preset_option_name] = option.current_key
-
     class SetEncoder(json.JSONEncoder):
         def default(self, obj):
             from collections.abc import Set
@@ -111,7 +87,7 @@ def option_presets(game: str) -> Response:
                 return list(obj)
             return json.JSONEncoder.default(self, obj)
 
-    json_data = json.dumps(presets, cls=SetEncoder)
+    json_data = json.dumps(world.web.options_presets, cls=SetEncoder)
     response = Response(json_data)
     response.headers["Content-Type"] = "application/json"
     return response
@@ -197,9 +173,9 @@ def generate_yaml(game: str):
             else:
                 options[key] = val
 
+        # Detect and build ItemDict options from their name pattern
         for key, val in options.copy().items():
             key_parts = key.rsplit("||", 2)
-            # Detect and build ItemDict options from their name pattern
             if key_parts[-1] == "qty":
                 if key_parts[0] not in options:
                     options[key_parts[0]] = {}
@@ -207,13 +183,6 @@ def generate_yaml(game: str):
                     options[key_parts[0]][key_parts[1]] = int(val)
                 del options[key]
 
-            # Detect keys which end with -custom, indicating a TextChoice with a possible custom value
-            elif key_parts[-1].endswith("-custom"):
-                if val:
-                    options[key_parts[-1][:-7]] = val
-
-                del options[key]
-
         # Detect random-* keys and set their options accordingly
         for key, val in options.copy().items():
             if key.startswith("random-"):

WebHostLib/requirements.txt

@@ -1,10 +1,9 @@
-flask>=3.0.3
-werkzeug>=3.0.3
+flask>=3.0.0
 pony>=0.7.17
-waitress>=3.0.0
-Flask-Caching>=2.3.0
-Flask-Compress>=1.15
-Flask-Limiter>=3.7.0
+waitress>=2.1.2
+Flask-Caching>=2.1.0
+Flask-Compress>=1.14
+Flask-Limiter>=3.5.0
 bokeh>=3.1.1; python_version <= '3.8'
-bokeh>=3.4.1; python_version >= '3.9'
-markupsafe>=2.1.5
+bokeh>=3.3.2; python_version >= '3.9'
+markupsafe>=2.1.3

WebHostLib/static/assets/trackerCommon.js

@@ -27,7 +27,7 @@ const adjustTableHeight = () => {
  * @returns {string}
  */
 const secondsToHours = (seconds) => {
-    let hours = Math.floor(seconds / 3600);
+    let hours   = Math.floor(seconds / 3600);
     let minutes = Math.floor((seconds - (hours * 3600)) / 60).toString().padStart(2, '0');
     return `${hours}:${minutes}`;
 };
@@ -38,18 +38,18 @@ window.addEventListener('load', () => {
         info: false,
         dom: "t",
         stateSave: true,
-        stateSaveCallback: function (settings, data) {
+        stateSaveCallback: function(settings, data) {
             delete data.search;
             localStorage.setItem(`DataTables_${settings.sInstance}_/tracker`, JSON.stringify(data));
         },
-        stateLoadCallback: function (settings) {
+        stateLoadCallback: function(settings) {
             return JSON.parse(localStorage.getItem(`DataTables_${settings.sInstance}_/tracker`));
         },
-        footerCallback: function (tfoot, data, start, end, display) {
+        footerCallback: function(tfoot, data, start, end, display) {
             if (tfoot) {
                 const activityData = this.api().column('lastActivity:name').data().toArray().filter(x => !isNaN(x));
                 Array.from(tfoot?.children).find(td => td.classList.contains('last-activity')).innerText =
-                    (activityData.length) ? secondsToHours(Math.min(...activityData)) : 'None';
+                  (activityData.length) ? secondsToHours(Math.min(...activityData)) : 'None';
             }
         },
         columnDefs: [
@@ -123,64 +123,49 @@ window.addEventListener('load', () => {
             event.preventDefault();
         }
     });
-    const target_second = parseInt(document.getElementById('tracker-wrapper').getAttribute('data-second')) + 3;
-    console.log("Target second of refresh: " + target_second);
+    const tracker = document.getElementById('tracker-wrapper').getAttribute('data-tracker');
+    const target_second = document.getElementById('tracker-wrapper').getAttribute('data-second') + 3;
 
-    function getSleepTimeSeconds() {
+    function getSleepTimeSeconds(){
         // -40 % 60 is -40, which is absolutely wrong and should burn
         var sleepSeconds = (((target_second - new Date().getSeconds()) % 60) + 60) % 60;
         return sleepSeconds || 60;
     }
 
-    let update_on_view = false;
     const update = () => {
-        if (document.hidden) {
-            console.log("Document reporting as not visible, not updating Tracker...");
-            update_on_view = true;
-        } else {
-            update_on_view = false;
-            const target = $("<div></div>");
-            console.log("Updating Tracker...");
-            target.load(location.href, function (response, status) {
-                if (status === "success") {
-                    target.find(".table").each(function (i, new_table) {
-                        const new_trs = $(new_table).find("tbody>tr");
-                        const footer_tr = $(new_table).find("tfoot>tr");
-                        const old_table = tables.eq(i);
-                        const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
-                        const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
-                        old_table.clear();
-                        if (footer_tr.length) {
-                            $(old_table.table).find("tfoot").html(footer_tr);
-                        }
-                        old_table.rows.add(new_trs);
-                        old_table.draw();
-                        $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
-                        $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
-                    });
-                    $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
-                } else {
-                    console.log("Failed to connect to Server, in order to update Table Data.");
-                    console.log(response);
-                }
-            })
-        }
-        updater = setTimeout(update, getSleepTimeSeconds() * 1000);
+        const target = $("<div></div>");
+        console.log("Updating Tracker...");
+        target.load(location.href, function (response, status) {
+            if (status === "success") {
+                target.find(".table").each(function (i, new_table) {
+                    const new_trs = $(new_table).find("tbody>tr");
+                    const footer_tr = $(new_table).find("tfoot>tr");
+                    const old_table = tables.eq(i);
+                    const topscroll = $(old_table.settings()[0].nScrollBody).scrollTop();
+                    const leftscroll = $(old_table.settings()[0].nScrollBody).scrollLeft();
+                    old_table.clear();
+                    if (footer_tr.length) {
+                        $(old_table.table).find("tfoot").html(footer_tr);
+                    }
+                    old_table.rows.add(new_trs);
+                    old_table.draw();
+                    $(old_table.settings()[0].nScrollBody).scrollTop(topscroll);
+                    $(old_table.settings()[0].nScrollBody).scrollLeft(leftscroll);
+                });
+                $("#multi-stream-link").replaceWith(target.find("#multi-stream-link"));
+            } else {
+                console.log("Failed to connect to Server, in order to update Table Data.");
+                console.log(response);
+            }
+        })
+        setTimeout(update, getSleepTimeSeconds()*1000);
     }
-    let updater = setTimeout(update, getSleepTimeSeconds() * 1000);
+    setTimeout(update, getSleepTimeSeconds()*1000);
 
     window.addEventListener('resize', () => {
         adjustTableHeight();
         tables.draw();
     });
 
-    window.addEventListener('visibilitychange', () => {
-        if (!document.hidden && update_on_view) {
-            console.log("Page became visible, tracker should be refreshed.");
-            clearTimeout(updater);
-            update();
-        }
-    });
-
     adjustTableHeight();
 });

WebHostLib/static/styles/playerOptions/playerOptions.css

@@ -15,7 +15,7 @@ html {
   border-radius: 8px;
   padding: 1rem;
   color: #eeffeb;
-  word-break: break-word;
+  word-break: break-all;
 }
 #player-options #player-options-header h1 {
   margin-bottom: 0;

WebHostLib/static/styles/playerOptions/playerOptions.scss

@@ -16,7 +16,7 @@ html{
     border-radius: 8px;
     padding: 1rem;
     color: #eeffeb;
-    word-break: break-word;
+    word-break: break-all;
 
     #player-options-header{
         h1{

WebHostLib/templates/hostRoom.html

@@ -24,8 +24,7 @@
             <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.
+            This room has a <a href="{{ url_for("get_multiworld_tracker", tracker=room.tracker) }}">Multiworld Tracker</a> enabled.
             <br />
         {% endif %}
         The server for this room will be paused after {{ room.timeout//60//60 }} hours of inactivity.

WebHostLib/templates/multispheretracker.html

@@ -1,72 +0,0 @@
-{% extends "tablepage.html" %}
-{% block head %}
-    {{ super() }}
-    <title>Multiworld Sphere Tracker</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for("static", filename="styles/tracker.css") }}" />
-    <script type="application/ecmascript" src="{{ url_for("static", filename="assets/trackerCommon.js") }}"></script>
-{% endblock %}
-
-{% block body %}
-    {% include "header/dirtHeader.html" %}
-
-    <div id="tracker-wrapper" data-tracker="{{ room.tracker | suuid }}">
-        <div id="tracker-header-bar">
-            <input placeholder="Search" id="search" />
-
-            <div class="info">
-                {% if tracker_data.get_spheres() %}
-                This tracker lists already found locations by their logical access sphere.
-                It ignores items that cannot be sent
-                and will therefore differ from the sphere numbers in the spoiler playthrough.
-                This tracker will automatically update itself periodically.
-                {% else %}
-                This Multiworld has no Sphere data, likely due to being too old, cannot display data.
-                {% endif %}
-            </div>
-        </div>
-
-        <div id="tables-container">
-        {%- for team, players in tracker_data.get_all_players().items() %}
-            <div class="table-wrapper">
-                <table id="checks-table" class="table non-unique-item-table">
-                    <thead>
-                        <tr>
-                            <th>Sphere</th>
-                            {#- Mimicking hint table header for familiarity. #}
-                            <th>Finder</th>
-                            <th>Receiver</th>
-                            <th>Item</th>
-                            <th>Location</th>
-                            <th>Game</th>
-                        </tr>
-                    </thead>
-                    <tbody>
-                    {%- for sphere in tracker_data.get_spheres() %}
-                    {%- set current_sphere = loop.index %}
-                    {%- for player, sphere_location_ids in sphere.items() %}
-                        {%- set checked_locations = tracker_data.get_player_checked_locations(team, player) %}
-                        {%- set finder_game = tracker_data.get_player_game(team, player) %}
-                        {%- set player_location_data = tracker_data.get_player_locations(team, player) %}
-                        {%- for location_id in sphere_location_ids.intersection(checked_locations) %}
-                        <tr>
-                            {%- set item_id, receiver, item_flags = player_location_data[location_id] %}
-                            {%- set receiver_game = tracker_data.get_player_game(team, receiver) %}
-                            <td>{{ current_sphere }}</td>
-                            <td>{{ tracker_data.get_player_name(team, player) }}</td>
-                            <td>{{ tracker_data.get_player_name(team, receiver) }}</td>
-                            <td>{{ tracker_data.item_id_to_name[receiver_game][item_id] }}</td>
-                            <td>{{ tracker_data.location_id_to_name[finder_game][location_id] }}</td>
-                            <td>{{ finder_game }}</td>
-                        </tr>
-                        {%- endfor %}
-
-                    {%- endfor %}
-                    {%- endfor %}
-                    </tbody>
-                </table>
-            </div>
-
-        {%- endfor -%}
-        </div>
-    </div>
-{% endblock %}

WebHostLib/templates/multitracker.html

@@ -10,7 +10,7 @@
     {% include "header/dirtHeader.html" %}
     {% include "multitrackerNavigation.html" %}
 
-    <div id="tracker-wrapper" data-tracker="{{ room.tracker | suuid }}" data-second="{{ saving_second }}">
+    <div id="tracker-wrapper" data-tracker="{{ room.tracker | suuid }}">
         <div id="tracker-header-bar">
             <input placeholder="Search" id="search" />
 

WebHostLib/templates/ootTracker.html

@@ -0,0 +1,180 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <title>{{ player_name }}&apos;s Tracker</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename='styles/ootTracker.css') }}"/>
+    <script type="application/ecmascript" src="{{ url_for('static', filename='assets/ootTracker.js') }}"></script>
+</head>
+
+<body>
+    <div id="player-tracker-wrapper" data-tracker="{{ room.tracker|suuid }}">
+        <table id="inventory-table">
+            <tr>
+                <td><img src="{{ ocarina_url }}" class="{{ 'acquired' if 'Ocarina' in acquired_items }}" title="Ocarina" /></td>
+                <td><img src="{{ icons['Bombs'] }}" class="{{ 'acquired' if 'Bomb Bag' in acquired_items }}" title="Bombs" /></td>
+                <td><img src="{{ icons['Bow'] }}" class="{{ 'acquired' if 'Bow' in acquired_items }}" title="Fairy Bow" /></td>
+                <td><img src="{{ icons['Fire Arrows'] }}" class="{{ 'acquired' if 'Fire Arrows' in acquired_items }}" title="Fire Arrows" /></td>
+                <td><img src="{{ icons['Kokiri Sword'] }}" class="{{ 'acquired' if 'Kokiri Sword' in acquired_items }}" title="Kokiri Sword" /></td>
+                <td><img src="{{ icons['Biggoron Sword'] }}" class="{{ 'acquired' if 'Biggoron Sword' in acquired_items }}" title="Biggoron's Sword" /></td>
+                <td><img src="{{ icons['Mirror Shield'] }}" class="{{ 'acquired' if 'Mirror Shield' in acquired_items }}" title="Mirror Shield" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Slingshot'] }}" class="{{ 'acquired' if 'Slingshot' in acquired_items }}" title="Slingshot" /></td>
+                <td><img src="{{ icons['Bombchus'] }}" class="{{ 'acquired' if has_bombchus }}" title="Bombchus" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ hookshot_url }}" class="{{ 'acquired' if 'Progressive Hookshot' in acquired_items }}" title="Progressive Hookshot" />
+                        <div class="item-count">{{ hookshot_length }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Ice Arrows'] }}" class="{{ 'acquired' if 'Ice Arrows' in acquired_items }}" title="Ice Arrows" /></td>
+                <td><img src="{{ strength_upgrade_url }}" class="{{ 'acquired' if 'Progressive Strength Upgrade' in acquired_items }}" title="Progressive Strength Upgrade" /></td>
+                <td><img src="{{ icons['Goron Tunic'] }}" class="{{ 'acquired' if 'Goron Tunic' in acquired_items }}" title="Goron Tunic" /></td>
+                <td><img src="{{ icons['Zora Tunic'] }}" class="{{ 'acquired' if 'Zora Tunic' in acquired_items }}" title="Zora Tunic" /></td>
+            </tr>
+            <tr>
+                <td><img src="{{ icons['Boomerang'] }}" class="{{ 'acquired' if 'Boomerang' in acquired_items }}" title="Boomerang" /></td>
+                <td><img src="{{ icons['Lens of Truth'] }}" class="{{ 'acquired' if 'Lens of Truth' in acquired_items }}" title="Lens of Truth" /></td>
+                <td><img src="{{ icons['Megaton Hammer'] }}" class="{{ 'acquired' if 'Megaton Hammer' in acquired_items }}" title="Megaton Hammer" /></td>
+                <td><img src="{{ icons['Light Arrows'] }}" class="{{ 'acquired' if 'Light Arrows' in acquired_items }}" title="Light Arrows" /></td>
+                <td><img src="{{ scale_url }}" class="{{ 'acquired' if 'Progressive Scale' in acquired_items }}" title="Progressive Scale" /></td>
+                <td><img src="{{ icons['Iron Boots'] }}" class="{{ 'acquired' if 'Iron Boots' in acquired_items }}" title="Iron Boots" /></td>
+                <td><img src="{{ icons['Hover Boots'] }}" class="{{ 'acquired' if 'Hover Boots' in acquired_items }}" title="Hover Boots" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ bottle_url }}" class="{{ 'acquired' if bottle_count > 0 }}" title="Bottles" />
+                        <div class="item-count">{{ bottle_count if bottle_count > 0 else '' }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ icons['Dins Fire'] }}" class="{{ 'acquired' if 'Dins Fire' in acquired_items }}" title="Din's Fire" /></td>
+                <td><img src="{{ icons['Farores Wind'] }}" class="{{ 'acquired' if 'Farores Wind' in acquired_items }}" title="Farore's Wind" /></td>
+                <td><img src="{{ icons['Nayrus Love'] }}" class="{{ 'acquired' if 'Nayrus Love' in acquired_items }}" title="Nayru's Love" /></td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ wallet_url }}" class="{{ 'acquired' if 'Progressive Wallet' in acquired_items }}" title="Progressive Wallet" />
+                        <div class="item-count">{{ wallet_size }}</div>
+                    </div>
+                </td>
+                <td><img src="{{ magic_meter_url }}" class="{{ 'acquired' if 'Magic Meter' in acquired_items }}" title="Magic Meter" /></td>
+                <td><img src="{{ icons['Gerudo Membership Card'] }}" class="{{ 'acquired' if 'Gerudo Membership Card' in acquired_items }}" title="Gerudo Membership Card" /></td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Zeldas Lullaby'] }}" class="{{ 'acquired' if 'Zeldas Lullaby' in acquired_items }}" title="Zelda's Lullaby" id="lullaby"/>
+                        <div class="item-count">Zelda</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Eponas Song'] }}" class="{{ 'acquired' if 'Eponas Song' in acquired_items }}" title="Epona's Song" id="epona" />
+                        <div class="item-count">Epona</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Sarias Song'] }}" class="{{ 'acquired' if 'Sarias Song' in acquired_items }}" title="Saria's Song" id="saria"/>
+                        <div class="item-count">Saria</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Suns Song'] }}" class="{{ 'acquired' if 'Suns Song' in acquired_items }}" title="Sun's Song" id="sun"/>
+                        <div class="item-count">Sun</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Time'] }}" class="{{ 'acquired' if 'Song of Time' in acquired_items }}" title="Song of Time" id="time"/>
+                        <div class="item-count">Time</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Song of Storms'] }}" class="{{ 'acquired' if 'Song of Storms' in acquired_items }}" title="Song of Storms" />
+                        <div class="item-count">Storms</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Gold Skulltula Token'] }}" class="{{ 'acquired' if token_count > 0 }}" title="Gold Skulltula Tokens" />
+                        <div class="item-count">{{ token_count }}</div>
+                    </div>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Minuet of Forest'] }}" class="{{ 'acquired' if 'Minuet of Forest' in acquired_items }}" title="Minuet of Forest" />
+                        <div class="item-count">Min</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Bolero of Fire'] }}" class="{{ 'acquired' if 'Bolero of Fire' in acquired_items }}" title="Bolero of Fire" />
+                        <div class="item-count">Bol</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Serenade of Water'] }}" class="{{ 'acquired' if 'Serenade of Water' in acquired_items }}" title="Serenade of Water" />
+                        <div class="item-count">Ser</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Requiem of Spirit'] }}" class="{{ 'acquired' if 'Requiem of Spirit' in acquired_items }}" title="Requiem of Spirit" />
+                        <div class="item-count">Req</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Nocturne of Shadow'] }}" class="{{ 'acquired' if 'Nocturne of Shadow' in acquired_items }}" title="Nocturne of Shadow" />
+                        <div class="item-count">Noc</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Prelude of Light'] }}" class="{{ 'acquired' if 'Prelude of Light' in acquired_items }}" title="Prelude of Light" />
+                        <div class="item-count">Pre</div>
+                    </div>
+                </td>
+                <td>
+                    <div class="counted-item">
+                        <img src="{{ icons['Triforce'] if game_finished else icons['Triforce Piece'] }}" class="{{ 'acquired' if game_finished or piece_count > 0 }}" title="{{ 'Triforce' if game_finished else 'Triforce Pieces' }}" id=triforce />
+                        <div class="item-count">{{ piece_count if piece_count > 0 else '' }}</div>
+                    </div>
+                </td>
+            </tr>
+        </table>
+        <table id="location-table">
+            <tr>
+                <td></td>
+                <td><img src="{{ icons['Small Key'] }}" title="Small Keys" /></td>
+                <td><img src="{{ icons['Boss Key'] }}" title="Boss Key" /></td>
+                <td class="right-align">Items</td>
+            </tr>
+            {% for area in checks_done %}
+            <tr class="location-category" id="{{area}}-header">
+                <td>{{ area }} {{'▼' if area != 'Total'}}</td>
+                <td class="smallkeys">{{ small_key_counts.get(area, '-') }}</td>
+                <td class="bosskeys">{{ boss_key_counts.get(area, '-') }}</td>
+                <td class="counter">{{ checks_done[area] }} / {{ checks_in_area[area] }}</td>
+            </tr>
+            <tbody class="locations hide" id="{{area}}">
+                {% for location in location_info[area] %}
+                <tr>
+                    <td class="location-name">{{ location }}</td>
+                    <td></td>
+                    <td></td>
+                    <td class="counter">{{ '✔' if location_info[area][location] else '' }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+            {% endfor %}
+        </table>
+    </div>
+</body>
+</html>

WebHostLib/templates/playerOptions/macros.html

@@ -141,7 +141,7 @@
         {% for group_name in world.location_name_groups.keys()|sort %}
             {% if group_name != "Everywhere" %}
                 <div class="option-entry">
-                    <input type="checkbox" id="{{ option_name }}-{{ group_name }}" name="{{ option_name }}" value="{{ group_name }}" {{ "checked" if group_name in option.default }} />
+                    <input type="checkbox" id="{{ option_name }}-{{ group_name }}" name="{{ option_name }}" value="{{ group_name }}" {{ "checked" if grop_name in option.default }} />
                     <label for="{{ option_name }}-{{ group_name }}">{{ group_name }}</label>
                 </div>
             {% endif %}

WebHostLib/templates/playerOptions/playerOptions.html

@@ -69,7 +69,7 @@
 
             <div id="option-groups">
                 {% for group_name, group_options in option_groups.items() %}
-                    <details class="group-container" {% if not start_collapsed[group_name] %}open{% endif %}>
+                    <details class="group-container" {% if loop.index == 1 %}open{% endif %}>
                         <summary class="h2">{{ group_name }}</summary>
                         <div class="game-options">
                             <div class="left">

WebHostLib/templates/weightedOptions/macros.html

@@ -1,9 +1,9 @@
 {% macro Toggle(option_name, option) %}
     <table>
         <tbody>
-            {{ RangeRow(option_name, option, "No", "false", False, "true" if option.default else "false") }}
-            {{ RangeRow(option_name, option, "Yes", "true", False, "true" if option.default else "false") }}
-            {{ RandomRow(option_name, option) }}
+            {{ RangeRow(option_name, option, "No", "false") }}
+            {{ RangeRow(option_name, option, "Yes", "true") }}
+            {{ RandomRows(option_name, option) }}
         </tbody>
     </table>
 {% endmacro %}
@@ -18,10 +18,10 @@
         <tbody>
             {% for id, name in option.name_lookup.items() %}
                 {% if name != 'random' %}
-                    {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.get_option_name(option.default)|lower == name|lower else None) }}
+                    {{ RangeRow(option_name, option, option.get_option_name(id), name) }}
                 {% endif %}
             {% endfor %}
-            {{ RandomRow(option_name, option) }}
+            {{ RandomRows(option_name, option) }}
         </tbody>
     </table>
 {% endmacro %}
@@ -72,9 +72,7 @@
         </div>
         <table>
             <tbody>
-                {% if option.default %}
-                    {{ RangeRow(option_name, option, option.default, option.default) }}
-                {% endif %}
+                <!-- This table to be filled by JS -->
             </tbody>
         </table>
     </div>
@@ -92,10 +90,10 @@
         <tbody>
             {% for id, name in option.name_lookup.items() %}
                 {% if name != 'random' %}
-                    {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.get_option_name(option.default)|lower == name else None) }}
+                    {{ RangeRow(option_name, option, option.get_option_name(id), name) }}
                 {% endif %}
             {% endfor %}
-            {{ RandomRow(option_name, option) }}
+            {{ RandomRows(option_name, option) }}
         </tbody>
     </table>
 {% endmacro %}
@@ -114,7 +112,7 @@
                     type="number"
                     id="{{ option_name }}-{{ item_name }}-qty"
                     name="{{ option_name }}||{{ item_name }}"
-                    value="{{ option.default[item_name] if item_name in option.default else "0" }}"
+                    value="0"
                 />
             </div>
         {% endfor %}
@@ -123,14 +121,13 @@
 
 {% macro OptionList(option_name, option) %}
     <div class="list-container">
-        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
+        {% for key in option.valid_keys|sort %}
             <div class="list-entry">
                 <input
                     type="checkbox"
                     id="{{ option_name }}-{{ key }}"
                     name="{{ option_name }}||{{ key }}"
                     value="1"
-                    checked="{{ "checked" if key in option.default else "" }}"
                 />
                 <label for="{{ option_name }}-{{ key }}">
                     {{ key }}
@@ -145,7 +142,7 @@
         {% for group_name in world.location_name_groups.keys()|sort %}
             {% if group_name != "Everywhere" %}
                 <div class="set-entry">
-                    <input type="checkbox" id="{{ option_name }}-{{ group_name }}" name="{{ option_name }}||{{ group_name }}" value="1" {{ "checked" if group_name in option.default }} />
+                    <input type="checkbox" id="{{ option_name }}-{{ group_name }}" name="{{ option_name }}||{{ group_name }}" value="1" {{ "checked" if grop_name in option.default }} />
                     <label for="{{ option_name }}-{{ group_name }}">{{ group_name }}</label>
                 </div>
             {% endif %}
@@ -186,7 +183,7 @@
 
 {% macro OptionSet(option_name, option) %}
     <div class="set-container">
-        {% for key in (option.valid_keys if option.valid_keys is ordered else option.valid_keys|sort) %}
+        {% for key in option.valid_keys|sort %}
             <div class="set-entry">
                 <input type="checkbox" id="{{ option_name }}-{{ key }}" name="{{ option_name }}||{{ key }}" value="1" {{ "checked" if key in option.default }} />
                 <label for="{{ option_name }}-{{ key }}">{{ key }}</label>
@@ -203,17 +200,13 @@
     </td>
 {% endmacro %}
 
-{% macro RandomRow(option_name, option, extra_column=False) %}
-    {{ RangeRow(option_name, option, "Random", "random") }}
-{% endmacro %}
-
 {% macro RandomRows(option_name, option, extra_column=False) %}
     {% for key, value in {"Random": "random", "Random (Low)": "random-low", "Random (Middle)": "random-middle", "Random (High)": "random-high"}.items() %}
         {{ RangeRow(option_name, option, key, value) }}
     {% endfor %}
 {% endmacro %}
 
-{% macro RangeRow(option_name, option, display_value, value, can_delete=False, default_override=None) %}
+{% macro RangeRow(option_name, option, display_value, value, can_delete=False) %}
     <tr data-row="{{ option_name }}-{{ value }}-row" data-option-name="{{ option_name }}" data-value="{{ value }}">
         <td class="td-left">
             <label for="{{ option_name }}||{{ value }}">
@@ -227,7 +220,7 @@
                 name="{{ option_name }}||{{ value }}"
                 min="0"
                 max="50"
-                {% if option.default == value or default_override == value %}
+                {% if option.default == value %}
                     value="25"
                 {% else %}
                     value="0"
@@ -236,7 +229,7 @@
         </td>
         <td class="td-right">
             <span id="{{ option_name }}||{{ value }}-value">
-                {% if option.default == value or default_override == value %}
+                {% if option.default == value %}
                     25
                 {% else %}
                     0

WebHostLib/templates/weightedOptions/weightedOptions.html

@@ -51,7 +51,7 @@
 
             <div id="{{ world_name }}-container">
                 {% for group_name, group_options in option_groups.items() %}
-                    <details {% if not start_collapsed[group_name] %}open{% endif %}>
+                    <details {% if loop.index == 1 %}open{% endif %}>
                         <summary class="h2">{{ group_name }}</summary>
                         {% for option_name, option in group_options.items() %}
                             <div class="option-wrapper">

WebHostLib/tracker.py

@@ -3,9 +3,8 @@ import collections
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Set, Tuple, NamedTuple, Counter
 from uuid import UUID
-from email.utils import parsedate_to_datetime
 
-from flask import render_template, make_response, Response, request
+from flask import render_template
 from werkzeug.exceptions import abort
 
 from MultiServer import Context, get_saving_second
@@ -292,47 +291,47 @@ class TrackerData:
 
         return video_feeds
 
-    @_cache_results
-    def get_spheres(self) -> List[List[int]]:
-        """ each sphere is { player: { location_id, ... } } """
-        return self._multidata.get("spheres", [])
+
+@app.route("/tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>")
+def get_player_tracker(tracker: UUID, tracked_team: int, tracked_player: int, generic: bool = False) -> str:
+    key = f"{tracker}_{tracked_team}_{tracked_player}_{generic}"
+    tracker_page = cache.get(key)
+    if tracker_page:
+        return tracker_page
+
+    timeout, tracker_page = get_timeout_and_tracker(tracker, tracked_team, tracked_player, generic)
+    cache.set(key, tracker_page, timeout)
+    return tracker_page
 
 
-def _process_if_request_valid(incoming_request, room: Optional[Room]) -> Optional[Response]:
+@app.route("/generic_tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>")
+def get_generic_game_tracker(tracker: UUID, tracked_team: int, tracked_player: int) -> str:
+    return get_player_tracker(tracker, tracked_team, tracked_player, True)
+
+
+@app.route("/tracker/<suuid:tracker>", defaults={"game": "Generic"})
+@app.route("/tracker/<suuid:tracker>/<game>")
+@cache.memoize(timeout=TRACKER_CACHE_TIMEOUT_IN_SECONDS)
+def get_multiworld_tracker(tracker: UUID, game: str):
+    # Room must exist.
+    room = Room.get(tracker=tracker)
     if not room:
         abort(404)
 
-    if_modified = incoming_request.headers.get("If-Modified-Since", None)
-    if if_modified:
-        if_modified = parsedate_to_datetime(if_modified)
-        # if_modified has less precision than last_activity, so we bring them to same precision
-        if if_modified >= room.last_activity.replace(microsecond=0):
-            return make_response("",  304)
+    tracker_data = TrackerData(room)
+    enabled_trackers = list(get_enabled_multiworld_trackers(room).keys())
+    if game not in _multiworld_trackers:
+        return render_generic_multiworld_tracker(tracker_data, enabled_trackers)
+
+    return _multiworld_trackers[game](tracker_data, enabled_trackers)
 
 
-@app.route("/tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>")
-def get_player_tracker(tracker: UUID, tracked_team: int, tracked_player: int, generic: bool = False) -> Response:
-    key = f"{tracker}_{tracked_team}_{tracked_player}_{generic}"
-    response: Optional[Response] = cache.get(key)
-    if response:
-        return response
-
+def get_timeout_and_tracker(tracker: UUID, tracked_team: int, tracked_player: int, generic: bool) -> Tuple[int, str]:
     # Room must exist.
     room = Room.get(tracker=tracker)
+    if not room:
+        abort(404)
 
-    response = _process_if_request_valid(request, room)
-    if response:
-        return response
-
-    timeout, last_modified, tracker_page = get_timeout_and_player_tracker(room, tracked_team, tracked_player, generic)
-    response = make_response(tracker_page)
-    response.last_modified = last_modified
-    cache.set(key, response, timeout)
-    return response
-
-
-def get_timeout_and_player_tracker(room: Room, tracked_team: int, tracked_player: int, generic: bool)\
-        -> Tuple[int, datetime.datetime, str]:
     tracker_data = TrackerData(room)
 
     # Load and render the game-specific player tracker, or fallback to generic tracker if none exists.
@@ -342,48 +341,7 @@ def get_timeout_and_player_tracker(room: Room, tracked_team: int, tracked_player
     else:
         tracker = render_generic_tracker(tracker_data, tracked_team, tracked_player)
 
-    return ((tracker_data.get_room_saving_second() - datetime.datetime.now().second)
-            % TRACKER_CACHE_TIMEOUT_IN_SECONDS or TRACKER_CACHE_TIMEOUT_IN_SECONDS, room.last_activity, tracker)
-
-
-@app.route("/generic_tracker/<suuid:tracker>/<int:tracked_team>/<int:tracked_player>")
-def get_generic_game_tracker(tracker: UUID, tracked_team: int, tracked_player: int) -> Response:
-    return get_player_tracker(tracker, tracked_team, tracked_player, True)
-
-
-@app.route("/tracker/<suuid:tracker>", defaults={"game": "Generic"})
-@app.route("/tracker/<suuid:tracker>/<game>")
-def get_multiworld_tracker(tracker: UUID, game: str) -> Response:
-    key = f"{tracker}_{game}"
-    response: Optional[Response] = cache.get(key)
-    if response:
-        return response
-
-    # Room must exist.
-    room = Room.get(tracker=tracker)
-
-    response = _process_if_request_valid(request, room)
-    if response:
-        return response
-
-    timeout, last_modified, tracker_page = get_timeout_and_multiworld_tracker(room, game)
-    response = make_response(tracker_page)
-    response.last_modified = last_modified
-    cache.set(key, response, timeout)
-    return response
-
-
-def get_timeout_and_multiworld_tracker(room: Room, game: str)\
-        -> Tuple[int, datetime.datetime, str]:
-    tracker_data = TrackerData(room)
-    enabled_trackers = list(get_enabled_multiworld_trackers(room).keys())
-    if game in _multiworld_trackers:
-        tracker = _multiworld_trackers[game](tracker_data, enabled_trackers)
-    else:
-        tracker = render_generic_multiworld_tracker(tracker_data, enabled_trackers)
-
-    return ((tracker_data.get_room_saving_second() - datetime.datetime.now().second)
-            % TRACKER_CACHE_TIMEOUT_IN_SECONDS or TRACKER_CACHE_TIMEOUT_IN_SECONDS, room.last_activity, tracker)
+    return (tracker_data.get_room_saving_second() - datetime.datetime.now().second) % 60 or 60, tracker
 
 
 def get_enabled_multiworld_trackers(room: Room) -> Dict[str, Callable]:
@@ -453,30 +411,9 @@ def render_generic_multiworld_tracker(tracker_data: TrackerData, enabled_tracker
         videos=tracker_data.get_room_videos(),
         item_id_to_name=tracker_data.item_id_to_name,
         location_id_to_name=tracker_data.location_id_to_name,
-        saving_second=tracker_data.get_room_saving_second(),
     )
 
 
-def render_generic_multiworld_sphere_tracker(tracker_data: TrackerData) -> str:
-    return render_template(
-        "multispheretracker.html",
-        room=tracker_data.room,
-        tracker_data=tracker_data,
-    )
-
-
-@app.route("/sphere_tracker/<suuid:tracker>")
-@cache.memoize(timeout=TRACKER_CACHE_TIMEOUT_IN_SECONDS)
-def get_multiworld_sphere_tracker(tracker: UUID):
-    # Room must exist.
-    room = Room.get(tracker=tracker)
-    if not room:
-        abort(404)
-
-    tracker_data = TrackerData(room)
-    return render_generic_multiworld_sphere_tracker(tracker_data)
-
-
 # TODO: This is a temporary solution until a proper Tracker API can be implemented for tracker templates and data to
 #       live in their respective world folders.
 

Zelda1Client.py

@@ -152,7 +152,7 @@ def get_payload(ctx: ZeldaContext):
 
 
 def reconcile_shops(ctx: ZeldaContext):
-    checked_location_names = [ctx.location_names.lookup_in_slot(location) for location in ctx.checked_locations]
+    checked_location_names = [ctx.location_names[location] for location in ctx.checked_locations]
     shops = [location for location in checked_location_names if "Shop" in location]
     left_slots = [shop for shop in shops if "Left" in shop]
     middle_slots = [shop for shop in shops if "Middle" in shop]
@@ -190,7 +190,7 @@ async def parse_locations(locations_array, ctx: ZeldaContext, force: bool, zone=
         locations_checked = []
         location = None
         for location in ctx.missing_locations:
-            location_name = ctx.location_names.lookup_in_slot(location)
+            location_name = ctx.location_names[location]
 
             if location_name in Locations.overworld_locations and zone == "overworld":
                 status = locations_array[Locations.major_location_offsets[location_name]]

docs/CODEOWNERS

@@ -6,24 +6,25 @@
 #
 # All usernames must be GitHub usernames (and are case sensitive).
 
+###################
+## Active Worlds ##
+###################
+
 # Adventure
 /worlds/adventure/ @JusticePS
 
-# A Hat in Time
-/worlds/ahit/ @CookieCat45
-
 # A Link to the Past
 /worlds/alttp/ @Berserker66
 
-# Sudoku (APSudoku)
-/worlds/apsudoku/ @EmilyV99
-
 # Aquaria
 /worlds/aquaria/ @tioui
 
 # ArchipIDLE
 /worlds/archipidle/ @LegendaryLinux
 
+# Sudoku (BK Sudoku)
+/worlds/bk_sudoku/ @Jarno458
+
 # Blasphemous
 /worlds/blasphemous/ @TRPG0
 
@@ -63,6 +64,9 @@
 # Factorio
 /worlds/factorio/ @Berserker66
 
+# Final Fantasy
+/worlds/ff1/ @jtoyoda
+
 # Final Fantasy Mystic Quest
 /worlds/ffmq/ @Alchav @wildham0
 
@@ -200,7 +204,7 @@
 /worlds/yoshisisland/ @PinkSwitch
 
 #Yu-Gi-Oh! Ultimate Masters: World Championship Tournament 2006
-/worlds/yugioh06/ @Rensen3
+/worlds/yugioh06/ @rensen
 
 # Zillion
 /worlds/zillion/ @beauxq
@@ -208,22 +212,9 @@
 # Zork Grand Inquisitor
 /worlds/zork_grand_inquisitor/ @nbrochu
 
-
-## Active Unmaintained Worlds
-
-# The following worlds in this repo are currently unmaintained, but currently still work in core. If any update breaks
-# compatibility, these worlds may be moved to `worlds_disabled`. If you are interested in stepping up as maintainer for
-# any of these worlds, please review `/docs/world maintainer.md` documentation.
-
-# Final Fantasy (1)
-# /worlds/ff1/
-
-
-## Disabled Unmaintained Worlds
-
-# The following worlds in this repo are currently unmaintained and disabled as they do not work in core. If you are
-# interested in stepping up as maintainer for any of these worlds, please review `/docs/world maintainer.md`
-# documentation.
+##################################
+## Disabled Unmaintained Worlds ##
+##################################
 
 # Ori and the Blind Forest
-# /worlds_disabled/oribf/
+# /worlds_disabled/oribf/ <Unmaintained>

docs/contributing.md

@@ -1,49 +1,43 @@
 # Contributing
-
-All contributions are welcome, though we have a few requests of contributors, whether they be for core, webhost, or new 
-game contributions:
+Contributions are welcome. We have a few requests for new contributors:
 
 * **Follow styling guidelines.**
   Please take a look at the [code style documentation](/docs/style.md)
   to ensure ease of communication and uniformity.
 
-* **Ensure that critical changes are covered by tests.**
-  It is strongly recommended that unit tests are used to avoid regression and to ensure everything is still working.
-  If you wish to contribute by adding a new game, please take a look at
-  the [logic unit test documentation](/docs/tests.md).
-  If you wish to contribute to the website, please take a look at [these tests](/test/webhost).
+* **Ensure that critical changes are covered by tests.** 
+It is strongly recommended that unit tests are used to avoid regression and to ensure everything is still working.
+If you wish to contribute by adding a new game, please take a look at the [logic unit test documentation](/docs/tests.md).
+If you wish to contribute to the website, please take a look at [these tests](/test/webhost).
 
 * **Do not introduce unit test failures/regressions.**
-  Archipelago supports multiple versions of Python. You may need to download older Python versions to fully test
-  your changes. Currently, the oldest supported version
-  is [Python 3.8](https://www.python.org/downloads/release/python-380/).
-  It is recommended that automated github actions are turned on in your fork to have github run unit tests after
-  pushing.
-  You can turn them on here:  
-  ![Github actions example](./img/github-actions-example.png)
+Archipelago supports multiple versions of Python. You may need to download older Python versions to fully test
+your changes. Currently, the oldest supported version is [Python 3.8](https://www.python.org/downloads/release/python-380/). 
+It is recommended that automated github actions are turned on in your fork to have github run all of the unit tests after pushing.
+You can turn them on here:  
+![Github actions example](./img/github-actions-example.png)
 
 * **When reviewing PRs, please leave a message about what was done.**
-  We don't have full test coverage, so manual testing can help.
-  For code changes that could affect multiple worlds or that could have changes in unexpected code paths, manual testing
-  or checking if all code paths are covered by automated tests is desired. The original author may not have been able
-  to test all possibly affected worlds, or didn't know it would affect another world. In such cases, it is helpful to
-  state which games or settings were rolled, if any.
-  Please also tell us if you looked at code, just did functional testing, did both, or did neither.
-  If testing the PR depends on other PRs, please state what you merged into what for testing.
-  We cannot determine what "LGTM" means without additional context, so that should not be the norm.
+We don't have full test coverage, so manual testing can help.
+For code changes that could affect multiple worlds or that could have changes in unexpected code paths, manual testing
+or checking if all code paths are covered by automated tests is desired. The original author may not have been able
+to test all possibly affected worlds, or didn't know it would affect another world. In such cases, it is helpful to
+state which games or settings were rolled, if any.
+Please also tell us if you looked at code, just did functional testing, did both, or did neither.
+If testing the PR depends on other PRs, please state what you merged into what for testing.
+We cannot determine what "LGTM" means without additional context, so that should not be the norm.
 
-Other than these requests, we tend to judge code on a case-by-case basis.
+Other than these requests, we tend to judge code on a case-by-case basis. 
 
 For contribution to the website, please refer to the [WebHost README](/WebHostLib/README.md).
 
 If you want to contribute to the core, you will be subject to stricter review on your pull requests. It is recommended
 that you get in touch with other core maintainers via the [Discord](https://archipelago.gg/discord).
 
-If you want to add Archipelago support for a new game, please take a look at
-the [adding games documentation](/docs/adding%20games.md)
-which details what is required to implement support for a game, and has tips on to get started.
-If you want to merge a new game into the main Archipelago repo, please make sure to read the responsibilities as a
-[world maintainer](/docs/world%20maintainer.md).
+If you want to add Archipelago support for a new game, please take a look at the [adding games documentation](/docs/adding%20games.md), which details what is required 
+to implement support for a game, as well as tips for how to get started.
+If you want to merge a new game into the main Archipelago repo, please make sure to read the responsibilities as a 
+[world maintainer](/docs/world%20maintainer.md).  
 
-For other questions, feel free to explore the [main documentation folder](/docs), and ask us questions in the
-#ap-world-dev channel of the [Discord](https://archipelago.gg/discord).
+For other questions, feel free to explore the [main documentation folder](/docs/) and ask us questions in the #archipelago-dev channel 
+of the [Discord](https://archipelago.gg/discord).

docs/network protocol.md

@@ -53,7 +53,7 @@ Example:
 ```
 
 ## (Server -> Client)
-These packets are sent from the multiworld server to the client. They are not messages which the server accepts.
+These packets are are sent from the multiworld server to the client. They are not messages which the server accepts.
 * [RoomInfo](#RoomInfo)
 * [ConnectionRefused](#ConnectionRefused)
 * [Connected](#Connected)
@@ -80,6 +80,7 @@ Sent to clients when they connect to an Archipelago server.
 | hint_cost             | int                                           | The percentage of total locations that need to be checked to receive a hint from the server.                                                                                                                                          |
 | location_check_points | int                                           | The amount of hint points you receive per item/location check completed.                                                                                                                                                              |
 | games                 | list\[str\]                                   | List of games present in this multiworld.                                                                                                                                                                                             |
+| datapackage_versions  | dict\[str, int\]                              | Data versions of the individual games' data packages the server will send. Used to decide which games' caches are outdated. See [Data Package Contents](#Data-Package-Contents). **Deprecated. Use `datapackage_checksums` instead.** |
 | datapackage_checksums | dict[str, str]                                | Checksum hash of the individual games' data packages the server will send. Used by newer clients to decide which games' caches are outdated. See [Data Package Contents](#Data-Package-Contents) for more information.                | 
 | seed_name             | str                                           | Uniquely identifying name of this generation                                                                                                                                                                                          |
 | time                  | float                                         | Unix time stamp of "now". Send for time synchronization if wanted for things like the DeathLink Bounce.                                                                                                                               |
@@ -499,9 +500,9 @@ In JSON this may look like:
     {"item": 3, "location": 3, "player": 3, "flags": 0}
 ]
 ```
-`item` is the item id of the item. Item ids are only supported in the range of [-2<sup>53</sup>, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
+`item` is the item id of the item. Item ids are in the range of ± 2<sup>53</sup>-1.
 
-`location` is the location id of the item inside the world. Location ids are only supported in the range of [-2<sup>53</sup>, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
+`location` is the location id of the item inside the world. Location ids are in the range of ± 2<sup>53</sup>-1.
 
 `player` is the player slot of the world the item is located in, except when inside an [LocationInfo](#LocationInfo) Packet then it will be the slot of the player to receive the item
 
@@ -645,47 +646,15 @@ class Hint(typing.NamedTuple):
 ```
 
 ### Data Package Contents
-A data package is a JSON object which may contain arbitrary metadata to enable a client to interact with the Archipelago
-server most easily and not maintain their own mappings. Some contents include:
+A data package is a JSON object which may contain arbitrary metadata to enable a client to interact with the Archipelago server most easily. Currently, this package is used to send ID to name mappings so that clients need not maintain their own mappings.
 
-   - Name to ID mappings for items and locations.
-   - A checksum of each game's data package for clients to tell if a cached package is invalid.
+We encourage clients to cache the data package they receive on disk, or otherwise not tied to a session. You will know when your cache is outdated if the [RoomInfo](#RoomInfo) packet or the datapackage itself denote a different version. A special case is datapackage version 0, where it is expected the package is custom and should not be cached.
 
-We encourage clients to cache the data package they receive on disk, or otherwise not tied to a session. You will know 
-when your cache is outdated if the [RoomInfo](#RoomInfo) packet or the datapackage itself denote a different checksum
-than any locally cached ones.
-
-**Important Notes about IDs and Names**: 
-
-* IDs ≤ 0 are reserved for "Archipelago" and should not be used by other world implementations.
-* The IDs from the game "Archipelago" (in `worlds/generic`) may be used in any world.
-  * Especially Location ID `-1`: `Cheat Console` and `-2`: `Server` (typically Remote Start Inventory)
-* Any names and IDs are only unique in its own world data package, but different games may reuse these names or IDs.
-  * At runtime, you will need to look up the game of the player to know which item or location ID/Name to lookup in the
-    data package. This can be easily achieved by reviewing the `slot_info` for a particular player ID prior to lookup.
-  * For example, a data package like this is valid (Some properties such as `checksum` were omitted):
-    ```json
-    {
-      "games": {
-        "Game A": {
-          "location_name_to_id": {
-            "Boss Chest": 40
-          },
-          "item_name_to_id": {
-            "Item X": 12
-          }
-        },
-        "Game B": {
-          "location_name_to_id": {
-            "Minigame Prize": 40
-          },
-          "item_name_to_id": {
-            "Item X": 40
-          }
-        }
-      }
-    }
-    ```
+Note: 
+ * Any ID is unique to its type across AP: Item 56 only exists once and Location 56 only exists once.
+ * Any Name is unique to its type across its own Game only: Single Arrow can exist in two games.
+ * The IDs from the game "Archipelago" may be used in any other game. 
+   Especially Location ID -1: Cheat Console and -2: Server (typically Remote Start Inventory)
 
 #### Contents
 | Name | Type | Notes |
@@ -699,6 +668,7 @@ GameData is a **dict** but contains these keys and values. It's broken out into
 |---------------------|----------------|-------------------------------------------------------------------------------------------------------------------------------|
 | item_name_to_id     | dict[str, int] | Mapping of all item names to their respective ID.                                                                             |
 | location_name_to_id | dict[str, int] | Mapping of all location names to their respective ID.                                                                         |
+| version             | int            | Version number of this game's data. Deprecated. Used by older clients to request an updated datapackage if cache is outdated. |
 | checksum            | str            | A checksum hash of this game's data.                                                                                          |
 
 ### Tags

docs/options api.md

@@ -86,29 +86,17 @@ class ExampleWorld(World):
 ```
 
 ### 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
-with the group name at the beginning of each group of options. The `start_collapsed` Boolean only affects how the groups
-appear on the WebHost, with the grouping being collapsed when this is `True`.
-
-Options without a group name are categorized into a generic "Game Options" group, which is always the first group. If
-every option for your world is in a group, this group will be removed. There is also an "Items & Location Options"
-group, which is automatically created using certain specified `item_and_loc_options`. These specified options cannot be
-removed from this group.
-
-Both the "Game Options" and "Item & Location Options" groups can be overridden by creating your own groups with
-those names, letting you add options to them and change whether they start collapsed. The "Item &
-Location Options" group can also be moved to a different position in the group ordering, but "Game Options" will always
-be first, regardless of where it is in your list.
+Options may be categorized into groups for display on the WebHost. Option groups are displayed alphabetically on the
+player-options and weighted-options pages. Options without a group name are categorized into a generic "Game Options"
+group.
 
 ```python
 from worlds.AutoWorld import WebWorld
 from Options import OptionGroup
-from . import Options
 
 class MyWorldWeb(WebWorld):
     option_groups = [
-        OptionGroup("Color Options", [
+        OptionGroup('Color Options', [
             Options.ColorblindMode,
             Options.FlashReduction,
             Options.UIColors,
@@ -132,8 +120,7 @@ or if I need a boolean object, such as in my slot_data I can access it as:
 start_with_sword = bool(self.options.starting_sword.value)
 ```
 All numeric options (i.e. Toggle, Choice, Range) can be compared to integers, strings that match their attributes,
-strings that match the option attributes after "option_" is stripped, and the attributes themselves. The option can
-also be checked to see if it exists within a collection, but this will fail for a set of strings due to hashing.
+strings that match the option attributes after "option_" is stripped, and the attributes themselves.
 ```python
 # options.py
 class Logic(Choice):
@@ -145,12 +132,6 @@ class Logic(Choice):
     alias_extra_hard = 2
     crazy = 4  # won't be listed as an option and only exists as an attribute on the class
 
-class Weapon(Choice):
-    option_none = 0
-    option_sword = 1
-    option_bow = 2
-    option_hammer = 3
-
 # __init__.py
 from .options import Logic
 
@@ -164,16 +145,6 @@ elif self.options.logic == Logic.option_extreme:
     do_extreme_things()
 elif self.options.logic == "crazy":
     do_insane_things()
-
-# check if the current option is in a collection of integers using the class attributes
-if self.options.weapon in {Weapon.option_bow, Weapon.option_sword}:
-    do_stuff()
-# in order to make a set of strings work, we have to compare against current_key
-elif self.options.weapon.current_key in {"none", "hammer"}:
-    do_something_else()
-# though it's usually better to just use a tuple instead
-elif self.options.weapon in ("none", "hammer"):
-    do_something_else()
 ```
 ## Generic Option Classes
 These options are generically available to every game automatically, but can be overridden for slightly different

docs/world api.md

@@ -121,53 +121,6 @@ class RLWeb(WebWorld):
     # ...
 ```
 
-* `location_descriptions` (optional) WebWorlds can provide a map that contains human-friendly descriptions of locations 
-or location groups.
-
-  ```python
-  # locations.py
-  location_descriptions = {
-      "Red Potion #6": "In a secret destructible block under the second stairway",
-      "L2 Spaceship": """
-        The group of all items in the spaceship in Level 2.
-  
-        This doesn't include the item on the spaceship door, since it can be
-        accessed without the Spaceship Key.
-      """
-  }
-  
-  # __init__.py
-  from worlds.AutoWorld import WebWorld
-  from .locations import location_descriptions
-  
-  
-  class MyGameWeb(WebWorld):
-      location_descriptions = location_descriptions
-  ```
-
-* `item_descriptions` (optional) WebWorlds can provide a map that contains human-friendly descriptions of items or item 
-groups.
-
-  ```python
-  # items.py
-  item_descriptions = {
-      "Red Potion": "A standard health potion",
-      "Spaceship Key": """
-        The key to the spaceship in Level 2.
-  
-        This is necessary to get to the Star Realm.
-      """,
-  }
-  
-  # __init__.py
-  from worlds.AutoWorld import WebWorld
-  from .items import item_descriptions
-  
-  
-  class MyGameWeb(WebWorld):
-      item_descriptions = item_descriptions
-  ```
-
 ### MultiWorld Object
 
 The `MultiWorld` object references the whole multiworld (all items and locations for all players) and is accessible
@@ -225,6 +178,36 @@ Classification is one of `LocationProgressType.DEFAULT`, `PRIORITY` or `EXCLUDED
 The Fill algorithm will force progression items to be placed at priority locations, giving a higher chance of them being
 required, and will prevent progression and useful items from being placed at excluded locations.
 
+#### Documenting Locations
+
+Worlds can optionally provide a `location_descriptions` map which contains human-friendly descriptions of locations and
+location groups. These descriptions will show up in location-selection options on the options pages.
+
+```python
+# locations.py
+
+location_descriptions = {
+    "Red Potion #6": "In a secret destructible block under the second stairway",
+    "L2 Spaceship":
+        """
+        The group of all items in the spaceship in Level 2.
+
+        This doesn't include the item on the spaceship door, since it can be accessed without the Spaceship Key.
+        """
+}
+```
+
+```python
+# __init__.py
+
+from worlds.AutoWorld import World
+from .locations import location_descriptions
+
+
+class MyGameWorld(World):
+    location_descriptions = location_descriptions
+```
+
 ### Items
 
 Items are all things that can "drop" for your game. This may be RPG items like weapons, or technologies you normally
@@ -249,6 +232,36 @@ Other classifications include:
 * `progression_skip_balancing`: the combination of `progression` and `skip_balancing`, i.e., a progression item that
   will not be moved around by progression balancing; used, e.g., for currency or tokens, to not flood early spheres
 
+#### Documenting Items
+
+Worlds can optionally provide an `item_descriptions` map which contains human-friendly descriptions of items and item
+groups. These descriptions will show up in item-selection options on the options pages.
+
+```python
+# items.py
+
+item_descriptions = {
+    "Red Potion": "A standard health potion",
+    "Spaceship Key":
+        """
+        The key to the spaceship in Level 2.
+
+        This is necessary to get to the Star Realm.
+        """
+}
+```
+
+```python
+# __init__.py
+
+from worlds.AutoWorld import World
+from .items import item_descriptions
+
+
+class MyGameWorld(World):
+    item_descriptions = item_descriptions
+```
+
 ### Events
 
 An Event is a special combination of a Location and an Item, with both having an `id` of `None`. These can be used to

inno_setup.iss

@@ -75,7 +75,7 @@ Name: "{commondesktop}\{#MyAppName} Launcher"; Filename: "{app}\ArchipelagoLaunc
 [Run]
 
 Filename: "{tmp}\vc_redist.x64.exe"; Parameters: "/passive /norestart"; Check: IsVCRedist64BitNeeded; StatusMsg: "Installing VC++ redistributable..."
-Filename: "{app}\ArchipelagoLttPAdjuster"; Parameters: "--update_sprites"; StatusMsg: "Updating Sprite Library..."; Components: lttp_sprites
+Filename: "{app}\ArchipelagoLttPAdjuster"; Parameters: "--update_sprites"; StatusMsg: "Updating Sprite Library..."; Flags: nowait; Components: lttp_sprites
 Filename: "{app}\ArchipelagoLauncher"; Parameters: "--update_settings"; StatusMsg: "Updating host.yaml..."; Flags: runasoriginaluser runhidden
 Filename: "{app}\ArchipelagoLauncher"; Description: "{cm:LaunchProgram,{#StringChange('Launcher', '&', '&&')}}"; Flags: nowait postinstall skipifsilent
 
@@ -87,11 +87,7 @@ Type: files; Name: "{app}\lib\worlds\_bizhawk.apworld"
 Type: files; Name: "{app}\ArchipelagoLttPClient.exe"
 Type: files; Name: "{app}\ArchipelagoPokemonClient.exe"
 Type: files; Name: "{app}\data\lua\connector_pkmn_rb.lua"
-Type: filesandordirs; Name: "{app}\lib\worlds\rogue-legacy"
-Type: dirifempty; Name: "{app}\lib\worlds\rogue-legacy"
-Type: filesandordirs; Name: "{app}\lib\worlds\bk_sudoku"
-Type: dirifempty; Name: "{app}\lib\worlds\bk_sudoku"
-Type: files; Name: "{app}\ArchipelagoLauncher(DEBUG).exe"
+Type: filesandordirs; Name: "{app}\lib\worlds\rogue-legacy*"
 Type: filesandordirs; Name: "{app}\SNI\lua*"
 Type: filesandordirs; Name: "{app}\EnemizerCLI*"
 #include "installdelete.iss"
@@ -213,11 +209,6 @@ Root: HKCR; Subkey: "{#MyAppName}multidata";                     ValueData: "Arc
 Root: HKCR; Subkey: "{#MyAppName}multidata\DefaultIcon";         ValueData: "{app}\ArchipelagoServer.exe,0";                         ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata\shell\open\command";  ValueData: """{app}\ArchipelagoServer.exe"" ""%1""";                ValueType: string;  ValueName: "";
 
-Root: HKCR; Subkey: ".apworld";                                 ValueData: "{#MyAppName}worlddata";  Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}worlddata";                    ValueData: "Archipelago World Data"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}worlddata\DefaultIcon";        ValueData: "{app}\ArchipelagoLauncher.exe,0";                 ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}worlddata\shell\open\command"; ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";
-
 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";

kvui.py

@@ -64,7 +64,7 @@ from kivy.uix.popup import Popup
 fade_in_animation = Animation(opacity=0, duration=0) + Animation(opacity=1, duration=0.25)
 
 from NetUtils import JSONtoTextParser, JSONMessagePart, SlotType
-from Utils import async_start, get_input_text_from_response
+from Utils import async_start
 
 if typing.TYPE_CHECKING:
     import CommonClient
@@ -285,10 +285,16 @@ class SelectableLabel(RecycleDataViewBehavior, TooltipLabel):
                 temp = MarkupLabel(text=self.text).markup
                 text = "".join(part for part in temp if not part.startswith(("[color", "[/color]", "[ref=", "[/ref]")))
                 cmdinput = App.get_running_app().textinput
-                if not cmdinput.text:
-                    input_text = get_input_text_from_response(text, App.get_running_app().last_autofillable_command)
-                    if input_text is not None:
-                        cmdinput.text = input_text
+                if not cmdinput.text and " did you mean " in text:
+                    for question in ("Didn't find something that closely matches, did you mean ",
+                                     "Too many close matches, did you mean "):
+                        if text.startswith(question):
+                            name = Utils.get_text_between(text, question,
+                                                          "? (")
+                            cmdinput.text = f"!{App.get_running_app().last_autofillable_command} {name}"
+                            break
+                elif not cmdinput.text and text.startswith("Missing: "):
+                    cmdinput.text = text.replace("Missing: ", "!hint_location ")
 
                 Clipboard.copy(text.replace("&", "&").replace("&bl;", "[").replace("&br;", "]"))
                 return self.parent.select_with_touch(self.index, touch)
@@ -677,18 +683,10 @@ class HintLog(RecycleView):
         for hint in hints:
             data.append({
                 "receiving": {"text": self.parser.handle_node({"type": "player_id", "text": hint["receiving_player"]})},
-                "item": {"text": self.parser.handle_node({
-                    "type": "item_id",
-                    "text": hint["item"],
-                    "flags": hint["item_flags"],
-                    "player": hint["receiving_player"],
-                })},
+                "item": {"text": self.parser.handle_node(
+                    {"type": "item_id", "text": hint["item"], "flags": hint["item_flags"]})},
                 "finding": {"text": self.parser.handle_node({"type": "player_id", "text": hint["finding_player"]})},
-                "location": {"text": self.parser.handle_node({
-                    "type": "location_id",
-                    "text": hint["location"],
-                    "player": hint["finding_player"],
-                })},
+                "location": {"text": self.parser.handle_node({"type": "location_id", "text": hint["location"]})},
                 "entrance": {"text": self.parser.handle_node({"type": "color" if hint["entrance"] else "text",
                                                               "color": "blue", "text": hint["entrance"]
                                                               if hint["entrance"] else "Vanilla"})},

requirements.txt

@@ -2,13 +2,13 @@ colorama>=0.4.6
 websockets>=12.0
 PyYAML>=6.0.1
 jellyfish>=1.0.3
-jinja2>=3.1.4
-schema>=0.7.7
+jinja2>=3.1.3
+schema>=0.7.5
 kivy>=2.3.0
 bsdiff4>=1.2.4
-platformdirs>=4.2.2
-certifi>=2024.6.2
-cython>=3.0.10
+platformdirs>=4.1.0
+certifi>=2023.11.17
+cython>=3.0.8
 cymem>=2.0.8
-orjson>=3.10.3
-typing_extensions>=4.12.1
+orjson>=3.9.10
+typing_extensions>=4.7.0

settings.py

@@ -643,6 +643,17 @@ class GeneratorOptions(Group):
         PLAYTHROUGH = 2
         FULL = 3
 
+    class GlitchTriforceRoom(IntEnum):
+        """
+        Glitch to Triforce room from Ganon
+        When disabled, you have to have a weapon that can hurt ganon (master sword or swordless/easy item functionality
+        + hammer) and have completed the goal required for killing ganon to be able to access the triforce room.
+        1 -> Enabled.
+        0 -> Disabled (except in no-logic)
+        """
+        OFF = 0
+        ON = 1
+
     class PlandoOptions(str):
         """
         List of options that can be plando'd. Can be combined, for example "bosses, items"
@@ -654,14 +665,6 @@ class GeneratorOptions(Group):
         OFF = 0
         ON = 1
 
-    class PanicMethod(str):
-        """
-        What to do if the current item placements appear unsolvable.
-        raise -> Raise an exception and abort.
-        swap -> Attempt to fix it by swapping prior placements around. (Default)
-        start_inventory -> Move remaining items to start_inventory, generate additional filler items to fill locations.
-        """
-
     enemizer_path: EnemizerPath = EnemizerPath("EnemizerCLI/EnemizerCLI.Core")  # + ".exe" is implied on Windows
     player_files_path: PlayerFilesPath = PlayerFilesPath("Players")
     players: Players = Players(0)
@@ -670,7 +673,6 @@ class GeneratorOptions(Group):
     spoiler: Spoiler = Spoiler(3)
     race: Race = Race(0)
     plando_options: PlandoOptions = PlandoOptions("bosses, connections, texts")
-    panic_method: PanicMethod = PanicMethod("swap")
 
 
 class SNIOptions(Group):

setup.py

@@ -21,7 +21,7 @@ from pathlib import Path
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
 try:
-    requirement = 'cx-Freeze==7.0.0'
+    requirement = 'cx-Freeze>=7.0.0'
     import pkg_resources
     try:
         pkg_resources.require(requirement)
@@ -190,7 +190,7 @@ if is_windows:
     c = next(component for component in components if component.script_name == "Launcher")
     exes.append(cx_Freeze.Executable(
         script=f"{c.script_name}.py",
-        target_name=f"{c.frozen_name}Debug.exe",
+        target_name=f"{c.frozen_name}(DEBUG).exe",
         icon=resolve_icon(c.icon),
     ))
 

test/general/test_client_server_interaction.py

@@ -1,23 +0,0 @@
-import unittest
-
-from Utils import get_intended_text, get_input_text_from_response
-
-
-class TestClient(unittest.TestCase):
-    def test_autofill_hint_from_fuzzy_hint(self) -> None:
-        tests = (
-            ("item", ["item1", "item2"]),          # Multiple close matches
-            ("itm", ["item1", "item21"]),          # No close match, multiple option
-            ("item", ["item1"]),                   # No close match, single option
-            ("item", ["\"item\" 'item' (item)"]),  # Testing different special characters
-        )
-
-        for input_text, possible_answers in tests:
-            item_name, usable, response = get_intended_text(input_text, possible_answers)
-            self.assertFalse(usable, "This test must be updated, it seems get_fuzzy_results behavior changed")
-
-            hint_command = get_input_text_from_response(response, "hint")
-            self.assertIsNotNone(hint_command,
-                                 "The response to fuzzy hints is no longer recognized by the hint autofill")
-            self.assertEqual(hint_command, f"!hint {item_name}",
-                             "The hint command autofilled by the response is not correct")

test/general/test_ids.py

@@ -6,6 +6,22 @@ from . import setup_solo_multiworld
 
 
 class TestIDs(unittest.TestCase):
+    def test_unique_items(self):
+        """Tests that every game has a unique ID per item in the datapackage"""
+        known_item_ids = set()
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            current = len(known_item_ids)
+            known_item_ids |= set(world_type.item_id_to_name)
+            self.assertEqual(len(known_item_ids) - len(world_type.item_id_to_name), current)
+
+    def test_unique_locations(self):
+        """Tests that every game has a unique ID per location in the datapackage"""
+        known_location_ids = set()
+        for gamename, world_type in AutoWorldRegister.world_types.items():
+            current = len(known_location_ids)
+            known_location_ids |= set(world_type.location_id_to_name)
+            self.assertEqual(len(known_location_ids) - len(world_type.location_id_to_name), current)
+
     def test_range_items(self):
         """There are Javascript clients, which are limited to Number.MAX_SAFE_INTEGER due to 64bit float precision."""
         for gamename, world_type in AutoWorldRegister.world_types.items():

test/general/test_items.py

@@ -64,6 +64,15 @@ class TestBase(unittest.TestCase):
                 for item in multiworld.itempool:
                     self.assertIn(item.name, world_type.item_name_to_id)
 
+    def test_item_descriptions_have_valid_names(self):
+        """Ensure all item descriptions match an item name or item group name"""
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            valid_names = world_type.item_names.union(world_type.item_name_groups)
+            for name in world_type.item_descriptions:
+                with self.subTest("Name should be valid", game=game_name, item=name):
+                    self.assertIn(name, valid_names,
+                                  "All item descriptions must match defined item names")
+
     def test_itempool_not_modified(self):
         """Test that worlds don't modify the itempool after `create_items`"""
         gen_steps = ("generate_early", "create_regions", "create_items")

test/general/test_locations.py

@@ -66,3 +66,12 @@ class TestBase(unittest.TestCase):
                         for location in locations:
                             self.assertIn(location, world_type.location_name_to_id)
                         self.assertNotIn(group_name, world_type.location_name_to_id)
+
+    def test_location_descriptions_have_valid_names(self):
+        """Ensure all location descriptions match a location name or location group name"""
+        for game_name, world_type in AutoWorldRegister.world_types.items():
+            valid_names = world_type.location_names.union(world_type.location_name_groups)
+            for name in world_type.location_descriptions:
+                with self.subTest("Name should be valid", game=game_name, location=name):
+                    self.assertIn(name, valid_names,
+                                  "All location descriptions must match defined location names")

test/general/test_player_options.py

@@ -31,7 +31,7 @@ class TestPlayerOptions(unittest.TestCase):
         self.assertEqual(new_weights["list_2"], ["string_3"])
         self.assertEqual(new_weights["list_1"], ["string", "string_2"])
         self.assertEqual(new_weights["dict_1"]["option_a"], 50)
-        self.assertEqual(new_weights["dict_1"]["option_b"], 50)
+        self.assertEqual(new_weights["dict_1"]["option_b"], 0)
         self.assertEqual(new_weights["dict_1"]["option_c"], 50)
         self.assertNotIn("option_f", new_weights["dict_2"])
         self.assertEqual(new_weights["dict_2"]["option_g"], 50)

test/hosting/__main__.py

@@ -1,191 +0,0 @@
-# A bunch of tests to verify MultiServer and custom webhost server work as expected.
-# This spawns processes and may modify your local AP, so this is not run as part of unit testing.
-# Run with `python test/hosting` instead,
-import logging
-import traceback
-from tempfile import TemporaryDirectory
-from time import sleep
-from typing import Any
-
-from test.hosting.client import Client
-from test.hosting.generate import generate_local
-from test.hosting.serve import ServeGame, LocalServeGame, WebHostServeGame
-from test.hosting.webhost import (create_room, get_app, get_multidata_for_room, set_multidata_for_room, start_room,
-                                  stop_autohost, upload_multidata)
-from test.hosting.world import copy as copy_world, delete as delete_world
-
-failure = False
-fail_fast = True
-
-
-def assert_true(condition: Any, msg: str = "") -> None:
-    global failure
-    if not condition:
-        failure = True
-        msg = f": {msg}" if msg else ""
-        raise AssertionError(f"Assertion failed{msg}")
-
-
-def assert_equal(first: Any, second: Any, msg: str = "") -> None:
-    global failure
-    if first != second:
-        failure = True
-        msg = f": {msg}" if msg else ""
-        raise AssertionError(f"Assertion failed: {first} == {second}{msg}")
-
-
-if fail_fast:
-    expect_true = assert_true
-    expect_equal = assert_equal
-else:
-    def expect_true(condition: Any, msg: str = "") -> None:
-        global failure
-        if not condition:
-            failure = True
-            tb = "".join(traceback.format_stack()[:-1])
-            msg = f": {msg}" if msg else ""
-            logging.error(f"Expectation failed{msg}\n{tb}")
-
-    def expect_equal(first: Any, second: Any, msg: str = "") -> None:
-        global failure
-        if first != second:
-            failure = True
-            tb = "".join(traceback.format_stack()[:-1])
-            msg = f": {msg}" if msg else ""
-            logging.error(f"Expectation failed {first} == {second}{msg}\n{tb}")
-
-
-if __name__ == "__main__":
-    import warnings
-    warnings.simplefilter("ignore", ResourceWarning)
-    warnings.simplefilter("ignore", UserWarning)
-
-    spacer = '=' * 80
-
-    with TemporaryDirectory() as tempdir:
-        multis = [["Clique"], ["Temp World"], ["Clique", "Temp World"]]
-        p1_games = []
-        data_paths = []
-        rooms = []
-
-        copy_world("Clique", "Temp World")
-        try:
-            for n, games in enumerate(multis, 1):
-                print(f"Generating [{n}] {', '.join(games)}")
-                multidata = generate_local(games, tempdir)
-                print(f"Generated [{n}] {', '.join(games)} as {multidata}\n")
-                p1_games.append(games[0])
-                data_paths.append(multidata)
-        finally:
-            delete_world("Temp World")
-
-        webapp = get_app(tempdir)
-        webhost_client = webapp.test_client()
-        for n, multidata in enumerate(data_paths, 1):
-            seed = upload_multidata(webhost_client, multidata)
-            room = create_room(webhost_client, seed)
-            print(f"Uploaded [{n}] {multidata} as {room}\n")
-            rooms.append(room)
-
-        print("Starting autohost")
-        from WebHostLib.autolauncher import autohost
-        try:
-            autohost(webapp.config)
-
-            host: ServeGame
-            for n, (multidata, room, game, multi_games) in enumerate(zip(data_paths, rooms, p1_games, multis), 1):
-                involved_games = {"Archipelago"} | set(multi_games)
-                for collected_items in range(3):
-                    print(f"\nTesting [{n}] {game} in {multidata} on MultiServer with {collected_items} items collected")
-                    with LocalServeGame(multidata) as host:
-                        with Client(host.address, game, "Player1") as client:
-                            local_data_packages = client.games_packages
-                            local_collected_items = len(client.checked_locations)
-                            if collected_items < 2:  # Clique only has 2 Locations
-                                client.collect_any()
-                            # TODO: Ctrl+C test here as well
-
-                    for game_name in sorted(involved_games):
-                        expect_true(game_name in local_data_packages,
-                                    f"{game_name} missing from MultiServer datap ackage")
-                        expect_true("item_name_groups" not in local_data_packages.get(game_name, {}),
-                                    f"item_name_groups are not supposed to be in MultiServer data for {game_name}")
-                        expect_true("location_name_groups" not in local_data_packages.get(game_name, {}),
-                                    f"location_name_groups are not supposed to be in MultiServer data for {game_name}")
-                    for game_name in local_data_packages:
-                        expect_true(game_name in involved_games,
-                                    f"Received unexpected extra data package for {game_name} from MultiServer")
-                    assert_equal(local_collected_items, collected_items,
-                                 "MultiServer did not load or save correctly")
-
-                    print(f"\nTesting [{n}] {game} in {multidata} on customserver with {collected_items} items collected")
-                    prev_host_adr: str
-                    with WebHostServeGame(webhost_client, room) as host:
-                        prev_host_adr = host.address
-                        with Client(host.address, game, "Player1") as client:
-                            web_data_packages = client.games_packages
-                            web_collected_items = len(client.checked_locations)
-                            if collected_items < 2:  # Clique only has 2 Locations
-                                client.collect_any()
-                            if collected_items == 1:
-                                sleep(1)  # wait for the server to collect the item
-                                stop_autohost(True)  # simulate Ctrl+C
-                                sleep(3)
-                                autohost(webapp.config)  # this will spin the room right up again
-                                sleep(1)  # make log less annoying
-                                # if saving failed, the next iteration will fail below
-
-                    # verify server shut down
-                    try:
-                        with Client(prev_host_adr, game, "Player1") as client:
-                            assert_true(False, "Server did not shut down")
-                    except ConnectionError:
-                        pass
-
-                    for game_name in sorted(involved_games):
-                        expect_true(game_name in web_data_packages,
-                                    f"{game_name} missing from customserver data package")
-                        expect_true("item_name_groups" not in web_data_packages.get(game_name, {}),
-                                    f"item_name_groups are not supposed to be in customserver data for {game_name}")
-                        expect_true("location_name_groups" not in web_data_packages.get(game_name, {}),
-                                    f"location_name_groups are not supposed to be in customserver data for {game_name}")
-                    for game_name in web_data_packages:
-                        expect_true(game_name in involved_games,
-                                    f"Received unexpected extra data package for {game_name} from customserver")
-                    assert_equal(web_collected_items, collected_items,
-                                 "customserver did not load or save correctly during/after "
-                                 + ("Ctrl+C" if collected_items == 2 else "/exit"))
-
-                    # compare customserver to MultiServer
-                    expect_equal(local_data_packages, web_data_packages,
-                                 "customserver datapackage differs from MultiServer")
-
-            sleep(5.5)  # make sure all tasks actually stopped
-
-            # raise an exception in customserver and verify the save doesn't get destroyed
-            # local variables room is the last room's id here
-            old_data = get_multidata_for_room(webhost_client, room)
-            print(f"Destroying multidata for {room}")
-            set_multidata_for_room(webhost_client, room, bytes([0]))
-            try:
-                start_room(webhost_client, room, timeout=7)
-            except TimeoutError:
-                pass
-            else:
-                assert_true(False, "Room started with destroyed multidata")
-            print(f"Restoring multidata for {room}")
-            set_multidata_for_room(webhost_client, room, old_data)
-            with WebHostServeGame(webhost_client, room) as host:
-                with Client(host.address, game, "Player1") as client:
-                    assert_equal(len(client.checked_locations), 2,
-                                 "Save was destroyed during exception in customserver")
-                    print("Save file is not busted 🥳")
-
-        finally:
-            print("Stopping autohost")
-            stop_autohost(False)
-
-    if failure:
-        print("Some tests failed")
-        exit(1)
-    exit(0)

test/hosting/client.py

@@ -1,110 +0,0 @@
-import json
-import sys
-from typing import Any, Collection, Dict, Iterable, Optional
-from websockets import ConnectionClosed
-from websockets.sync.client import connect, ClientConnection
-from threading import Thread
-
-
-__all__ = [
-    "Client"
-]
-
-
-class Client:
-    """Incomplete, minimalistic sync test client for AP network protocol"""
-
-    recv_timeout = 1.0
-
-    host: str
-    game: str
-    slot: str
-    password: Optional[str]
-
-    _ws: Optional[ClientConnection]
-
-    games: Iterable[str]
-    data_package_checksums: Dict[str, Any]
-    games_packages: Dict[str, Any]
-    missing_locations: Collection[int]
-    checked_locations: Collection[int]
-
-    def __init__(self, host: str, game: str, slot: str, password: Optional[str] = None) -> None:
-        self.host = host
-        self.game = game
-        self.slot = slot
-        self.password = password
-        self._ws = None
-        self.games = []
-        self.data_package_checksums = {}
-        self.games_packages = {}
-        self.missing_locations = []
-        self.checked_locations = []
-
-    def __enter__(self) -> "Client":
-        try:
-            self.connect()
-        except BaseException:
-            self.__exit__(*sys.exc_info())
-            raise
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore
-        self.close()
-
-    def _poll(self) -> None:
-        assert self._ws
-        try:
-            while True:
-                self._ws.recv()
-        except (TimeoutError, ConnectionClosed, KeyboardInterrupt, SystemExit):
-            pass
-
-    def connect(self) -> None:
-        self._ws = connect(f"ws://{self.host}")
-        room_info = json.loads(self._ws.recv(self.recv_timeout))[0]
-        self.games = sorted(room_info["games"])
-        self.data_package_checksums = room_info["datapackage_checksums"]
-        self._ws.send(json.dumps([{
-            "cmd": "GetDataPackage",
-            "games": list(self.games),
-        }]))
-        data_package_msg = json.loads(self._ws.recv(self.recv_timeout))[0]
-        self.games_packages = data_package_msg["data"]["games"]
-        self._ws.send(json.dumps([{
-            "cmd": "Connect",
-            "game": self.game,
-            "name": self.slot,
-            "password": self.password,
-            "uuid": "",
-            "version": {
-                "class": "Version",
-                "major": 0,
-                "minor": 4,
-                "build": 6,
-            },
-            "items_handling": 0,
-            "tags": [],
-            "slot_data": False,
-        }]))
-        connect_result_msg = json.loads(self._ws.recv(self.recv_timeout))[0]
-        if connect_result_msg["cmd"] != "Connected":
-            raise ConnectionError(", ".join(connect_result_msg.get("errors", [connect_result_msg["cmd"]])))
-        self.missing_locations = connect_result_msg["missing_locations"]
-        self.checked_locations = connect_result_msg["checked_locations"]
-
-    def close(self) -> None:
-        if self._ws:
-            Thread(target=self._poll).start()
-            self._ws.close()
-
-    def collect(self, locations: Iterable[int]) -> None:
-        if not self._ws:
-            raise ValueError("Not connected")
-        self._ws.send(json.dumps([{
-            "cmd": "LocationChecks",
-            "locations": locations,
-        }]))
-
-    def collect_any(self) -> None:
-        self.collect([next(iter(self.missing_locations))])

test/hosting/generate.py

@@ -1,75 +0,0 @@
-import json
-import sys
-import warnings
-from pathlib import Path
-from typing import Iterable, Union, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from multiprocessing.managers import ListProxy  # noqa
-
-__all__ = [
-    "generate_local",
-]
-
-
-def _generate_local_inner(games: Iterable[str],
-                          dest: Union[Path, str],
-                          results: "ListProxy[Union[Path, BaseException]]") -> None:
-    original_argv = sys.argv
-    warnings.simplefilter("ignore")
-    try:
-        from tempfile import TemporaryDirectory
-
-        if not isinstance(dest, Path):
-            dest = Path(dest)
-
-        with TemporaryDirectory() as players_dir:
-            with TemporaryDirectory() as output_dir:
-                import Generate
-
-                for n, game in enumerate(games, 1):
-                    player_path = Path(players_dir) / f"{n}.yaml"
-                    with open(player_path, "w", encoding="utf-8") as f:
-                        f.write(json.dumps({
-                            "name": f"Player{n}",
-                            "game": game,
-                            game: {"hard_mode": "true"},
-                            "description": f"generate_local slot {n} ('Player{n}'): {game}",
-                        }))
-
-                # this is basically copied from test/programs/test_generate.py
-                # uses a reproducible seed that is different for each set of games
-                sys.argv = [sys.argv[0], "--seed", str(hash(tuple(games))),
-                            "--player_files_path", players_dir,
-                            "--outputpath", output_dir]
-                Generate.main()
-                output_files = list(Path(output_dir).glob('*.zip'))
-                assert len(output_files) == 1
-                final_file = dest / output_files[0].name
-                output_files[0].rename(final_file)
-                results.append(final_file)
-    except BaseException as e:
-        results.append(e)
-        raise e
-    finally:
-        sys.argv = original_argv
-
-
-def generate_local(games: Iterable[str], dest: Union[Path, str]) -> Path:
-    from multiprocessing import Manager, Process, set_start_method
-
-    try:
-        set_start_method("spawn")
-    except RuntimeError:
-        pass
-
-    manager = Manager()
-    results: "ListProxy[Union[Path, Exception]]" = manager.list()
-
-    p = Process(target=_generate_local_inner, args=(games, dest, results))
-    p.start()
-    p.join()
-    result = results[0]
-    if isinstance(result, BaseException):
-        raise Exception("Could not generate multiworld") from result
-    return result

test/hosting/serve.py

@@ -1,115 +0,0 @@
-import sys
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from threading import Event
-    from werkzeug.test import Client as FlaskClient
-
-__all__ = [
-    "ServeGame",
-    "LocalServeGame",
-    "WebHostServeGame",
-]
-
-
-class ServeGame:
-    address: str
-
-
-def _launch_multiserver(multidata: Path, ready: "Event", stop: "Event") -> None:
-    import os
-    import warnings
-
-    original_argv = sys.argv
-    original_stdin = sys.stdin
-    warnings.simplefilter("ignore")
-    try:
-        import asyncio
-        from MultiServer import main, parse_args
-
-        sys.argv = [sys.argv[0], str(multidata), "--host", "127.0.0.1"]
-        r, w = os.pipe()
-        sys.stdin = os.fdopen(r, "r")
-
-        async def set_ready() -> None:
-            await asyncio.sleep(.01)  # switch back to other task once more
-            ready.set()  # server should be up, set ready state
-
-        async def wait_stop() -> None:
-            await asyncio.get_event_loop().run_in_executor(None, stop.wait)
-            os.fdopen(w, "w").write("/exit")
-
-        async def run() -> None:
-            # this will run main() until first await, then switch to set_ready()
-            await asyncio.gather(
-                main(parse_args()),
-                set_ready(),
-                wait_stop(),
-            )
-
-        asyncio.run(run())
-    finally:
-        sys.argv = original_argv
-        sys.stdin = original_stdin
-
-
-class LocalServeGame(ServeGame):
-    from multiprocessing import Process
-
-    _multidata: Path
-    _proc: Process
-    _stop: "Event"
-
-    def __init__(self, multidata: Path) -> None:
-        self.address = ""
-        self._multidata = multidata
-
-    def __enter__(self) -> "LocalServeGame":
-        from multiprocessing import Manager, Process, set_start_method
-
-        try:
-            set_start_method("spawn")
-        except RuntimeError:
-            pass
-
-        manager = Manager()
-        ready: "Event" = manager.Event()
-        self._stop = manager.Event()
-
-        self._proc = Process(target=_launch_multiserver, args=(self._multidata, ready, self._stop))
-        try:
-            self._proc.start()
-            ready.wait(30)
-            self.address = "localhost:38281"
-            return self
-        except BaseException:
-            self.__exit__(*sys.exc_info())
-            raise
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore
-        try:
-            self._stop.set()
-            self._proc.join(30)
-        except TimeoutError:
-            self._proc.terminate()
-            self._proc.join()
-
-
-class WebHostServeGame(ServeGame):
-    _client: "FlaskClient"
-    _room: str
-
-    def __init__(self, app_client: "FlaskClient", room: str) -> None:
-        self.address = ""
-        self._client = app_client
-        self._room = room
-
-    def __enter__(self) -> "WebHostServeGame":
-        from .webhost import start_room
-        self.address = start_room(self._client, self._room)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb) -> None:  # type: ignore
-        from .webhost import stop_room
-        stop_room(self._client, self._room, timeout=30)

test/hosting/webhost.py

@@ -1,201 +0,0 @@
-import re
-from pathlib import Path
-from typing import TYPE_CHECKING, Optional, cast
-
-if TYPE_CHECKING:
-    from flask import Flask
-    from werkzeug.test import Client as FlaskClient
-
-__all__ = [
-    "get_app",
-    "upload_multidata",
-    "create_room",
-    "start_room",
-    "stop_room",
-    "set_room_timeout",
-    "get_multidata_for_room",
-    "set_multidata_for_room",
-    "stop_autohost",
-]
-
-
-def get_app(tempdir: str) -> "Flask":
-    from WebHostLib import app as raw_app
-    from WebHost import get_app
-    raw_app.config["PONY"] = {
-        "provider": "sqlite",
-        "filename": str(Path(tempdir) / "host.db"),
-        "create_db": True,
-    }
-    raw_app.config.update({
-        "TESTING": True,
-        "HOST_ADDRESS": "localhost",
-        "HOSTERS": 1,
-    })
-    return get_app()
-
-
-def upload_multidata(app_client: "FlaskClient", multidata: Path) -> str:
-    response = app_client.post("/uploads", data={
-        "file": multidata.open("rb"),
-    })
-    assert response.status_code < 400, f"Upload of {multidata} failed: status {response.status_code}"
-    assert "Location" in response.headers, f"Upload of {multidata} failed: no redirect"
-    location = response.headers["Location"]
-    assert isinstance(location, str)
-    assert location.startswith("/seed/"), f"Upload of {multidata} failed: unexpected redirect"
-    return location[6:]
-
-
-def create_room(app_client: "FlaskClient", seed: str, auto_start: bool = False) -> str:
-    response = app_client.get(f"/new_room/{seed}")
-    assert response.status_code < 400, f"Creating room for {seed} failed: status {response.status_code}"
-    assert "Location" in response.headers, f"Creating room for {seed} failed: no redirect"
-    location = response.headers["Location"]
-    assert isinstance(location, str)
-    assert location.startswith("/room/"), f"Creating room for {seed} failed: unexpected redirect"
-    room_id = location[6:]
-
-    if not auto_start:
-        # by default, creating a room will auto-start it, so we update last activity here
-        stop_room(app_client, room_id, simulate_idle=False)
-
-    return room_id
-
-
-def start_room(app_client: "FlaskClient", room_id: str, timeout: float = 30) -> str:
-    from time import sleep
-
-    poll_interval = .2
-
-    print(f"Starting room {room_id}")
-    no_timeout = timeout <= 0
-    while no_timeout or timeout > 0:
-        response = app_client.get(f"/room/{room_id}")
-        assert response.status_code == 200, f"Starting room for {room_id} failed: status {response.status_code}"
-        match = re.search(r"/connect ([\w:.\-]+)", response.text)
-        if match:
-            return match[1]
-        timeout -= poll_interval
-        sleep(poll_interval)
-    raise TimeoutError("Room did not start")
-
-
-def stop_room(app_client: "FlaskClient",
-              room_id: str,
-              timeout: Optional[float] = None,
-              simulate_idle: bool = True) -> None:
-    from datetime import datetime, timedelta
-    from time import sleep
-
-    from pony.orm import db_session
-
-    from WebHostLib.models import Command, Room
-    from WebHostLib import app
-
-    poll_interval = 2
-
-    print(f"Stopping room {room_id}")
-    room_uuid = app.url_map.converters["suuid"].to_python(None, room_id)  # type: ignore[arg-type]
-
-    if timeout is not None:
-        sleep(.1)  # should not be required, but other things might use threading
-
-    with db_session:
-        room: Room = Room.get(id=room_uuid)
-        if simulate_idle:
-            new_last_activity = datetime.utcnow() - timedelta(seconds=room.timeout + 5)
-        else:
-            new_last_activity = datetime.utcnow() - timedelta(days=3)
-        room.last_activity = new_last_activity
-        address = f"localhost:{room.last_port}" if room.last_port > 0 else None
-        if address:
-            original_timeout = room.timeout
-            room.timeout = 1  # avoid spinning it up again
-            Command(room=room, commandtext="/exit")
-
-    try:
-        if address and timeout is not None:
-            print("waiting for shutdown")
-            import socket
-            host_str, port_str = tuple(address.split(":"))
-            address_tuple = host_str, int(port_str)
-
-            no_timeout = timeout <= 0
-            while no_timeout or timeout > 0:
-                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-                try:
-                    s.connect(address_tuple)
-                    s.close()
-                except ConnectionRefusedError:
-                    return
-                sleep(poll_interval)
-                timeout -= poll_interval
-
-            raise TimeoutError("Room did not stop")
-    finally:
-        with db_session:
-            room = Room.get(id=room_uuid)
-            room.last_port = 0  # easier to detect when the host is up this way
-            if address:
-                room.timeout = original_timeout
-                room.last_activity = new_last_activity
-                print("timeout restored")
-
-
-def set_room_timeout(room_id: str, timeout: float) -> None:
-    from pony.orm import db_session
-
-    from WebHostLib.models import Room
-    from WebHostLib import app
-
-    room_uuid = app.url_map.converters["suuid"].to_python(None, room_id)  # type: ignore[arg-type]
-    with db_session:
-        room: Room = Room.get(id=room_uuid)
-        room.timeout = timeout
-
-
-def get_multidata_for_room(webhost_client: "FlaskClient", room_id: str) -> bytes:
-    from pony.orm import db_session
-
-    from WebHostLib.models import Room
-    from WebHostLib import app
-
-    room_uuid = app.url_map.converters["suuid"].to_python(None, room_id)  # type: ignore[arg-type]
-    with db_session:
-        room: Room = Room.get(id=room_uuid)
-        return cast(bytes, room.seed.multidata)
-
-
-def set_multidata_for_room(webhost_client: "FlaskClient", room_id: str, data: bytes) -> None:
-    from pony.orm import db_session
-
-    from WebHostLib.models import Room
-    from WebHostLib import app
-
-    room_uuid = app.url_map.converters["suuid"].to_python(None, room_id)  # type: ignore[arg-type]
-    with db_session:
-        room: Room = Room.get(id=room_uuid)
-        room.seed.multidata = data
-
-
-def stop_autohost(graceful: bool = True) -> None:
-    import os
-    import signal
-
-    import multiprocessing
-
-    from WebHostLib.autolauncher import stop
-
-    stop()
-    proc: multiprocessing.process.BaseProcess
-    for proc in filter(lambda child: child.name.startswith("MultiHoster"), multiprocessing.active_children()):
-        if graceful and proc.pid:
-            os.kill(proc.pid, getattr(signal, "CTRL_C_EVENT", signal.SIGINT))
-        else:
-            proc.kill()
-        try:
-            proc.join(30)
-        except TimeoutError:
-            proc.kill()
-            proc.join()

test/hosting/world.py

@@ -1,42 +0,0 @@
-import re
-import shutil
-from pathlib import Path
-from typing import Dict
-
-
-__all__ = ["copy", "delete"]
-
-
-_new_worlds: Dict[str, str] = {}
-
-
-def copy(src: str, dst: str) -> None:
-    from Utils import get_file_safe_name
-    from worlds import AutoWorldRegister
-
-    assert dst not in _new_worlds, "World already created"
-    if '"' in dst or "\\" in dst:  # easier to reject than to escape
-        raise ValueError(f"Unsupported symbols in {dst}")
-    dst_folder_name = get_file_safe_name(dst.lower())
-    src_cls = AutoWorldRegister.world_types[src]
-    src_folder = Path(src_cls.__file__).parent
-    worlds_folder = src_folder.parent
-    if (not src_cls.__file__.endswith("__init__.py") or not src_folder.is_dir()
-            or not (worlds_folder / "generic").is_dir()):
-        raise ValueError(f"Unsupported layout for copy_world from {src}")
-    dst_folder = worlds_folder / dst_folder_name
-    if dst_folder.is_dir():
-        raise ValueError(f"Destination {dst_folder} already exists")
-    shutil.copytree(src_folder, dst_folder)
-    _new_worlds[dst] = str(dst_folder)
-    with open(dst_folder / "__init__.py", "r", encoding="utf-8-sig") as f:
-        contents = f.read()
-    contents = re.sub(r'game\s*=\s*[\'"]' + re.escape(src) + r'[\'"]', f'game = "{dst}"', contents)
-    with open(dst_folder / "__init__.py", "w", encoding="utf-8") as f:
-        f.write(contents)
-
-
-def delete(name: str) -> None:
-    assert name in _new_worlds, "World not created by this script"
-    shutil.rmtree(_new_worlds[name])
-    del _new_worlds[name]

test/options/test_option_classes.py

@@ -1,67 +0,0 @@
-import unittest
-
-from Options import Choice, DefaultOnToggle, Toggle
-
-
-class TestNumericOptions(unittest.TestCase):
-    def test_numeric_option(self) -> None:
-        """Tests the initialization and equivalency comparisons of the base Numeric Option class."""
-        class TestChoice(Choice):
-            option_zero = 0
-            option_one = 1
-            option_two = 2
-            alias_three = 1
-            non_option_attr = 2
-
-        class TestToggle(Toggle):
-            pass
-
-        class TestDefaultOnToggle(DefaultOnToggle):
-            pass
-
-        with self.subTest("choice"):
-            choice_option_default = TestChoice.from_any(TestChoice.default)
-            choice_option_string = TestChoice.from_any("one")
-            choice_option_int = TestChoice.from_any(2)
-            choice_option_alias = TestChoice.from_any("three")
-            choice_option_attr = TestChoice.from_any(TestChoice.option_two)
-            
-            self.assertEqual(choice_option_default, TestChoice.option_zero,
-                "assigning default didn't match default value")
-            self.assertEqual(choice_option_string, "one")
-            self.assertEqual(choice_option_int, 2)
-            self.assertEqual(choice_option_alias, TestChoice.alias_three)
-            self.assertEqual(choice_option_attr, TestChoice.non_option_attr)
-
-            self.assertRaises(KeyError, TestChoice.from_any, "four")
-            
-            self.assertIn(choice_option_int, [1, 2, 3])
-            self.assertIn(choice_option_int, {2})
-            self.assertIn(choice_option_int, (2,))
-
-            self.assertIn(choice_option_string, ["one", "two", "three"])
-            # this fails since the hash is derived from the value
-            self.assertNotIn(choice_option_string, {"one"})
-            self.assertIn(choice_option_string, ("one",))
-
-        with self.subTest("toggle"):
-            toggle_default = TestToggle.from_any(TestToggle.default)
-            toggle_string = TestToggle.from_any("false")
-            toggle_int = TestToggle.from_any(0)
-            toggle_alias = TestToggle.from_any("off")
-
-            self.assertFalse(toggle_default)
-            self.assertFalse(toggle_string)
-            self.assertFalse(toggle_int)
-            self.assertFalse(toggle_alias)
-
-        with self.subTest("on toggle"):
-            toggle_default = TestDefaultOnToggle.from_any(TestDefaultOnToggle.default)
-            toggle_string = TestDefaultOnToggle.from_any("true")
-            toggle_int = TestDefaultOnToggle.from_any(1)
-            toggle_alias = TestDefaultOnToggle.from_any("on")
-
-            self.assertTrue(toggle_default)
-            self.assertTrue(toggle_string)
-            self.assertTrue(toggle_int)
-            self.assertTrue(toggle_alias)

test/programs/test_common_client.py

@@ -1,106 +0,0 @@
-import unittest
-
-import NetUtils
-from CommonClient import CommonContext
-
-
-class TestCommonContext(unittest.IsolatedAsyncioTestCase):
-    async def asyncSetUp(self):
-        self.ctx = CommonContext()
-        self.ctx.slot = 1  # Pretend we're player 1 for this.
-        self.ctx.slot_info.update({
-            1: NetUtils.NetworkSlot("Player 1", "__TestGame1", NetUtils.SlotType.player),
-            2: NetUtils.NetworkSlot("Player 2", "__TestGame1", NetUtils.SlotType.player),
-            3: NetUtils.NetworkSlot("Player 3", "__TestGame2", NetUtils.SlotType.player),
-        })
-        self.ctx.consume_players_package([
-            NetUtils.NetworkPlayer(1, 1, "Player 1", "Player 1"),
-            NetUtils.NetworkPlayer(1, 2, "Player 2", "Player 2"),
-            NetUtils.NetworkPlayer(1, 3, "Player 3", "Player 3"),
-        ])
-        # Using IDs outside the "safe range" for testing purposes only. If this fails unit tests, it's because
-        # another world is not following the spec for allowed ID ranges.
-        self.ctx.update_data_package({
-            "games": {
-                "__TestGame1": {
-                    "location_name_to_id": {
-                        "Test Location 1 - Safe": 2**54 + 1,
-                        "Test Location 2 - Duplicate": 2**54 + 2,
-                    },
-                    "item_name_to_id": {
-                        "Test Item 1 - Safe": 2**54 + 1,
-                        "Test Item 2 - Duplicate": 2**54 + 2,
-                    },
-                },
-                "__TestGame2": {
-                    "location_name_to_id": {
-                        "Test Location 3 - Duplicate": 2**54 + 2,
-                    },
-                    "item_name_to_id": {
-                        "Test Item 3 - Duplicate": 2**54 + 2,
-                    },
-                },
-            },
-        })
-
-    async def test_archipelago_datapackage_lookups_exist(self):
-        assert "Archipelago" in self.ctx.item_names, "Archipelago item names entry does not exist"
-        assert "Archipelago" in self.ctx.location_names, "Archipelago location names entry does not exist"
-
-    async def test_implicit_name_lookups(self):
-        # Items
-        assert self.ctx.item_names[2**54 + 1] == "Test Item 1 - Safe"
-        assert self.ctx.item_names[2**54 + 3] == f"Unknown item (ID: {2**54+3})"
-        assert self.ctx.item_names[-1] == "Nothing"
-
-        # Locations
-        assert self.ctx.location_names[2**54 + 1] == "Test Location 1 - Safe"
-        assert self.ctx.location_names[2**54 + 3] == f"Unknown location (ID: {2**54+3})"
-        assert self.ctx.location_names[-1] == "Cheat Console"
-
-    async def test_explicit_name_lookups(self):
-        # Items
-        assert self.ctx.item_names["__TestGame1"][2**54+1] == "Test Item 1 - Safe"
-        assert self.ctx.item_names["__TestGame1"][2**54+2] == "Test Item 2 - Duplicate"
-        assert self.ctx.item_names["__TestGame1"][2**54+3] == f"Unknown item (ID: {2**54+3})"
-        assert self.ctx.item_names["__TestGame1"][-1] == "Nothing"
-        assert self.ctx.item_names["__TestGame2"][2**54+1] == f"Unknown item (ID: {2**54+1})"
-        assert self.ctx.item_names["__TestGame2"][2**54+2] == "Test Item 3 - Duplicate"
-        assert self.ctx.item_names["__TestGame2"][2**54+3] == f"Unknown item (ID: {2**54+3})"
-        assert self.ctx.item_names["__TestGame2"][-1] == "Nothing"
-
-        # Locations
-        assert self.ctx.location_names["__TestGame1"][2**54+1] == "Test Location 1 - Safe"
-        assert self.ctx.location_names["__TestGame1"][2**54+2] == "Test Location 2 - Duplicate"
-        assert self.ctx.location_names["__TestGame1"][2**54+3] == f"Unknown location (ID: {2**54+3})"
-        assert self.ctx.location_names["__TestGame1"][-1] == "Cheat Console"
-        assert self.ctx.location_names["__TestGame2"][2**54+1] == f"Unknown location (ID: {2**54+1})"
-        assert self.ctx.location_names["__TestGame2"][2**54+2] == "Test Location 3 - Duplicate"
-        assert self.ctx.location_names["__TestGame2"][2**54+3] == f"Unknown location (ID: {2**54+3})"
-        assert self.ctx.location_names["__TestGame2"][-1] == "Cheat Console"
-
-    async def test_lookup_helper_functions(self):
-        # Checking own slot.
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 1) == "Test Item 1 - Safe"
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 2) == "Test Item 2 - Duplicate"
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 3) == f"Unknown item (ID: {2 ** 54 + 3})"
-        assert self.ctx.item_names.lookup_in_slot(-1) == f"Nothing"
-
-        # Checking others' slots.
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 1, 2) == "Test Item 1 - Safe"
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 2, 2) == "Test Item 2 - Duplicate"
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 1, 3) == f"Unknown item (ID: {2 ** 54 + 1})"
-        assert self.ctx.item_names.lookup_in_slot(2 ** 54 + 2, 3) == "Test Item 3 - Duplicate"
-
-        # Checking by game.
-        assert self.ctx.item_names.lookup_in_game(2 ** 54 + 1, "__TestGame1") == "Test Item 1 - Safe"
-        assert self.ctx.item_names.lookup_in_game(2 ** 54 + 2, "__TestGame1") == "Test Item 2 - Duplicate"
-        assert self.ctx.item_names.lookup_in_game(2 ** 54 + 3, "__TestGame1") == f"Unknown item (ID: {2 ** 54 + 3})"
-        assert self.ctx.item_names.lookup_in_game(2 ** 54 + 1, "__TestGame2") == f"Unknown item (ID: {2 ** 54 + 1})"
-        assert self.ctx.item_names.lookup_in_game(2 ** 54 + 2, "__TestGame2") == "Test Item 3 - Duplicate"
-
-        # Checking with Archipelago ids are valid in any game package.
-        assert self.ctx.item_names.lookup_in_slot(-1, 2) == "Nothing"
-        assert self.ctx.item_names.lookup_in_slot(-1, 3) == "Nothing"
-        assert self.ctx.item_names.lookup_in_game(-1, "__TestGame1") == "Nothing"
-        assert self.ctx.item_names.lookup_in_game(-1, "__TestGame2") == "Nothing"

test/webhost/test_descriptions.py

@@ -1,23 +0,0 @@
-import unittest
-
-from worlds.AutoWorld import AutoWorldRegister
-
-
-class TestWebDescriptions(unittest.TestCase):
-    def test_item_descriptions_have_valid_names(self) -> None:
-        """Ensure all item descriptions match an item name or item group name"""
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            valid_names = world_type.item_names.union(world_type.item_name_groups)
-            for name in world_type.web.item_descriptions:
-                with self.subTest("Name should be valid", game=game_name, item=name):
-                    self.assertIn(name, valid_names,
-                                  "All item descriptions must match defined item names")
-
-    def test_location_descriptions_have_valid_names(self) -> None:
-        """Ensure all location descriptions match a location name or location group name"""
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            valid_names = world_type.location_names.union(world_type.location_name_groups)
-            for name in world_type.web.location_descriptions:
-                with self.subTest("Name should be valid", game=game_name, location=name):
-                    self.assertIn(name, valid_names,
-                                  "All location descriptions must match defined location names")

test/webhost/test_option_presets.py

@@ -1,7 +1,7 @@
 import unittest
 
 from worlds import AutoWorldRegister
-from Options import ItemDict, NamedRange, NumericOption, OptionList, OptionSet
+from Options import Choice, NamedRange, Toggle, Range
 
 
 class TestOptionPresets(unittest.TestCase):
@@ -14,7 +14,7 @@ class TestOptionPresets(unittest.TestCase):
                     with self.subTest(game=game_name, preset=preset_name, option=option_name):
                         try:
                             option = world_type.options_dataclass.type_hints[option_name].from_any(option_value)
-                            supported_types = [NumericOption, OptionSet, OptionList, ItemDict]
+                            supported_types = [Choice, Toggle, Range, NamedRange]
                             if not any([issubclass(option.__class__, t) for t in supported_types]):
                                 self.fail(f"'{option_name}' in preset '{preset_name}' for game '{game_name}' "
                                           f"is not a supported type for webhost. "

typings/kivy/core/window.pyi

@@ -1,15 +0,0 @@
-from typing import Callable, ClassVar
-
-from kivy.event import EventDispatcher
-
-
-class WindowBase(EventDispatcher):
-    width: ClassVar[int]  # readonly AliasProperty
-    height: ClassVar[int]  # readonly AliasProperty
-
-    @staticmethod
-    def bind(**kwargs: Callable[..., None]) -> None: ...
-
-
-class Window(WindowBase):
-    ...

typings/kivy/event.pyi

@@ -1,2 +0,0 @@
-class EventDispatcher:
-    ...

typings/kivy/uix/boxlayout.pyi

@@ -1,6 +0,0 @@
-from typing import Literal
-from .layout import Layout
-
-
-class BoxLayout(Layout):
-    orientation: Literal['horizontal', 'vertical']

typings/kivy/uix/layout.pyi

@@ -1,14 +1,8 @@
-from typing import Any, Sequence
-
+from typing import Any
 from .widget import Widget
 
 
 class Layout(Widget):
-    @property
-    def children(self) -> Sequence[Widget]: ...
-
     def add_widget(self, widget: Widget) -> None: ...
 
-    def remove_widget(self, widget: Widget) -> None: ...
-
     def do_layout(self, *largs: Any, **kwargs: Any) -> None: ...

typings/schema/__init__.pyi

@@ -1,17 +0,0 @@
-from typing import Any, Callable
-
-
-class And:
-    def __init__(self, __type: type, __func: Callable[[Any], bool]) -> None: ...
-
-
-class Or:
-    def __init__(self, *args: object) -> None: ...
-
-
-class Schema:
-    def __init__(self, __x: object) -> None: ...
-
-
-class Optional(Schema):
-    ...

worlds/AutoWorld.py

@@ -3,14 +3,18 @@ from __future__ import annotations
 import hashlib
 import logging
 import pathlib
+from random import Random
+import re
 import sys
 import time
-from random import Random
 from dataclasses import make_dataclass
-from typing import (Any, Callable, ClassVar, Dict, FrozenSet, List, Mapping, Optional, Set, TextIO, Tuple,
-                    TYPE_CHECKING, Type, Union)
+from typing import (Any, Callable, ClassVar, Dict, FrozenSet, List, Mapping,
+                    Optional, Set, TextIO, Tuple, TYPE_CHECKING, Type, Union)
 
-from Options import item_and_loc_options, OptionGroup, PerGameCommonOptions
+from Options import (
+    ExcludeLocations, ItemLinks, LocalItems, NonLocalItems, OptionGroup, PerGameCommonOptions,
+    PriorityLocations, StartHints, StartInventory, StartInventoryPool, StartLocationHints
+)
 from BaseClasses import CollectionState
 
 if TYPE_CHECKING:
@@ -51,12 +55,17 @@ class AutoWorldRegister(type):
         dct["item_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
                                    in dct.get("item_name_groups", {}).items()}
         dct["item_name_groups"]["Everything"] = dct["item_names"]
-
+        dct["item_descriptions"] = {name: _normalize_description(description) for name, description
+                                    in dct.get("item_descriptions", {}).items()}
+        dct["item_descriptions"]["Everything"] = "All items in the entire game."
         dct["location_names"] = frozenset(dct["location_name_to_id"])
         dct["location_name_groups"] = {group_name: frozenset(group_set) for group_name, group_set
                                        in dct.get("location_name_groups", {}).items()}
         dct["location_name_groups"]["Everywhere"] = dct["location_names"]
         dct["all_item_and_group_names"] = frozenset(dct["item_names"] | set(dct.get("item_name_groups", {})))
+        dct["location_descriptions"] = {name: _normalize_description(description) for name, description
+                                    in dct.get("location_descriptions", {}).items()}
+        dct["location_descriptions"]["Everywhere"] = "All locations in the entire game."
 
         # move away from get_required_client_version function
         if "game" in dct:
@@ -116,19 +125,13 @@ class WebWorldRegister(type):
         # don't allow an option to appear in multiple groups, allow "Item & Location Options" to appear anywhere by the
         # dev, putting it at the end if they don't define options in it
         option_groups: List[OptionGroup] = dct.get("option_groups", [])
-        prebuilt_options = ["Game Options", "Item & Location Options"]
+        item_and_loc_options = [LocalItems, NonLocalItems, StartInventory, StartInventoryPool, StartHints,
+                                StartLocationHints, ExcludeLocations, PriorityLocations, ItemLinks]
         seen_options = []
         item_group_in_list = False
         for group in option_groups:
-            assert group.options, "A custom defined Option Group must contain at least one Option."
-            # catch incorrectly titled versions of the prebuilt groups so they don't create extra groups
-            title_name = group.name.title()
-            if title_name in prebuilt_options:
-                group.name = title_name
-
+            assert group.name != "Game Options", "Game Options is a pre-determined group and can not be defined."
             if group.name == "Item & Location Options":
-                assert not any(option in item_and_loc_options for option in group.options), \
-                    f"Item and Location Options cannot be specified multiple times"
                 group.options.extend(item_and_loc_options)
                 item_group_in_list = True
             else:
@@ -140,7 +143,7 @@ class WebWorldRegister(type):
                 assert option not in seen_options, f"{option} found in two option groups"
                 seen_options.append(option)
         if not item_group_in_list:
-            option_groups.append(OptionGroup("Item & Location Options", item_and_loc_options, True))
+            option_groups.append(OptionGroup("Item & Location Options", item_and_loc_options))
         return super().__new__(mcs, name, bases, dct)
 
 
@@ -223,12 +226,6 @@ class WebWorld(metaclass=WebWorldRegister):
     option_groups: ClassVar[List[OptionGroup]] = []
     """Ordered list of option groupings. Any options not set in a group will be placed in a pre-built "Game Options"."""
 
-    location_descriptions: Dict[str, str] = {}
-    """An optional map from location names (or location group names) to brief descriptions for users."""
-
-    item_descriptions: Dict[str, str] = {}
-    """An optional map from item names (or item group names) to brief descriptions for users."""
-
 
 class World(metaclass=AutoWorldRegister):
     """A World object encompasses a game's Items, Locations, Rules and additional data or functionality required.
@@ -255,9 +252,35 @@ class World(metaclass=AutoWorldRegister):
     item_name_groups: ClassVar[Dict[str, Set[str]]] = {}
     """maps item group names to sets of items. Example: {"Weapons": {"Sword", "Bow"}}"""
 
+    item_descriptions: ClassVar[Dict[str, str]] = {}
+    """An optional map from item names (or item group names) to brief descriptions for users.
+
+    Individual newlines and indentation will be collapsed into spaces before these descriptions are
+    displayed. This may cover only a subset of items.
+    """
+
     location_name_groups: ClassVar[Dict[str, Set[str]]] = {}
     """maps location group names to sets of locations. Example: {"Sewer": {"Sewer Key Drop 1", "Sewer Key Drop 2"}}"""
 
+    location_descriptions: ClassVar[Dict[str, str]] = {}
+    """An optional map from location names (or location group names) to brief descriptions for users.
+
+    Individual newlines and indentation will be collapsed into spaces before these descriptions are
+    displayed. This may cover only a subset of locations.
+    """
+
+    data_version: ClassVar[int] = 0
+    """
+    Increment this every time something in your world's names/id mappings changes.
+
+    When this is set to 0, that world's DataPackage is considered in "testing mode", which signals to servers/clients
+    that it should not be cached, and clients should request that world's DataPackage every connection. Not
+    recommended for production-ready worlds.
+
+    Deprecated. Clients should utilize `checksum` to determine if DataPackage has changed since last connection and
+    request a new DataPackage, if necessary.
+    """
+
     required_client_version: Tuple[int, int, int] = (0, 1, 6)
     """
     override this if changes to a world break forward-compatibility of the client
@@ -531,6 +554,7 @@ class World(metaclass=AutoWorldRegister):
             "item_name_to_id": cls.item_name_to_id,
             "location_name_groups": sorted_location_name_groups,
             "location_name_to_id": cls.location_name_to_id,
+            "version": cls.data_version,
         }
         res["checksum"] = data_package_checksum(res)
         return res
@@ -548,3 +572,18 @@ def data_package_checksum(data: "GamesPackage") -> str:
     assert sorted(data) == list(data), "Data not ordered"
     from NetUtils import encode
     return hashlib.sha1(encode(data).encode()).hexdigest()
+
+
+def _normalize_description(description):
+    """
+    Normalizes a description in item_descriptions or location_descriptions.
+
+    This allows authors to write descritions with nice indentation and line lengths in their world
+    definitions without having it affect the rendered format.
+    """
+    # First, collapse the whitespace around newlines and the ends of the description.
+    description = re.sub(r' *\n *', '\n', description.strip())
+    # Next, condense individual newlines into spaces.
+    description = re.sub(r'(?<!\n)\n(?!\n)', ' ', description)
+    return description
+

worlds/LauncherComponents.py

@@ -1,11 +1,8 @@
-import bisect
-import logging
-import pathlib
 import weakref
 from enum import Enum, auto
-from typing import Optional, Callable, List, Iterable, Tuple
+from typing import Optional, Callable, List, Iterable
 
-from Utils import local_path, open_filename
+from Utils import local_path
 
 
 class Type(Enum):
@@ -52,10 +49,8 @@ class Component:
     def __repr__(self):
         return f"{self.__class__.__name__}({self.display_name})"
 
-
 processes = weakref.WeakSet()
 
-
 def launch_subprocess(func: Callable, name: str = None):
     global processes
     import multiprocessing
@@ -63,7 +58,6 @@ def launch_subprocess(func: Callable, name: str = None):
     process.start()
     processes.add(process)
 
-
 class SuffixIdentifier:
     suffixes: Iterable[str]
 
@@ -83,80 +77,6 @@ def launch_textclient():
     launch_subprocess(CommonClient.run_as_textclient, name="TextClient")
 
 
-def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, pathlib.Path]]:
-    if not apworld_src:
-        apworld_src = open_filename('Select APWorld file to install', (('APWorld', ('.apworld',)),))
-        if not apworld_src:
-            # user closed menu
-            return
-
-    if not apworld_src.endswith(".apworld"):
-        raise Exception(f"Wrong file format, looking for .apworld. File identified: {apworld_src}")
-
-    apworld_path = pathlib.Path(apworld_src)
-
-    module_name = pathlib.Path(apworld_path.name).stem
-    try:
-        import zipfile
-        zipfile.ZipFile(apworld_path).open(module_name + "/__init__.py")
-    except ValueError as e:
-        raise Exception("Archive appears invalid or damaged.") from e
-    except KeyError as e:
-        raise Exception("Archive appears to not be an apworld. (missing __init__.py)") from e
-
-    import worlds
-    if worlds.user_folder is None:
-        raise Exception("Custom Worlds directory appears to not be writable.")
-    for world_source in worlds.world_sources:
-        if apworld_path.samefile(world_source.resolved_path):
-            # Note that this doesn't check if the same world is already installed.
-            # It only checks if the user is trying to install the apworld file
-            # that comes from the installation location (worlds or custom_worlds)
-            raise Exception(f"APWorld is already installed at {world_source.resolved_path}.")
-
-    # TODO: run generic test suite over the apworld.
-    # TODO: have some kind of version system to tell from metadata if the apworld should be compatible.
-
-    target = pathlib.Path(worlds.user_folder) / apworld_path.name
-    import shutil
-    shutil.copyfile(apworld_path, target)
-
-    # If a module with this name is already loaded, then we can't load it now.
-    # TODO: We need to be able to unload a world module,
-    # so the user can update a world without restarting the application.
-    found_already_loaded = False
-    for loaded_world in worlds.world_sources:
-        loaded_name = pathlib.Path(loaded_world.path).stem
-        if module_name == loaded_name:
-            found_already_loaded = True
-            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.")
-    world_source = worlds.WorldSource(str(target), is_zip=True)
-    bisect.insort(worlds.world_sources, world_source)
-    world_source.load()
-
-    return apworld_path, target
-
-
-def install_apworld(apworld_path: str = "") -> None:
-    try:
-        res = _install_apworld(apworld_path)
-        if res is None:
-            logging.info("Aborting APWorld installation.")
-            return
-        source, target = res
-    except Exception as e:
-        import Utils
-        Utils.messagebox(e.__class__.__name__, str(e), error=True)
-        logging.exception(e)
-    else:
-        import Utils
-        logging.info(f"Installed APWorld successfully, copied {source} to {target}.")
-        Utils.messagebox("Install complete.", f"Installed APWorld from {source}.")
-
-
 components: List[Component] = [
     # Launcher
     Component('Launcher', 'Launcher', component_type=Type.HIDDEN),
@@ -164,7 +84,6 @@ components: List[Component] = [
     Component('Host', 'MultiServer', 'ArchipelagoServer', cli=True,
               file_identifier=SuffixIdentifier('.archipelago', '.zip')),
     Component('Generate', 'Generate', cli=True),
-    Component("Install APWorld", func=install_apworld, file_identifier=SuffixIdentifier(".apworld")),
     Component('Text Client', 'CommonClient', 'ArchipelagoTextClient', func=launch_textclient),
     Component('Links Awakening DX Client', 'LinksAwakeningClient',
               file_identifier=SuffixIdentifier('.apladx')),

worlds/__init__.py

@@ -1,21 +1,16 @@
 import importlib
-import logging
 import os
 import sys
 import warnings
 import zipimport
 import time
 import dataclasses
-from typing import Dict, List, TypedDict
+from typing import Dict, List, TypedDict, Optional
 
 from Utils import local_path, user_path
 
 local_folder = os.path.dirname(__file__)
-user_folder = user_path("worlds") if user_path() != local_path() else user_path("custom_worlds")
-try:
-    os.makedirs(user_folder, exist_ok=True)
-except OSError:  # can't access/write?
-    user_folder = None
+user_folder = user_path("worlds") if user_path() != local_path() else None
 
 __all__ = {
     "network_data_package",
@@ -38,6 +33,7 @@ class GamesPackage(TypedDict, total=False):
     location_name_groups: Dict[str, List[str]]
     location_name_to_id: Dict[str, int]
     checksum: str
+    version: int  # TODO: Remove support after per game data packages API change.
 
 
 class DataPackage(TypedDict):
@@ -49,7 +45,7 @@ class WorldSource:
     path: str  # typically relative path from this module
     is_zip: bool = False
     relative: bool = True  # relative to regular world import folder
-    time_taken: float = -1.0
+    time_taken: Optional[float] = None
 
     def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.path}, is_zip={self.is_zip}, relative={self.relative})"
@@ -93,6 +89,7 @@ class WorldSource:
             print(f"Could not load world {self}:", file=file_like)
             traceback.print_exc(file=file_like)
             file_like.seek(0)
+            import logging
             logging.exception(file_like.read())
             failed_world_loads.append(os.path.basename(self.path).rsplit(".", 1)[0])
             return False
@@ -107,11 +104,7 @@ for folder in (folder for folder in (user_folder, local_folder) if folder):
         if not entry.name.startswith(("_", ".")):
             file_name = entry.name if relative else os.path.join(folder, entry.name)
             if entry.is_dir():
-                init_file_path = os.path.join(entry.path, '__init__.py')
-                if os.path.isfile(init_file_path):
-                    world_sources.append(WorldSource(file_name, relative=relative))
-                else:
-                    logging.warning(f"excluding {entry.name} from world sources because it has no __init__.py")
+                world_sources.append(WorldSource(file_name, relative=relative))
             elif entry.is_file() and entry.name.endswith(".apworld"):
                 world_sources.append(WorldSource(file_name, is_zip=True, relative=relative))
 

worlds/_bizhawk/__init__.py

@@ -103,7 +103,7 @@ async def connect(ctx: BizHawkContext) -> bool:
             return True
         except (TimeoutError, ConnectionRefusedError):
             continue
-
+    
     # No ports worked
     ctx.streams = None
     ctx.connection_status = ConnectionStatus.NOT_CONNECTED

worlds/_bizhawk/client.py

@@ -2,6 +2,7 @@
 A module containing the BizHawkClient base class and metaclass
 """
 
+
 from __future__ import annotations
 
 import abc
@@ -11,13 +12,14 @@ from worlds.LauncherComponents import Component, SuffixIdentifier, Type, compone
 
 if TYPE_CHECKING:
     from .context import BizHawkClientContext
+else:
+    BizHawkClientContext = object
 
 
 def launch_client(*args) -> None:
     from .context import launch
     launch_subprocess(launch, name="BizHawkClient")
 
-
 component = Component("BizHawk Client", "BizHawkClient", component_type=Type.CLIENT, func=launch_client,
                       file_identifier=SuffixIdentifier())
 components.append(component)
@@ -54,7 +56,7 @@ class AutoBizHawkClientRegister(abc.ABCMeta):
         return new_class
 
     @staticmethod
-    async def get_handler(ctx: "BizHawkClientContext", system: str) -> Optional[BizHawkClient]:
+    async def get_handler(ctx: BizHawkClientContext, system: str) -> Optional[BizHawkClient]:
         for systems, handlers in AutoBizHawkClientRegister.game_handlers.items():
             if system in systems:
                 for handler in handlers.values():
@@ -75,7 +77,7 @@ class BizHawkClient(abc.ABC, metaclass=AutoBizHawkClientRegister):
     """The file extension(s) this client is meant to open and patch (e.g. ".apz3")"""
 
     @abc.abstractmethod
-    async def validate_rom(self, ctx: "BizHawkClientContext") -> bool:
+    async def validate_rom(self, ctx: BizHawkClientContext) -> bool:
         """Should return whether the currently loaded ROM should be handled by this client. You might read the game name
         from the ROM header, for example. This function will only be asked to validate ROMs from the system set by the
         client class, so you do not need to check the system yourself.
@@ -84,18 +86,18 @@ class BizHawkClient(abc.ABC, metaclass=AutoBizHawkClientRegister):
         as necessary (such as setting `ctx.game = self.game`, modifying `ctx.items_handling`, etc...)."""
         ...
 
-    async def set_auth(self, ctx: "BizHawkClientContext") -> None:
+    async def set_auth(self, ctx: BizHawkClientContext) -> None:
         """Should set ctx.auth in anticipation of sending a `Connected` packet. You may override this if you store slot
         name in your patched ROM. If ctx.auth is not set after calling, the player will be prompted to enter their
         username."""
         pass
 
     @abc.abstractmethod
-    async def game_watcher(self, ctx: "BizHawkClientContext") -> None:
+    async def game_watcher(self, ctx: BizHawkClientContext) -> None:
         """Runs on a loop with the approximate interval `ctx.watcher_timeout`. The currently loaded ROM is guaranteed
         to have passed your validator when this function is called, and the emulator is very likely to be connected."""
         ...
 
-    def on_package(self, ctx: "BizHawkClientContext", cmd: str, args: dict) -> None:
+    def on_package(self, ctx: BizHawkClientContext, cmd: str, args: dict) -> None:
         """For handling packages from the server. Called from `BizHawkClientContext.on_package`."""
         pass

worlds/_bizhawk/context.py

@@ -3,6 +3,7 @@ A module containing context and functions relevant to running the client. This m
 checking or launching the client, otherwise it will probably cause circular import issues.
 """
 
+
 import asyncio
 import enum
 import subprocess
@@ -76,7 +77,7 @@ class BizHawkClientContext(CommonContext):
         if self.client_handler is not None:
             self.client_handler.on_package(self, cmd, args)
 
-    async def server_auth(self, password_requested: bool=False):
+    async def server_auth(self, password_requested: bool = False):
         self.password_requested = password_requested
 
         if self.bizhawk_ctx.connection_status != ConnectionStatus.CONNECTED:
@@ -102,7 +103,7 @@ class BizHawkClientContext(CommonContext):
         await self.send_connect()
         self.auth_status = AuthStatus.PENDING
 
-    async def disconnect(self, allow_autoreconnect: bool=False):
+    async def disconnect(self, allow_autoreconnect: bool = False):
         self.auth_status = AuthStatus.NOT_AUTHENTICATED
         await super().disconnect(allow_autoreconnect)
 
@@ -147,8 +148,7 @@ async def _game_watcher(ctx: BizHawkClientContext):
                 script_version = await get_script_version(ctx.bizhawk_ctx)
 
                 if script_version != EXPECTED_SCRIPT_VERSION:
-                    logger.info(f"Connector script is incompatible. Expected version {EXPECTED_SCRIPT_VERSION} but "
-                                f"got {script_version}. Disconnecting.")
+                    logger.info(f"Connector script is incompatible. Expected version {EXPECTED_SCRIPT_VERSION} but got {script_version}. Disconnecting.")
                     disconnect(ctx.bizhawk_ctx)
                     continue
 
@@ -168,7 +168,6 @@ async def _game_watcher(ctx: BizHawkClientContext):
                 ctx.auth = None
                 ctx.username = None
                 ctx.client_handler = None
-                ctx.finished_game = False
                 await ctx.disconnect(False)
             ctx.rom_hash = rom_hash
 
@@ -178,8 +177,7 @@ async def _game_watcher(ctx: BizHawkClientContext):
 
                 if ctx.client_handler is None:
                     if not showed_no_handler_message:
-                        logger.info("No handler was found for this game. Double-check that the apworld is installed "
-                                    "correctly and that you loaded the right ROM file.")
+                        logger.info("No handler was found for this game")
                         showed_no_handler_message = True
                     continue
                 else:

worlds/adventure/__init__.py

@@ -113,6 +113,7 @@ class AdventureWorld(World):
     settings: ClassVar[AdventureSettings]
     item_name_to_id: ClassVar[Dict[str, int]] = {name: data.id for name, data in item_table.items()}
     location_name_to_id: ClassVar[Dict[str, int]] = {name: data.location_id for name, data in location_table.items()}
+    data_version: ClassVar[int] = 1
     required_client_version: Tuple[int, int, int] = (0, 3, 9)
 
     def __init__(self, world: MultiWorld, player: int):

worlds/ahit/Client.py

@@ -1,232 +0,0 @@
-import asyncio
-import Utils
-import websockets
-import functools
-from copy import deepcopy
-from typing import List, Any, Iterable
-from NetUtils import decode, encode, JSONtoTextParser, JSONMessagePart, NetworkItem
-from MultiServer import Endpoint
-from CommonClient import CommonContext, gui_enabled, ClientCommandProcessor, logger, get_base_parser
-
-DEBUG = False
-
-
-class AHITJSONToTextParser(JSONtoTextParser):
-    def _handle_color(self, node: JSONMessagePart):
-        return self._handle_text(node)  # No colors for the in-game text
-
-
-class AHITCommandProcessor(ClientCommandProcessor):
-    def _cmd_ahit(self):
-        """Check AHIT Connection State"""
-        if isinstance(self.ctx, AHITContext):
-            logger.info(f"AHIT Status: {self.ctx.get_ahit_status()}")
-
-
-class AHITContext(CommonContext):
-    command_processor = AHITCommandProcessor
-    game = "A Hat in Time"
-
-    def __init__(self, server_address, password):
-        super().__init__(server_address, password)
-        self.proxy = None
-        self.proxy_task = None
-        self.gamejsontotext = AHITJSONToTextParser(self)
-        self.autoreconnect_task = None
-        self.endpoint = None
-        self.items_handling = 0b111
-        self.room_info = None
-        self.connected_msg = None
-        self.game_connected = False
-        self.awaiting_info = False
-        self.full_inventory: List[Any] = []
-        self.server_msgs: List[Any] = []
-
-    async def server_auth(self, password_requested: bool = False):
-        if password_requested and not self.password:
-            await super(AHITContext, self).server_auth(password_requested)
-
-        await self.get_username()
-        await self.send_connect()
-
-    def get_ahit_status(self) -> str:
-        if not self.is_proxy_connected():
-            return "Not connected to A Hat in Time"
-
-        return "Connected to A Hat in Time"
-
-    async def send_msgs_proxy(self, msgs: Iterable[dict]) -> bool:
-        """ `msgs` JSON serializable """
-        if not self.endpoint or not self.endpoint.socket.open or self.endpoint.socket.closed:
-            return False
-
-        if DEBUG:
-            logger.info(f"Outgoing message: {msgs}")
-
-        await self.endpoint.socket.send(msgs)
-        return True
-
-    async def disconnect(self, allow_autoreconnect: bool = False):
-        await super().disconnect(allow_autoreconnect)
-
-    async def disconnect_proxy(self):
-        if self.endpoint and not self.endpoint.socket.closed:
-            await self.endpoint.socket.close()
-        if self.proxy_task is not None:
-            await self.proxy_task
-
-    def is_connected(self) -> bool:
-        return self.server and self.server.socket.open
-
-    def is_proxy_connected(self) -> bool:
-        return self.endpoint and self.endpoint.socket.open
-
-    def on_print_json(self, args: dict):
-        text = self.gamejsontotext(deepcopy(args["data"]))
-        msg = {"cmd": "PrintJSON", "data": [{"text": text}], "type": "Chat"}
-        self.server_msgs.append(encode([msg]))
-
-        if self.ui:
-            self.ui.print_json(args["data"])
-        else:
-            text = self.jsontotextparser(args["data"])
-            logger.info(text)
-
-    def update_items(self):
-        # just to be safe - we might still have an inventory from a different room
-        if not self.is_connected():
-            return
-
-        self.server_msgs.append(encode([{"cmd": "ReceivedItems", "index": 0, "items": self.full_inventory}]))
-
-    def on_package(self, cmd: str, args: dict):
-        if cmd == "Connected":
-            self.connected_msg = encode([args])
-            if self.awaiting_info:
-                self.server_msgs.append(self.room_info)
-                self.update_items()
-                self.awaiting_info = False
-
-        elif cmd == "ReceivedItems":
-            if args["index"] == 0:
-                self.full_inventory.clear()
-
-            for item in args["items"]:
-                self.full_inventory.append(NetworkItem(*item))
-
-            self.server_msgs.append(encode([args]))
-
-        elif cmd == "RoomInfo":
-            self.seed_name = args["seed_name"]
-            self.room_info = encode([args])
-
-        else:
-            if cmd != "PrintJSON":
-                self.server_msgs.append(encode([args]))
-
-    def run_gui(self):
-        from kvui import GameManager
-
-        class AHITManager(GameManager):
-            logging_pairs = [
-                ("Client", "Archipelago")
-            ]
-            base_title = "Archipelago A Hat in Time Client"
-
-        self.ui = AHITManager(self)
-        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
-
-
-async def proxy(websocket, path: str = "/", ctx: AHITContext = None):
-    ctx.endpoint = Endpoint(websocket)
-    try:
-        await on_client_connected(ctx)
-
-        if ctx.is_proxy_connected():
-            async for data in websocket:
-                if DEBUG:
-                    logger.info(f"Incoming message: {data}")
-
-                for msg in decode(data):
-                    if msg["cmd"] == "Connect":
-                        # Proxy is connecting, make sure it is valid
-                        if msg["game"] != "A Hat in Time":
-                            logger.info("Aborting proxy connection: game is not A Hat in Time")
-                            await ctx.disconnect_proxy()
-                            break
-
-                        if ctx.seed_name:
-                            seed_name = msg.get("seed_name", "")
-                            if seed_name != "" and seed_name != ctx.seed_name:
-                                logger.info("Aborting proxy connection: seed mismatch from save file")
-                                logger.info(f"Expected: {ctx.seed_name}, got: {seed_name}")
-                                text = encode([{"cmd": "PrintJSON",
-                                                "data": [{"text": "Connection aborted - save file to seed mismatch"}]}])
-                                await ctx.send_msgs_proxy(text)
-                                await ctx.disconnect_proxy()
-                                break
-
-                        if ctx.connected_msg and ctx.is_connected():
-                            await ctx.send_msgs_proxy(ctx.connected_msg)
-                            ctx.update_items()
-                        continue
-
-                    if not ctx.is_proxy_connected():
-                        break
-
-                    await ctx.send_msgs([msg])
-
-    except Exception as e:
-        if not isinstance(e, websockets.WebSocketException):
-            logger.exception(e)
-    finally:
-        await ctx.disconnect_proxy()
-
-
-async def on_client_connected(ctx: AHITContext):
-    if ctx.room_info and ctx.is_connected():
-        await ctx.send_msgs_proxy(ctx.room_info)
-    else:
-        ctx.awaiting_info = True
-
-
-async def proxy_loop(ctx: AHITContext):
-    try:
-        while not ctx.exit_event.is_set():
-            if len(ctx.server_msgs) > 0:
-                for msg in ctx.server_msgs:
-                    await ctx.send_msgs_proxy(msg)
-
-                ctx.server_msgs.clear()
-            await asyncio.sleep(0.1)
-    except Exception as e:
-        logger.exception(e)
-        logger.info("Aborting AHIT Proxy Client due to errors")
-
-
-def launch():
-    async def main():
-        parser = get_base_parser()
-        args = parser.parse_args()
-
-        ctx = AHITContext(args.connect, args.password)
-        logger.info("Starting A Hat in Time proxy server")
-        ctx.proxy = websockets.serve(functools.partial(proxy, ctx=ctx),
-                                     host="localhost", port=11311, ping_timeout=999999, ping_interval=999999)
-        ctx.proxy_task = asyncio.create_task(proxy_loop(ctx), name="ProxyLoop")
-
-        if gui_enabled:
-            ctx.run_gui()
-        ctx.run_cli()
-
-        await ctx.proxy
-        await ctx.proxy_task
-        await ctx.exit_event.wait()
-
-    Utils.init_logging("AHITClient")
-    # options = Utils.get_options()
-
-    import colorama
-    colorama.init()
-    asyncio.run(main())
-    colorama.deinit()

worlds/ahit/DeathWishLocations.py

@@ -1,243 +0,0 @@
-from .Types import HatInTimeLocation, HatInTimeItem
-from .Regions import create_region
-from BaseClasses import Region, LocationProgressType, ItemClassification
-from worlds.generic.Rules import add_rule
-from typing import List, TYPE_CHECKING
-from .Locations import death_wishes
-from .Options import EndGoal
-
-if TYPE_CHECKING:
-    from . import HatInTimeWorld
-
-
-dw_prereqs = {
-    "So You're Back From Outer Space":  ["Beat the Heat"],
-    "Snatcher's Hit List":              ["Beat the Heat"],
-    "Snatcher Coins in Mafia Town":     ["So You're Back From Outer Space"],
-    "Rift Collapse: Mafia of Cooks":    ["So You're Back From Outer Space"],
-    "Collect-a-thon":                   ["So You're Back From Outer Space"],
-    "She Speedran from Outer Space":    ["Rift Collapse: Mafia of Cooks"],
-    "Mafia's Jumps":                    ["She Speedran from Outer Space"],
-    "Vault Codes in the Wind":          ["Collect-a-thon", "She Speedran from Outer Space"],
-    "Encore! Encore!":                  ["Collect-a-thon"],
-
-    "Security Breach":                          ["Beat the Heat"],
-    "Rift Collapse: Dead Bird Studio":          ["Security Breach"],
-    "The Great Big Hootenanny":                 ["Security Breach"],
-    "10 Seconds until Self-Destruct":           ["The Great Big Hootenanny"],
-    "Killing Two Birds":                        ["Rift Collapse: Dead Bird Studio", "10 Seconds until Self-Destruct"],
-    "Community Rift: Rhythm Jump Studio":       ["10 Seconds until Self-Destruct"],
-    "Snatcher Coins in Battle of the Birds":    ["The Great Big Hootenanny"],
-    "Zero Jumps":                               ["Rift Collapse: Dead Bird Studio"],
-    "Snatcher Coins in Nyakuza Metro":          ["Killing Two Birds"],
-
-    "Speedrun Well":                    ["Beat the Heat"],
-    "Rift Collapse: Sleepy Subcon":     ["Speedrun Well"],
-    "Boss Rush":                        ["Speedrun Well"],
-    "Quality Time with Snatcher":       ["Rift Collapse: Sleepy Subcon"],
-    "Breaching the Contract":           ["Boss Rush", "Quality Time with Snatcher"],
-    "Community Rift: Twilight Travels": ["Quality Time with Snatcher"],
-    "Snatcher Coins in Subcon Forest":  ["Rift Collapse: Sleepy Subcon"],
-
-    "Bird Sanctuary":                       ["Beat the Heat"],
-    "Snatcher Coins in Alpine Skyline":     ["Bird Sanctuary"],
-    "Wound-Up Windmill":                    ["Bird Sanctuary"],
-    "Rift Collapse: Alpine Skyline":        ["Bird Sanctuary"],
-    "Camera Tourist":                       ["Rift Collapse: Alpine Skyline"],
-    "Community Rift: The Mountain Rift":    ["Rift Collapse: Alpine Skyline"],
-    "The Illness has Speedrun":             ["Rift Collapse: Alpine Skyline", "Wound-Up Windmill"],
-
-    "The Mustache Gauntlet":            ["Wound-Up Windmill"],
-    "No More Bad Guys":                 ["The Mustache Gauntlet"],
-    "Seal the Deal":                    ["Encore! Encore!", "Killing Two Birds",
-                                         "Breaching the Contract", "No More Bad Guys"],
-
-    "Rift Collapse: Deep Sea":          ["Rift Collapse: Mafia of Cooks", "Rift Collapse: Dead Bird Studio",
-                                         "Rift Collapse: Sleepy Subcon", "Rift Collapse: Alpine Skyline"],
-
-    "Cruisin' for a Bruisin'":          ["Rift Collapse: Deep Sea"],
-}
-
-dw_candles = [
-    "Snatcher's Hit List",
-    "Zero Jumps",
-    "Camera Tourist",
-    "Snatcher Coins in Mafia Town",
-    "Snatcher Coins in Battle of the Birds",
-    "Snatcher Coins in Subcon Forest",
-    "Snatcher Coins in Alpine Skyline",
-    "Snatcher Coins in Nyakuza Metro",
-]
-
-annoying_dws = [
-    "Vault Codes in the Wind",
-    "Boss Rush",
-    "Camera Tourist",
-    "The Mustache Gauntlet",
-    "Rift Collapse: Deep Sea",
-    "Cruisin' for a Bruisin'",
-    "Seal the Deal",  # Non-excluded if goal
-]
-
-# includes the above as well
-annoying_bonuses = [
-    "So You're Back From Outer Space",
-    "Encore! Encore!",
-    "Snatcher's Hit List",
-    "Vault Codes in the Wind",
-    "10 Seconds until Self-Destruct",
-    "Killing Two Birds",
-    "Zero Jumps",
-    "Boss Rush",
-    "Bird Sanctuary",
-    "The Mustache Gauntlet",
-    "Wound-Up Windmill",
-    "Camera Tourist",
-    "Rift Collapse: Deep Sea",
-    "Cruisin' for a Bruisin'",
-    "Seal the Deal",
-]
-
-dw_classes = {
-    "Beat the Heat":                    "Hat_SnatcherContract_DeathWish_HeatingUpHarder",
-    "So You're Back From Outer Space":  "Hat_SnatcherContract_DeathWish_BackFromSpace",
-    "Snatcher's Hit List":              "Hat_SnatcherContract_DeathWish_KillEverybody",
-    "Collect-a-thon":                   "Hat_SnatcherContract_DeathWish_PonFrenzy",
-    "Rift Collapse: Mafia of Cooks":    "Hat_SnatcherContract_DeathWish_RiftCollapse_MafiaTown",
-    "Encore! Encore!":                  "Hat_SnatcherContract_DeathWish_MafiaBossEX",
-    "She Speedran from Outer Space":    "Hat_SnatcherContract_DeathWish_Speedrun_MafiaAlien",
-    "Mafia's Jumps":                    "Hat_SnatcherContract_DeathWish_NoAPresses_MafiaAlien",
-    "Vault Codes in the Wind":          "Hat_SnatcherContract_DeathWish_MovingVault",
-    "Snatcher Coins in Mafia Town":     "Hat_SnatcherContract_DeathWish_Tokens_MafiaTown",
-
-    "Security Breach":                          "Hat_SnatcherContract_DeathWish_DeadBirdStudioMoreGuards",
-    "The Great Big Hootenanny":                 "Hat_SnatcherContract_DeathWish_DifficultParade",
-    "Rift Collapse: Dead Bird Studio":          "Hat_SnatcherContract_DeathWish_RiftCollapse_Birds",
-    "10 Seconds until Self-Destruct":           "Hat_SnatcherContract_DeathWish_TrainRushShortTime",
-    "Killing Two Birds":                        "Hat_SnatcherContract_DeathWish_BirdBossEX",
-    "Snatcher Coins in Battle of the Birds":    "Hat_SnatcherContract_DeathWish_Tokens_Birds",
-    "Zero Jumps":                               "Hat_SnatcherContract_DeathWish_NoAPresses",
-
-    "Speedrun Well":                    "Hat_SnatcherContract_DeathWish_Speedrun_SubWell",
-    "Rift Collapse: Sleepy Subcon":     "Hat_SnatcherContract_DeathWish_RiftCollapse_Subcon",
-    "Boss Rush":                        "Hat_SnatcherContract_DeathWish_BossRush",
-    "Quality Time with Snatcher":       "Hat_SnatcherContract_DeathWish_SurvivalOfTheFittest",
-    "Breaching the Contract":           "Hat_SnatcherContract_DeathWish_SnatcherEX",
-    "Snatcher Coins in Subcon Forest":  "Hat_SnatcherContract_DeathWish_Tokens_Subcon",
-
-    "Bird Sanctuary":                   "Hat_SnatcherContract_DeathWish_NiceBirdhouse",
-    "Rift Collapse: Alpine Skyline":    "Hat_SnatcherContract_DeathWish_RiftCollapse_Alps",
-    "Wound-Up Windmill":                "Hat_SnatcherContract_DeathWish_FastWindmill",
-    "The Illness has Speedrun":         "Hat_SnatcherContract_DeathWish_Speedrun_Illness",
-    "Snatcher Coins in Alpine Skyline": "Hat_SnatcherContract_DeathWish_Tokens_Alps",
-    "Camera Tourist":                   "Hat_SnatcherContract_DeathWish_CameraTourist_1",
-
-    "The Mustache Gauntlet":            "Hat_SnatcherContract_DeathWish_HardCastle",
-    "No More Bad Guys":                 "Hat_SnatcherContract_DeathWish_MuGirlEX",
-
-    "Seal the Deal":                    "Hat_SnatcherContract_DeathWish_BossRushEX",
-    "Rift Collapse: Deep Sea":          "Hat_SnatcherContract_DeathWish_RiftCollapse_Cruise",
-    "Cruisin' for a Bruisin'":          "Hat_SnatcherContract_DeathWish_EndlessTasks",
-
-    "Community Rift: Rhythm Jump Studio":   "Hat_SnatcherContract_DeathWish_CommunityRift_RhythmJump",
-    "Community Rift: Twilight Travels":     "Hat_SnatcherContract_DeathWish_CommunityRift_TwilightTravels",
-    "Community Rift: The Mountain Rift":    "Hat_SnatcherContract_DeathWish_CommunityRift_MountainRift",
-
-    "Snatcher Coins in Nyakuza Metro":      "Hat_SnatcherContract_DeathWish_Tokens_Metro",
-}
-
-
-def create_dw_regions(world: "HatInTimeWorld"):
-    if world.options.DWExcludeAnnoyingContracts:
-        for name in annoying_dws:
-            world.excluded_dws.append(name)
-
-    if not world.options.DWEnableBonus or world.options.DWAutoCompleteBonuses:
-        for name in death_wishes:
-            world.excluded_bonuses.append(name)
-    elif world.options.DWExcludeAnnoyingBonuses:
-        for name in annoying_bonuses:
-            world.excluded_bonuses.append(name)
-
-    if world.options.DWExcludeCandles:
-        for name in dw_candles:
-            if name not in world.excluded_dws:
-                world.excluded_dws.append(name)
-
-    spaceship = world.multiworld.get_region("Spaceship", world.player)
-    dw_map: Region = create_region(world, "Death Wish Map")
-    entrance = spaceship.connect(dw_map, "-> Death Wish Map")
-    add_rule(entrance, lambda state: state.has("Time Piece", world.player, world.options.DWTimePieceRequirement))
-
-    if world.options.DWShuffle:
-        # Connect Death Wishes randomly to one another in a linear sequence
-        dw_list: List[str] = []
-        for name in death_wishes.keys():
-            # Don't shuffle excluded or invalid Death Wishes
-            if not world.is_dlc2() and name == "Snatcher Coins in Nyakuza Metro" or world.is_dw_excluded(name):
-                continue
-
-            dw_list.append(name)
-
-        world.random.shuffle(dw_list)
-        count = world.random.randint(world.options.DWShuffleCountMin.value, world.options.DWShuffleCountMax.value)
-        dw_shuffle: List[str] = []
-        total = min(len(dw_list), count)
-        for i in range(total):
-            dw_shuffle.append(dw_list[i])
-
-        # Seal the Deal is always last if it's the goal
-        if world.options.EndGoal == EndGoal.option_seal_the_deal:
-            if "Seal the Deal" in dw_shuffle:
-                dw_shuffle.remove("Seal the Deal")
-
-            dw_shuffle.append("Seal the Deal")
-
-        world.dw_shuffle = dw_shuffle
-        prev_dw = dw_map
-        for death_wish_name in dw_shuffle:
-            dw = create_region(world, death_wish_name)
-            prev_dw.connect(dw)
-            create_dw_locations(world, dw)
-            prev_dw = dw
-    else:
-        # DWShuffle is disabled, use vanilla connections
-        for key in death_wishes.keys():
-            if key == "Snatcher Coins in Nyakuza Metro" and not world.is_dlc2():
-                world.excluded_dws.append(key)
-                continue
-
-            dw = create_region(world, key)
-            if key == "Beat the Heat":
-                dw_map.connect(dw, f"{dw_map.name} -> Beat the Heat")
-            elif key in dw_prereqs.keys():
-                for name in dw_prereqs[key]:
-                    parent = world.multiworld.get_region(name, world.player)
-                    parent.connect(dw, f"{parent.name} -> {key}")
-
-            create_dw_locations(world, dw)
-
-
-def create_dw_locations(world: "HatInTimeWorld", dw: Region):
-    loc_id = death_wishes[dw.name]
-    main_objective = HatInTimeLocation(world.player, f"{dw.name} - Main Objective", loc_id, dw)
-    full_clear = HatInTimeLocation(world.player, f"{dw.name} - All Clear", loc_id + 1, dw)
-    main_stamp = HatInTimeLocation(world.player, f"Main Stamp - {dw.name}", None, dw)
-    bonus_stamps = HatInTimeLocation(world.player, f"Bonus Stamps - {dw.name}", None, dw)
-    main_stamp.show_in_spoiler = False
-    bonus_stamps.show_in_spoiler = False
-    dw.locations.append(main_stamp)
-    dw.locations.append(bonus_stamps)
-    main_stamp.place_locked_item(HatInTimeItem(f"1 Stamp - {dw.name}",
-                                               ItemClassification.progression, None, world.player))
-    bonus_stamps.place_locked_item(HatInTimeItem(f"2 Stamp - {dw.name}",
-                                                 ItemClassification.progression, None, world.player))
-
-    if dw.name in world.excluded_dws:
-        main_objective.progress_type = LocationProgressType.EXCLUDED
-        full_clear.progress_type = LocationProgressType.EXCLUDED
-    elif world.is_bonus_excluded(dw.name):
-        full_clear.progress_type = LocationProgressType.EXCLUDED
-
-    dw.locations.append(main_objective)
-    dw.locations.append(full_clear)

worlds/ahit/DeathWishRules.py

@@ -1,462 +0,0 @@
-from worlds.AutoWorld import CollectionState
-from .Rules import can_use_hat, can_use_hookshot, can_hit, zipline_logic, get_difficulty, has_paintings
-from .Types import HatType, Difficulty, HatInTimeLocation, HatInTimeItem, LocData, HitType
-from .DeathWishLocations import dw_prereqs, dw_candles
-from BaseClasses import Entrance, Location, ItemClassification
-from worlds.generic.Rules import add_rule, set_rule
-from typing import List, Callable, TYPE_CHECKING
-from .Locations import death_wishes
-from .Options import EndGoal
-
-if TYPE_CHECKING:
-    from . import HatInTimeWorld
-
-
-# Any speedruns expect the player to have Sprint Hat
-dw_requirements = {
-    "Beat the Heat": LocData(hit_type=HitType.umbrella),
-    "So You're Back From Outer Space": LocData(hookshot=True),
-    "Mafia's Jumps": LocData(required_hats=[HatType.ICE]),
-    "Vault Codes in the Wind": LocData(required_hats=[HatType.SPRINT]),
-
-    "Security Breach": LocData(hit_type=HitType.umbrella_or_brewing),
-    "10 Seconds until Self-Destruct": LocData(hookshot=True),
-    "Community Rift: Rhythm Jump Studio": LocData(required_hats=[HatType.ICE]),
-
-    "Speedrun Well": LocData(hookshot=True, hit_type=HitType.umbrella_or_brewing),
-    "Boss Rush": LocData(hit_type=HitType.umbrella, hookshot=True),
-    "Community Rift: Twilight Travels": LocData(hookshot=True, required_hats=[HatType.DWELLER]),
-
-    "Bird Sanctuary": LocData(hookshot=True),
-    "Wound-Up Windmill": LocData(hookshot=True),
-    "The Illness has Speedrun": LocData(hookshot=True),
-    "Community Rift: The Mountain Rift": LocData(hookshot=True, required_hats=[HatType.DWELLER]),
-    "Camera Tourist": LocData(misc_required=["Camera Badge"]),
-
-    "The Mustache Gauntlet": LocData(hookshot=True, required_hats=[HatType.DWELLER]),
-
-    "Rift Collapse: Deep Sea": LocData(hookshot=True),
-}
-
-# Includes main objective requirements
-dw_bonus_requirements = {
-    # Some One-Hit Hero requirements need badge pins as well because of Hookshot
-    "So You're Back From Outer Space": LocData(required_hats=[HatType.SPRINT]),
-    "Encore! Encore!": LocData(misc_required=["One-Hit Hero Badge"]),
-
-    "10 Seconds until Self-Destruct": LocData(misc_required=["One-Hit Hero Badge", "Badge Pin"]),
-
-    "Boss Rush": LocData(misc_required=["One-Hit Hero Badge", "Badge Pin"]),
-    "Community Rift: Twilight Travels": LocData(required_hats=[HatType.BREWING]),
-
-    "Bird Sanctuary": LocData(misc_required=["One-Hit Hero Badge", "Badge Pin"], required_hats=[HatType.DWELLER]),
-    "Wound-Up Windmill": LocData(misc_required=["One-Hit Hero Badge", "Badge Pin"]),
-    "The Illness has Speedrun": LocData(required_hats=[HatType.SPRINT]),
-
-    "The Mustache Gauntlet": LocData(required_hats=[HatType.ICE]),
-
-    "Rift Collapse: Deep Sea": LocData(required_hats=[HatType.DWELLER]),
-}
-
-dw_stamp_costs = {
-    "So You're Back From Outer Space":  2,
-    "Collect-a-thon":                   5,
-    "She Speedran from Outer Space":    8,
-    "Encore! Encore!":                  10,
-
-    "Security Breach":                  4,
-    "The Great Big Hootenanny":         7,
-    "10 Seconds until Self-Destruct":   15,
-    "Killing Two Birds":                25,
-    "Snatcher Coins in Nyakuza Metro":  30,
-
-    "Speedrun Well":                10,
-    "Boss Rush":                    15,
-    "Quality Time with Snatcher":   20,
-    "Breaching the Contract":       40,
-
-    "Bird Sanctuary":           15,
-    "Wound-Up Windmill":        30,
-    "The Illness has Speedrun": 35,
-
-    "The Mustache Gauntlet":    35,
-    "No More Bad Guys":         50,
-    "Seal the Deal":            70,
-}
-
-required_snatcher_coins = {
-    "Snatcher Coins in Mafia Town": ["Snatcher Coin - Top of HQ", "Snatcher Coin - Top of Tower",
-                                     "Snatcher Coin - Under Ruined Tower"],
-
-    "Snatcher Coins in Battle of the Birds": ["Snatcher Coin - Top of Red House", "Snatcher Coin - Train Rush",
-                                              "Snatcher Coin - Picture Perfect"],
-
-    "Snatcher Coins in Subcon Forest": ["Snatcher Coin - Swamp Tree", "Snatcher Coin - Manor Roof",
-                                        "Snatcher Coin - Giant Time Piece"],
-
-    "Snatcher Coins in Alpine Skyline": ["Snatcher Coin - Goat Village Top", "Snatcher Coin - Lava Cake",
-                                         "Snatcher Coin - Windmill"],
-
-    "Snatcher Coins in Nyakuza Metro": ["Snatcher Coin - Green Clean Tower", "Snatcher Coin - Bluefin Cat Train",
-                                        "Snatcher Coin - Pink Paw Fence"],
-}
-
-
-def set_dw_rules(world: "HatInTimeWorld"):
-    if "Snatcher's Hit List" not in world.excluded_dws or "Camera Tourist" not in world.excluded_dws:
-        set_enemy_rules(world)
-
-    dw_list: List[str] = []
-    if world.options.DWShuffle:
-        dw_list = world.dw_shuffle
-    else:
-        for name in death_wishes.keys():
-            dw_list.append(name)
-
-    for name in dw_list:
-        if name == "Snatcher Coins in Nyakuza Metro" and not world.is_dlc2():
-            continue
-
-        dw = world.multiworld.get_region(name, world.player)
-        if not world.options.DWShuffle and name in dw_stamp_costs.keys():
-            for entrance in dw.entrances:
-                add_rule(entrance, lambda state, n=name: state.has("Stamps", world.player, dw_stamp_costs[n]))
-
-        main_objective = world.multiworld.get_location(f"{name} - Main Objective", world.player)
-        all_clear = world.multiworld.get_location(f"{name} - All Clear", world.player)
-        main_stamp = world.multiworld.get_location(f"Main Stamp - {name}", world.player)
-        bonus_stamps = world.multiworld.get_location(f"Bonus Stamps - {name}", world.player)
-        if not world.options.DWEnableBonus:
-            # place nothing, but let the locations exist still, so we can use them for bonus stamp rules
-            all_clear.address = None
-            all_clear.place_locked_item(HatInTimeItem("Nothing", ItemClassification.filler, None, world.player))
-            all_clear.show_in_spoiler = False
-
-        # No need for rules if excluded - stamps will be auto-granted
-        if world.is_dw_excluded(name):
-            continue
-
-        modify_dw_rules(world, name)
-        add_dw_rules(world, main_objective)
-        add_dw_rules(world, all_clear)
-        add_rule(main_stamp, main_objective.access_rule)
-        add_rule(all_clear, main_objective.access_rule)
-        # Only set bonus stamp rules if we don't auto complete bonuses
-        if not world.options.DWAutoCompleteBonuses and not world.is_bonus_excluded(all_clear.name):
-            add_rule(bonus_stamps, all_clear.access_rule)
-
-    if world.options.DWShuffle:
-        for i in range(len(world.dw_shuffle)-1):
-            name = world.dw_shuffle[i+1]
-            prev_dw = world.multiworld.get_region(world.dw_shuffle[i], world.player)
-            entrance = world.multiworld.get_entrance(f"{prev_dw.name} -> {name}", world.player)
-            add_rule(entrance, lambda state, n=prev_dw.name: state.has(f"1 Stamp - {n}", world.player))
-    else:
-        for key, reqs in dw_prereqs.items():
-            if key == "Snatcher Coins in Nyakuza Metro" and not world.is_dlc2():
-                continue
-
-            access_rules: List[Callable[[CollectionState], bool]] = []
-            entrances: List[Entrance] = []
-
-            for parent in reqs:
-                entrance = world.multiworld.get_entrance(f"{parent} -> {key}", world.player)
-                entrances.append(entrance)
-
-                if not world.is_dw_excluded(parent):
-                    access_rules.append(lambda state, n=parent: state.has(f"1 Stamp - {n}", world.player))
-
-            for entrance in entrances:
-                for rule in access_rules:
-                    add_rule(entrance, rule)
-
-    if world.options.EndGoal == EndGoal.option_seal_the_deal:
-        world.multiworld.completion_condition[world.player] = lambda state: \
-            state.has("1 Stamp - Seal the Deal", world.player)
-
-
-def add_dw_rules(world: "HatInTimeWorld", loc: Location):
-    bonus: bool = "All Clear" in loc.name
-    if not bonus:
-        data = dw_requirements.get(loc.parent_region.name)
-    else:
-        data = dw_bonus_requirements.get(loc.parent_region.name)
-
-    if data is None:
-        return
-
-    if data.hookshot:
-        add_rule(loc, lambda state: can_use_hookshot(state, world))
-
-    for hat in data.required_hats:
-        add_rule(loc, lambda state, h=hat: can_use_hat(state, world, h))
-
-    for misc in data.misc_required:
-        add_rule(loc, lambda state, item=misc: state.has(item, world.player))
-
-    if data.paintings > 0 and world.options.ShuffleSubconPaintings:
-        add_rule(loc, lambda state, paintings=data.paintings: has_paintings(state, world, paintings))
-
-    if data.hit_type is not HitType.none and world.options.UmbrellaLogic:
-        if data.hit_type == HitType.umbrella:
-            add_rule(loc, lambda state: state.has("Umbrella", world.player))
-
-        elif data.hit_type == HitType.umbrella_or_brewing:
-            add_rule(loc, lambda state: state.has("Umbrella", world.player)
-                     or can_use_hat(state, world, HatType.BREWING))
-
-        elif data.hit_type == HitType.dweller_bell:
-            add_rule(loc, lambda state: state.has("Umbrella", world.player)
-                     or can_use_hat(state, world, HatType.BREWING)
-                     or can_use_hat(state, world, HatType.DWELLER))
-
-
-def modify_dw_rules(world: "HatInTimeWorld", name: str):
-    difficulty: Difficulty = get_difficulty(world)
-    main_objective = world.multiworld.get_location(f"{name} - Main Objective", world.player)
-    full_clear = world.multiworld.get_location(f"{name} - All Clear", world.player)
-
-    if name == "The Illness has Speedrun":
-        # All stamps with hookshot only in Expert
-        if difficulty >= Difficulty.EXPERT:
-            set_rule(full_clear, lambda state: True)
-        else:
-            add_rule(main_objective, lambda state: state.has("Umbrella", world.player))
-
-    elif name == "The Mustache Gauntlet":
-        add_rule(main_objective, lambda state: state.has("Umbrella", world.player)
-                 or can_use_hat(state, world, HatType.ICE) or can_use_hat(state, world, HatType.BREWING))
-
-    elif name == "Vault Codes in the Wind":
-        # Sprint is normally expected here
-        if difficulty >= Difficulty.HARD:
-            set_rule(main_objective, lambda state: True)
-
-    elif name == "Speedrun Well":
-        # All stamps with nothing :)
-        if difficulty >= Difficulty.EXPERT:
-            set_rule(main_objective, lambda state: True)
-
-    elif name == "Mafia's Jumps":
-        if difficulty >= Difficulty.HARD:
-            set_rule(main_objective, lambda state: True)
-            set_rule(full_clear, lambda state: True)
-
-    elif name == "So You're Back from Outer Space":
-        # Without Hookshot
-        if difficulty >= Difficulty.HARD:
-            set_rule(main_objective, lambda state: True)
-
-    elif name == "Wound-Up Windmill":
-        # No badge pin required. Player can switch to One Hit Hero after the checkpoint and do level without it.
-        if difficulty >= Difficulty.MODERATE:
-            set_rule(full_clear, lambda state: can_use_hookshot(state, world)
-                     and state.has("One-Hit Hero Badge", world.player))
-
-    if name in dw_candles:
-        set_candle_dw_rules(name, world)
-
-
-def set_candle_dw_rules(name: str, world: "HatInTimeWorld"):
-    main_objective = world.multiworld.get_location(f"{name} - Main Objective", world.player)
-    full_clear = world.multiworld.get_location(f"{name} - All Clear", world.player)
-
-    if name == "Zero Jumps":
-        add_rule(main_objective, lambda state: state.has("Zero Jumps", world.player))
-        add_rule(full_clear, lambda state: state.has("Zero Jumps", world.player, 4)
-                 and state.has("Train Rush (Zero Jumps)", world.player) and can_use_hat(state, world, HatType.ICE))
-
-        # No Ice Hat/painting required in Expert for Toilet Zero Jumps
-        # This painting wall can only be skipped via cherry hover.
-        if get_difficulty(world) < Difficulty.EXPERT or world.options.NoPaintingSkips:
-            set_rule(world.multiworld.get_location("Toilet of Doom (Zero Jumps)", world.player),
-                     lambda state: can_use_hookshot(state, world) and can_hit(state, world)
-                     and has_paintings(state, world, 1, False))
-        else:
-            set_rule(world.multiworld.get_location("Toilet of Doom (Zero Jumps)", world.player),
-                     lambda state: can_use_hookshot(state, world) and can_hit(state, world))
-
-        set_rule(world.multiworld.get_location("Contractual Obligations (Zero Jumps)", world.player),
-                 lambda state: has_paintings(state, world, 1, False))
-
-    elif name == "Snatcher's Hit List":
-        add_rule(main_objective, lambda state: state.has("Mafia Goon", world.player))
-        add_rule(full_clear, lambda state: state.has("Enemy", world.player, 12))
-
-    elif name == "Camera Tourist":
-        add_rule(main_objective, lambda state: state.has("Enemy", world.player, 8))
-        add_rule(full_clear, lambda state: state.has("Boss", world.player, 6)
-                 and state.has("Triple Enemy Photo", world.player))
-
-    elif "Snatcher Coins" in name:
-        coins: List[str] = []
-        for coin in required_snatcher_coins[name]:
-            coins.append(coin)
-            add_rule(full_clear, lambda state, c=coin: state.has(c, world.player))
-
-        # any coin works for the main objective
-        add_rule(main_objective, lambda state: state.has(coins[0], world.player)
-                 or state.has(coins[1], world.player)
-                 or state.has(coins[2], world.player))
-
-
-def create_enemy_events(world: "HatInTimeWorld"):
-    no_tourist = "Camera Tourist" in world.excluded_dws
-    for enemy, regions in hit_list.items():
-        if no_tourist and enemy in bosses:
-            continue
-
-        for area in regions:
-            if (area == "Bon Voyage!" or area == "Time Rift - Deep Sea") and not world.is_dlc1():
-                continue
-
-            if area == "Time Rift - Tour" and (not world.is_dlc1() or world.options.ExcludeTour):
-                continue
-
-            if area == "Bluefin Tunnel" and not world.is_dlc2():
-                continue
-
-            if world.options.DWShuffle and area in death_wishes.keys() and area not in world.dw_shuffle:
-                continue
-
-            region = world.multiworld.get_region(area, world.player)
-            event = HatInTimeLocation(world.player, f"{enemy} - {area}", None, region)
-            event.place_locked_item(HatInTimeItem(enemy, ItemClassification.progression, None, world.player))
-            region.locations.append(event)
-            event.show_in_spoiler = False
-
-    for name in triple_enemy_locations:
-        if name == "Time Rift - Tour" and (not world.is_dlc1() or world.options.ExcludeTour):
-            continue
-
-        if world.options.DWShuffle and name in death_wishes.keys() and name not in world.dw_shuffle:
-            continue
-
-        region = world.multiworld.get_region(name, world.player)
-        event = HatInTimeLocation(world.player, f"Triple Enemy Photo - {name}", None, region)
-        event.place_locked_item(HatInTimeItem("Triple Enemy Photo", ItemClassification.progression, None, world.player))
-        region.locations.append(event)
-        event.show_in_spoiler = False
-        if name == "The Mustache Gauntlet":
-            add_rule(event, lambda state: can_use_hookshot(state, world) and can_use_hat(state, world, HatType.DWELLER))
-
-
-def set_enemy_rules(world: "HatInTimeWorld"):
-    no_tourist = "Camera Tourist" in world.excluded_dws or "Camera Tourist" in world.excluded_bonuses
-
-    for enemy, regions in hit_list.items():
-        if no_tourist and enemy in bosses:
-            continue
-
-        for area in regions:
-            if (area == "Bon Voyage!" or area == "Time Rift - Deep Sea") and not world.is_dlc1():
-                continue
-
-            if area == "Time Rift - Tour" and (not world.is_dlc1() or world.options.ExcludeTour):
-                continue
-
-            if area == "Bluefin Tunnel" and not world.is_dlc2():
-                continue
-
-            if world.options.DWShuffle and area in death_wishes and area not in world.dw_shuffle:
-                continue
-
-            event = world.multiworld.get_location(f"{enemy} - {area}", world.player)
-
-            if enemy == "Toxic Flower":
-                add_rule(event, lambda state: can_use_hookshot(state, world))
-
-                if area == "The Illness has Spread":
-                    add_rule(event, lambda state: not zipline_logic(world) or
-                             state.has("Zipline Unlock - The Birdhouse Path", world.player)
-                             or state.has("Zipline Unlock - The Lava Cake Path", world.player)
-                             or state.has("Zipline Unlock - The Windmill Path", world.player))
-
-            elif enemy == "Director":
-                if area == "Dead Bird Studio Basement":
-                    add_rule(event, lambda state: can_use_hookshot(state, world))
-
-            elif enemy == "Snatcher" or enemy == "Mustache Girl":
-                if area == "Boss Rush":
-                    # need to be able to kill toilet and snatcher
-                    add_rule(event, lambda state: can_hit(state, world) and can_use_hookshot(state, world))
-                    if enemy == "Mustache Girl":
-                        add_rule(event, lambda state: can_hit(state, world, True) and can_use_hookshot(state, world))
-
-                elif area == "The Finale" and enemy == "Mustache Girl":
-                    add_rule(event, lambda state: can_use_hookshot(state, world)
-                             and can_use_hat(state, world, HatType.DWELLER))
-
-            elif enemy == "Shock Squid" or enemy == "Ninja Cat":
-                if area == "Time Rift - Deep Sea":
-                    add_rule(event, lambda state: can_use_hookshot(state, world))
-
-
-# Enemies for Snatcher's Hit List/Camera Tourist, and where to find them
-hit_list = {
-    "Mafia Goon":       ["Mafia Town Area", "Time Rift - Mafia of Cooks", "Time Rift - Tour",
-                         "Bon Voyage!", "The Mustache Gauntlet", "Rift Collapse: Mafia of Cooks",
-                         "So You're Back From Outer Space"],
-
-    "Sleepy Raccoon":   ["She Came from Outer Space", "Down with the Mafia!", "The Twilight Bell",
-                         "She Speedran from Outer Space", "Mafia's Jumps", "The Mustache Gauntlet",
-                         "Time Rift - Sleepy Subcon", "Rift Collapse: Sleepy Subcon"],
-
-    "UFO":              ["Picture Perfect", "So You're Back From Outer Space", "Community Rift: Rhythm Jump Studio"],
-
-    "Rat":              ["Down with the Mafia!", "Bluefin Tunnel"],
-
-    "Shock Squid":      ["Bon Voyage!", "Time Rift - Sleepy Subcon", "Time Rift - Deep Sea",
-                         "Rift Collapse: Sleepy Subcon"],
-
-    "Shromb Egg":       ["The Birdhouse", "Bird Sanctuary"],
-
-    "Spider":           ["Subcon Forest Area", "The Mustache Gauntlet", "Speedrun Well",
-                         "The Lava Cake", "The Windmill"],
-
-    "Crow":             ["Mafia Town Area", "The Birdhouse", "Time Rift - Tour", "Bird Sanctuary",
-                         "Time Rift - Alpine Skyline", "Rift Collapse: Alpine Skyline"],
-
-    "Pompous Crow":     ["The Birdhouse", "Time Rift - The Lab", "Bird Sanctuary", "The Mustache Gauntlet"],
-
-    "Fiery Crow":       ["The Finale", "The Lava Cake", "The Mustache Gauntlet"],
-
-    "Express Owl":      ["The Finale", "Time Rift - The Owl Express", "Time Rift - Deep Sea"],
-
-    "Ninja Cat":        ["The Birdhouse", "The Windmill", "Bluefin Tunnel", "The Mustache Gauntlet",
-                         "Time Rift - Curly Tail Trail", "Time Rift - Alpine Skyline", "Time Rift - Deep Sea",
-                         "Rift Collapse: Alpine Skyline"],
-
-    # Bosses
-    "Mafia Boss":       ["Down with the Mafia!", "Encore! Encore!", "Boss Rush"],
-
-    "Conductor":        ["Dead Bird Studio Basement", "Killing Two Birds", "Boss Rush"],
-    "Toilet":           ["Toilet of Doom", "Boss Rush"],
-
-    "Snatcher":         ["Your Contract has Expired", "Breaching the Contract", "Boss Rush",
-                         "Quality Time with Snatcher"],
-
-    "Toxic Flower":     ["The Illness has Spread", "The Illness has Speedrun"],
-
-    "Mustache Girl":    ["The Finale", "Boss Rush", "No More Bad Guys"],
-}
-
-# Camera Tourist has a bonus that requires getting three different types of enemies in one photo.
-triple_enemy_locations = [
-    "She Came from Outer Space",
-    "She Speedran from Outer Space",
-    "Mafia's Jumps",
-    "The Mustache Gauntlet",
-    "The Birdhouse",
-    "Bird Sanctuary",
-    "Time Rift - Tour",
-]
-
-bosses = [
-    "Mafia Boss",
-    "Conductor",
-    "Toilet",
-    "Snatcher",
-    "Toxic Flower",
-    "Mustache Girl",
-]

worlds/ahit/Items.py

@@ -1,302 +0,0 @@
-from BaseClasses import Item, ItemClassification
-from .Types import HatDLC, HatType, hat_type_to_item, Difficulty, ItemData, HatInTimeItem
-from .Locations import get_total_locations
-from .Rules import get_difficulty
-from .Options import get_total_time_pieces, CTRLogic
-from typing import List, Dict, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from . import HatInTimeWorld
-
-
-def create_itempool(world: "HatInTimeWorld") -> List[Item]:
-    itempool: List[Item] = []
-    if world.has_yarn():
-        yarn_pool: List[Item] = create_multiple_items(world, "Yarn",
-                                                      world.options.YarnAvailable.value,
-                                                      ItemClassification.progression_skip_balancing)
-
-        for i in range(int(len(yarn_pool) * (0.01 * world.options.YarnBalancePercent))):
-            yarn_pool[i].classification = ItemClassification.progression
-
-        itempool += yarn_pool
-
-    for name in item_table.keys():
-        if name == "Yarn":
-            continue
-
-        if not item_dlc_enabled(world, name):
-            continue
-
-        if not world.options.HatItems and name in hat_type_to_item.values():
-            continue
-
-        item_type: ItemClassification = item_table.get(name).classification
-
-        if world.is_dw_only():
-            if item_type is ItemClassification.progression \
-               or item_type is ItemClassification.progression_skip_balancing:
-                continue
-        else:
-            if name == "Scooter Badge":
-                if world.options.CTRLogic is CTRLogic.option_scooter or get_difficulty(world) >= Difficulty.MODERATE:
-                    item_type = ItemClassification.progression
-            elif name == "No Bonk Badge" and world.is_dw():
-                item_type = ItemClassification.progression
-
-        # some death wish bonuses require one hit hero + hookshot
-        if world.is_dw() and name == "Badge Pin" and not world.is_dw_only():
-            item_type = ItemClassification.progression
-
-        if item_type is ItemClassification.filler or item_type is ItemClassification.trap:
-            continue
-
-        if name in act_contracts.keys() and not world.options.ShuffleActContracts:
-            continue
-
-        if name in alps_hooks.keys() and not world.options.ShuffleAlpineZiplines:
-            continue
-
-        if name == "Progressive Painting Unlock" and not world.options.ShuffleSubconPaintings:
-            continue
-
-        if world.options.StartWithCompassBadge and name == "Compass Badge":
-            continue
-
-        if name == "Time Piece":
-            tp_list: List[Item] = create_multiple_items(world, name, get_total_time_pieces(world), item_type)
-            for i in range(int(len(tp_list) * (0.01 * world.options.TimePieceBalancePercent))):
-                tp_list[i].classification = ItemClassification.progression
-
-            itempool += tp_list
-            continue
-
-        itempool += create_multiple_items(world, name, item_frequencies.get(name, 1), item_type)
-
-    itempool += create_junk_items(world, get_total_locations(world) - len(itempool))
-    return itempool
-
-
-def calculate_yarn_costs(world: "HatInTimeWorld"):
-    min_yarn_cost = int(min(world.options.YarnCostMin.value, world.options.YarnCostMax.value))
-    max_yarn_cost = int(max(world.options.YarnCostMin.value, world.options.YarnCostMax.value))
-
-    max_cost = 0
-    for i in range(5):
-        hat: HatType = HatType(i)
-        if not world.is_hat_precollected(hat):
-            cost: int = world.random.randint(min_yarn_cost, max_yarn_cost)
-            world.hat_yarn_costs[hat] = cost
-            max_cost += cost
-        else:
-            world.hat_yarn_costs[hat] = 0
-
-    available_yarn: int = world.options.YarnAvailable.value
-    if max_cost > available_yarn:
-        world.options.YarnAvailable.value = max_cost
-        available_yarn = max_cost
-
-    extra_yarn = max_cost + world.options.MinExtraYarn - available_yarn
-    if extra_yarn > 0:
-        world.options.YarnAvailable.value += extra_yarn
-
-
-def item_dlc_enabled(world: "HatInTimeWorld", name: str) -> bool:
-    data = item_table[name]
-
-    if data.dlc_flags == HatDLC.none:
-        return True
-    elif data.dlc_flags == HatDLC.dlc1 and world.is_dlc1():
-        return True
-    elif data.dlc_flags == HatDLC.dlc2 and world.is_dlc2():
-        return True
-    elif data.dlc_flags == HatDLC.death_wish and world.is_dw():
-        return True
-
-    return False
-
-
-def create_item(world: "HatInTimeWorld", name: str) -> Item:
-    data = item_table[name]
-    return HatInTimeItem(name, data.classification, data.code, world.player)
-
-
-def create_multiple_items(world: "HatInTimeWorld", name: str, count: int = 1,
-                          item_type: ItemClassification = ItemClassification.progression) -> List[Item]:
-
-    data = item_table[name]
-    itemlist: List[Item] = []
-
-    for i in range(count):
-        itemlist += [HatInTimeItem(name, item_type, data.code, world.player)]
-
-    return itemlist
-
-
-def create_junk_items(world: "HatInTimeWorld", count: int) -> List[Item]:
-    trap_chance = world.options.TrapChance.value
-    junk_pool: List[Item] = []
-    junk_list: Dict[str, int] = {}
-    trap_list: Dict[str, int] = {}
-    ic: ItemClassification
-
-    for name in item_table.keys():
-        ic = item_table[name].classification
-        if ic == ItemClassification.filler:
-            if world.is_dw_only() and "Pons" in name:
-                continue
-
-            junk_list[name] = junk_weights.get(name)
-
-        elif trap_chance > 0 and ic == ItemClassification.trap:
-            if name == "Baby Trap":
-                trap_list[name] = world.options.BabyTrapWeight.value
-            elif name == "Laser Trap":
-                trap_list[name] = world.options.LaserTrapWeight.value
-            elif name == "Parade Trap":
-                trap_list[name] = world.options.ParadeTrapWeight.value
-
-    for i in range(count):
-        if trap_chance > 0 and world.random.randint(1, 100) <= trap_chance:
-            junk_pool.append(world.create_item(
-                world.random.choices(list(trap_list.keys()), weights=list(trap_list.values()), k=1)[0]))
-        else:
-            junk_pool.append(world.create_item(
-                world.random.choices(list(junk_list.keys()), weights=list(junk_list.values()), k=1)[0]))
-
-    return junk_pool
-
-
-def get_shop_trap_name(world: "HatInTimeWorld") -> str:
-    rand = world.random.randint(1, 9)
-    name = ""
-    if rand == 1:
-        name = "Time Plece"
-    elif rand == 2:
-        name = "Time Piece (Trust me bro)"
-    elif rand == 3:
-        name = "TimePiece"
-    elif rand == 4:
-        name = "Time Piece?"
-    elif rand == 5:
-        name = "Time Pizza"
-    elif rand == 6:
-        name = "Time piece"
-    elif rand == 7:
-        name = "TIme Piece"
-    elif rand == 8:
-        name = "Time Piece (maybe)"
-    elif rand == 9:
-        name = "Time Piece ;)"
-
-    return name
-
-
-ahit_items = {
-    "Yarn": ItemData(2000300001, ItemClassification.progression_skip_balancing),
-    "Time Piece": ItemData(2000300002, ItemClassification.progression_skip_balancing),
-
-    # for HatItems option
-    "Sprint Hat": ItemData(2000300049, ItemClassification.progression),
-    "Brewing Hat": ItemData(2000300050, ItemClassification.progression),
-    "Ice Hat": ItemData(2000300051, ItemClassification.progression),
-    "Dweller Mask": ItemData(2000300052, ItemClassification.progression),
-    "Time Stop Hat": ItemData(2000300053, ItemClassification.progression),
-
-    # Badges
-    "Projectile Badge": ItemData(2000300024, ItemClassification.useful),
-    "Fast Hatter Badge": ItemData(2000300025, ItemClassification.useful),
-    "Hover Badge": ItemData(2000300026, ItemClassification.useful),
-    "Hookshot Badge": ItemData(2000300027, ItemClassification.progression),
-    "Item Magnet Badge": ItemData(2000300028, ItemClassification.useful),
-    "No Bonk Badge": ItemData(2000300029, ItemClassification.useful),
-    "Compass Badge": ItemData(2000300030, ItemClassification.useful),
-    "Scooter Badge": ItemData(2000300031, ItemClassification.useful),
-    "One-Hit Hero Badge": ItemData(2000300038, ItemClassification.progression, HatDLC.death_wish),
-    "Camera Badge": ItemData(2000300042, ItemClassification.progression, HatDLC.death_wish),
-
-    # Relics
-    "Relic (Burger Patty)": ItemData(2000300006, ItemClassification.progression),
-    "Relic (Burger Cushion)": ItemData(2000300007, ItemClassification.progression),
-    "Relic (Mountain Set)": ItemData(2000300008, ItemClassification.progression),
-    "Relic (Train)": ItemData(2000300009, ItemClassification.progression),
-    "Relic (UFO)": ItemData(2000300010, ItemClassification.progression),
-    "Relic (Cow)": ItemData(2000300011, ItemClassification.progression),
-    "Relic (Cool Cow)": ItemData(2000300012, ItemClassification.progression),
-    "Relic (Tin-foil Hat Cow)": ItemData(2000300013, ItemClassification.progression),
-    "Relic (Crayon Box)": ItemData(2000300014, ItemClassification.progression),
-    "Relic (Red Crayon)": ItemData(2000300015, ItemClassification.progression),
-    "Relic (Blue Crayon)": ItemData(2000300016, ItemClassification.progression),
-    "Relic (Green Crayon)": ItemData(2000300017, ItemClassification.progression),
-    # DLC
-    "Relic (Cake Stand)": ItemData(2000300018, ItemClassification.progression, HatDLC.dlc1),
-    "Relic (Shortcake)": ItemData(2000300019, ItemClassification.progression, HatDLC.dlc1),
-    "Relic (Chocolate Cake Slice)": ItemData(2000300020, ItemClassification.progression, HatDLC.dlc1),
-    "Relic (Chocolate Cake)": ItemData(2000300021, ItemClassification.progression, HatDLC.dlc1),
-    "Relic (Necklace Bust)": ItemData(2000300022, ItemClassification.progression, HatDLC.dlc2),
-    "Relic (Necklace)": ItemData(2000300023, ItemClassification.progression, HatDLC.dlc2),
-
-    # Garbage items
-    "25 Pons": ItemData(2000300034, ItemClassification.filler),
-    "50 Pons": ItemData(2000300035, ItemClassification.filler),
-    "100 Pons": ItemData(2000300036, ItemClassification.filler),
-    "Health Pon": ItemData(2000300037, ItemClassification.filler),
-    "Random Cosmetic": ItemData(2000300044, ItemClassification.filler),
-
-    # Traps
-    "Baby Trap": ItemData(2000300039, ItemClassification.trap),
-    "Laser Trap": ItemData(2000300040, ItemClassification.trap),
-    "Parade Trap": ItemData(2000300041, ItemClassification.trap),
-
-    # Other
-    "Badge Pin": ItemData(2000300043, ItemClassification.useful),
-    "Umbrella": ItemData(2000300033, ItemClassification.progression),
-    "Progressive Painting Unlock": ItemData(2000300003, ItemClassification.progression),
-    # DLC
-    "Metro Ticket - Yellow": ItemData(2000300045, ItemClassification.progression, HatDLC.dlc2),
-    "Metro Ticket - Green": ItemData(2000300046, ItemClassification.progression, HatDLC.dlc2),
-    "Metro Ticket - Blue": ItemData(2000300047, ItemClassification.progression, HatDLC.dlc2),
-    "Metro Ticket - Pink": ItemData(2000300048, ItemClassification.progression, HatDLC.dlc2),
-}
-
-act_contracts = {
-    "Snatcher's Contract - The Subcon Well": ItemData(2000300200, ItemClassification.progression),
-    "Snatcher's Contract - Toilet of Doom": ItemData(2000300201, ItemClassification.progression),
-    "Snatcher's Contract - Queen Vanessa's Manor": ItemData(2000300202, ItemClassification.progression),
-    "Snatcher's Contract - Mail Delivery Service": ItemData(2000300203, ItemClassification.progression),
-}
-
-alps_hooks = {
-    "Zipline Unlock - The Birdhouse Path": ItemData(2000300204, ItemClassification.progression),
-    "Zipline Unlock - The Lava Cake Path": ItemData(2000300205, ItemClassification.progression),
-    "Zipline Unlock - The Windmill Path": ItemData(2000300206, ItemClassification.progression),
-    "Zipline Unlock - The Twilight Bell Path": ItemData(2000300207, ItemClassification.progression),
-}
-
-relic_groups = {
-    "Burger": {"Relic (Burger Patty)", "Relic (Burger Cushion)"},
-    "Train": {"Relic (Mountain Set)", "Relic (Train)"},
-    "UFO": {"Relic (UFO)", "Relic (Cow)", "Relic (Cool Cow)", "Relic (Tin-foil Hat Cow)"},
-    "Crayon": {"Relic (Crayon Box)", "Relic (Red Crayon)", "Relic (Blue Crayon)", "Relic (Green Crayon)"},
-    "Cake": {"Relic (Cake Stand)", "Relic (Chocolate Cake)", "Relic (Chocolate Cake Slice)", "Relic (Shortcake)"},
-    "Necklace": {"Relic (Necklace Bust)", "Relic (Necklace)"},
-}
-
-item_frequencies = {
-    "Badge Pin": 2,
-    "Progressive Painting Unlock": 3,
-}
-
-junk_weights = {
-    "25 Pons": 50,
-    "50 Pons": 25,
-    "100 Pons": 10,
-    "Health Pon": 35,
-    "Random Cosmetic": 35,
-}
-
-item_table = {
-    **ahit_items,
-    **act_contracts,
-    **alps_hooks,
-}

worlds/ahit/Options.py

@@ -1,770 +0,0 @@
-from typing import List, TYPE_CHECKING, Dict, Any
-from schema import Schema, Optional
-from dataclasses import dataclass
-from worlds.AutoWorld import PerGameCommonOptions
-from Options import Range, Toggle, DeathLink, Choice, OptionDict, DefaultOnToggle, OptionGroup
-
-if TYPE_CHECKING:
-    from . import HatInTimeWorld
-
-
-def create_option_groups() -> List[OptionGroup]:
-    option_group_list: List[OptionGroup] = []
-    for name, options in ahit_option_groups.items():
-        option_group_list.append(OptionGroup(name=name, options=options))
-
-    return option_group_list
-
-
-def adjust_options(world: "HatInTimeWorld"):
-    if world.options.HighestChapterCost < world.options.LowestChapterCost:
-        world.options.HighestChapterCost.value, world.options.LowestChapterCost.value = \
-         world.options.LowestChapterCost.value, world.options.HighestChapterCost.value
-
-    if world.options.FinalChapterMaxCost < world.options.FinalChapterMinCost:
-        world.options.FinalChapterMaxCost.value, world.options.FinalChapterMinCost.value = \
-         world.options.FinalChapterMinCost.value, world.options.FinalChapterMaxCost.value
-
-    if world.options.BadgeSellerMaxItems < world.options.BadgeSellerMinItems:
-        world.options.BadgeSellerMaxItems.value, world.options.BadgeSellerMinItems.value = \
-         world.options.BadgeSellerMinItems.value, world.options.BadgeSellerMaxItems.value
-
-    if world.options.NyakuzaThugMaxShopItems < world.options.NyakuzaThugMinShopItems:
-        world.options.NyakuzaThugMaxShopItems.value, world.options.NyakuzaThugMinShopItems.value = \
-         world.options.NyakuzaThugMinShopItems.value, world.options.NyakuzaThugMaxShopItems.value
-
-    if world.options.DWShuffleCountMax < world.options.DWShuffleCountMin:
-        world.options.DWShuffleCountMax.value, world.options.DWShuffleCountMin.value = \
-         world.options.DWShuffleCountMin.value, world.options.DWShuffleCountMax.value
-
-    total_tps: int = get_total_time_pieces(world)
-    if world.options.HighestChapterCost > total_tps-5:
-        world.options.HighestChapterCost.value = min(45, total_tps-5)
-
-    if world.options.LowestChapterCost > total_tps-5:
-        world.options.LowestChapterCost.value = min(45, total_tps-5)
-
-    if world.options.FinalChapterMaxCost > total_tps:
-        world.options.FinalChapterMaxCost.value = min(50, total_tps)
-
-    if world.options.FinalChapterMinCost > total_tps:
-        world.options.FinalChapterMinCost.value = min(50, total_tps)
-
-    if world.is_dlc1() and world.options.ShipShapeCustomTaskGoal <= 0:
-        # automatically determine task count based on Tasksanity settings
-        if world.options.Tasksanity:
-            world.options.ShipShapeCustomTaskGoal.value = world.options.TasksanityCheckCount * world.options.TasksanityTaskStep
-        else:
-            world.options.ShipShapeCustomTaskGoal.value = 18
-
-    # Don't allow Rush Hour goal if DLC2 content is disabled
-    if world.options.EndGoal == EndGoal.option_rush_hour and not world.options.EnableDLC2:
-        world.options.EndGoal.value = EndGoal.option_finale
-
-    # Don't allow Seal the Deal goal if Death Wish content is disabled
-    if world.options.EndGoal == EndGoal.option_seal_the_deal and not world.is_dw():
-        world.options.EndGoal.value = EndGoal.option_finale
-
-    if world.options.DWEnableBonus:
-        world.options.DWAutoCompleteBonuses.value = 0
-
-    if world.is_dw_only():
-        world.options.EndGoal.value = EndGoal.option_seal_the_deal
-        world.options.ActRandomizer.value = 0
-        world.options.ShuffleAlpineZiplines.value = 0
-        world.options.ShuffleSubconPaintings.value = 0
-        world.options.ShuffleStorybookPages.value = 0
-        world.options.ShuffleActContracts.value = 0
-        world.options.EnableDLC1.value = 0
-        world.options.LogicDifficulty.value = LogicDifficulty.option_normal
-        world.options.DWTimePieceRequirement.value = 0
-
-
-def get_total_time_pieces(world: "HatInTimeWorld") -> int:
-    count: int = 40
-    if world.is_dlc1():
-        count += 6
-
-    if world.is_dlc2():
-        count += 10
-
-    return min(40+world.options.MaxExtraTimePieces, count)
-
-
-class EndGoal(Choice):
-    """The end goal required to beat the game.
-    Finale: Reach Time's End and beat Mustache Girl. The Finale will be in its vanilla location.
-
-    Rush Hour: Reach and complete Rush Hour. The level will be in its vanilla location and Chapter 7
-    will be the final chapter. You also must find Nyakuza Metro itself and complete all of its levels.
-    Requires DLC2 content to be enabled.
-
-    Seal the Deal: Reach and complete the Seal the Deal death wish main objective.
-    Requires Death Wish content to be enabled."""
-    display_name = "End Goal"
-    option_finale = 1
-    option_rush_hour = 2
-    option_seal_the_deal = 3
-    default = 1
-
-
-class ActRandomizer(Choice):
-    """If enabled, shuffle the game's Acts between each other.
-    Light will cause Time Rifts to only be shuffled amongst each other,
-    and Blue Time Rifts and Purple Time Rifts to be shuffled separately."""
-    display_name = "Shuffle Acts"
-    option_false = 0
-    option_light = 1
-    option_insanity = 2
-    default = 1
-
-
-class ActPlando(OptionDict):
-    """Plando acts onto other acts. For example, \"Train Rush\": \"Alpine Free Roam\" will place Alpine Free Roam
-    at Train Rush."""
-    display_name = "Act Plando"
-    schema = Schema({
-        Optional(str): str
-    })
-
-
-class ActBlacklist(OptionDict):
-    """Blacklist acts from being shuffled onto other acts. Multiple can be listed per act.
-    For example, \"Barrel Battle\": [\"The Big Parade\", \"Dead Bird Studio\"]
-    will prevent The Big Parade and Dead Bird Studio from being shuffled onto Barrel Battle."""
-    display_name = "Act Blacklist"
-    schema = Schema({
-        Optional(str): list
-    })
-
-
-class FinaleShuffle(Toggle):
-    """If enabled, chapter finales will only be shuffled amongst each other in act shuffle."""
-    display_name = "Finale Shuffle"
-
-
-class LogicDifficulty(Choice):
-    """Choose the difficulty setting for logic.
-    For an exhaustive list of all logic tricks for each difficulty, see this Google Doc:
-    https://docs.google.com/document/d/1x9VLSQ5davfx1KGamR9T0mD5h69_lDXJ6H7Gq7knJRI/edit?usp=sharing"""
-    display_name = "Logic Difficulty"
-    option_normal = -1
-    option_moderate = 0
-    option_hard = 1
-    option_expert = 2
-    default = -1
-
-
-class CTRLogic(Choice):
-    """Choose how you want to logically clear Cheating the Race."""
-    display_name = "Cheating the Race Logic"
-    option_time_stop_only = 0
-    option_scooter = 1
-    option_sprint = 2
-    option_nothing = 3
-    default = 0
-
-
-class RandomizeHatOrder(Choice):
-    """Randomize the order that hats are stitched in.
-    Time Stop Last will force Time Stop to be the last hat in the sequence."""
-    display_name = "Randomize Hat Order"
-    option_false = 0
-    option_true = 1
-    option_time_stop_last = 2
-    default = 1
-
-
-class YarnBalancePercent(Range):
-    """How much (in percentage) of the yarn in the pool that will be progression balanced."""
-    display_name = "Yarn Balance Percentage"
-    default = 20
-    range_start = 0
-    range_end = 100
-
-
-class TimePieceBalancePercent(Range):
-    """How much (in percentage) of time pieces in the pool that will be progression balanced."""
-    display_name = "Time Piece Balance Percentage"
-    default = 35
-    range_start = 0
-    range_end = 100
-
-
-class StartWithCompassBadge(DefaultOnToggle):
-    """If enabled, start with the Compass Badge. In Archipelago, the Compass Badge will track all items in the world
-    (instead of just Relics). Recommended if you're not familiar with where item locations are."""
-    display_name = "Start with Compass Badge"
-
-
-class CompassBadgeMode(Choice):
-    """closest - Compass Badge points to the closest item regardless of classification
-    important_only - Compass Badge points to progression/useful items only
-    important_first - Compass Badge points to progression/useful items first, then it will point to junk items"""
-    display_name = "Compass Badge Mode"
-    option_closest = 1
-    option_important_only = 2
-    option_important_first = 3
-    default = 1
-
-
-class UmbrellaLogic(Toggle):
-    """Makes Hat Kid's default punch attack do absolutely nothing, making the Umbrella much more relevant and useful"""
-    display_name = "Umbrella Logic"
-
-
-class ShuffleStorybookPages(DefaultOnToggle):
-    """If enabled, each storybook page in the purple Time Rifts is an item check.
-    The Compass Badge can track these down for you."""
-    display_name = "Shuffle Storybook Pages"
-
-
-class ShuffleActContracts(DefaultOnToggle):
-    """If enabled, shuffle Snatcher's act contracts into the pool as items"""
-    display_name = "Shuffle Contracts"
-
-
-class ShuffleAlpineZiplines(Toggle):
-    """If enabled, Alpine's zipline paths leading to the peaks will be locked behind items."""
-    display_name = "Shuffle Alpine Ziplines"
-
-
-class ShuffleSubconPaintings(Toggle):
-    """If enabled, shuffle items into the pool that unlock Subcon Forest fire spirit paintings.
-    These items are progressive, with the order of Village-Swamp-Courtyard."""
-    display_name = "Shuffle Subcon Paintings"
-
-
-class NoPaintingSkips(Toggle):
-    """If enabled, prevent Subcon fire wall skips from being in logic on higher difficulty settings."""
-    display_name = "No Subcon Fire Wall Skips"
-
-
-class StartingChapter(Choice):
-    """Determines which chapter you will be guaranteed to be able to enter at the beginning of the game."""
-    display_name = "Starting Chapter"
-    option_1 = 1
-    option_2 = 2
-    option_3 = 3
-    option_4 = 4
-    default = 1
-
-
-class ChapterCostIncrement(Range):
-    """Lower values mean chapter costs increase slower. Higher values make the cost differences more steep."""
-    display_name = "Chapter Cost Increment"
-    range_start = 1
-    range_end = 8
-    default = 4
-
-
-class ChapterCostMinDifference(Range):
-    """The minimum difference between chapter costs."""
-    display_name = "Minimum Chapter Cost Difference"
-    range_start = 1
-    range_end = 8
-    default = 4
-
-
-class LowestChapterCost(Range):
-    """Value determining the lowest possible cost for a chapter.
-    Chapter costs will, progressively, be calculated based on this value (except for the final chapter)."""
-    display_name = "Lowest Possible Chapter Cost"
-    range_start = 0
-    range_end = 10
-    default = 5
-
-
-class HighestChapterCost(Range):
-    """Value determining the highest possible cost for a chapter.
-    Chapter costs will, progressively, be calculated based on this value (except for the final chapter)."""
-    display_name = "Highest Possible Chapter Cost"
-    range_start = 15
-    range_end = 45
-    default = 25
-
-
-class FinalChapterMinCost(Range):
-    """Minimum Time Pieces required to enter the final chapter. This is part of your goal."""
-    display_name = "Final Chapter Minimum Time Piece Cost"
-    range_start = 0
-    range_end = 50
-    default = 30
-
-
-class FinalChapterMaxCost(Range):
-    """Maximum Time Pieces required to enter the final chapter. This is part of your goal."""
-    display_name = "Final Chapter Maximum Time Piece Cost"
-    range_start = 0
-    range_end = 50
-    default = 35
-
-
-class MaxExtraTimePieces(Range):
-    """Maximum number of extra Time Pieces from the DLCs.
-    Arctic Cruise will add up to 6. Nyakuza Metro will add up to 10. The absolute maximum is 56."""
-    display_name = "Max Extra Time Pieces"
-    range_start = 0
-    range_end = 16
-    default = 16
-
-
-class YarnCostMin(Range):
-    """The minimum possible yarn needed to stitch a hat."""
-    display_name = "Minimum Yarn Cost"
-    range_start = 1
-    range_end = 12
-    default = 4
-
-
-class YarnCostMax(Range):
-    """The maximum possible yarn needed to stitch a hat."""
-    display_name = "Maximum Yarn Cost"
-    range_start = 1
-    range_end = 12
-    default = 8
-
-
-class YarnAvailable(Range):
-    """How much yarn is available to collect in the item pool."""
-    display_name = "Yarn Available"
-    range_start = 30
-    range_end = 80
-    default = 50
-
-
-class MinExtraYarn(Range):
-    """The minimum number of extra yarn in the item pool.
-    There must be at least this much more yarn over the total number of yarn needed to craft all hats.
-    For example, if this option's value is 10, and the total yarn needed to craft all hats is 40,
-    there must be at least 50 yarn in the pool."""
-    display_name = "Max Extra Yarn"
-    range_start = 5
-    range_end = 15
-    default = 10
-
-
-class HatItems(Toggle):
-    """Removes all yarn from the pool and turns the hats into individual items instead."""
-    display_name = "Hat Items"
-
-
-class MinPonCost(Range):
-    """The minimum number of Pons that any item in the Badge Seller's shop can cost."""
-    display_name = "Minimum Shop Pon Cost"
-    range_start = 10
-    range_end = 800
-    default = 75
-
-
-class MaxPonCost(Range):
-    """The maximum number of Pons that any item in the Badge Seller's shop can cost."""
-    display_name = "Maximum Shop Pon Cost"
-    range_start = 10
-    range_end = 800
-    default = 300
-
-
-class BadgeSellerMinItems(Range):
-    """The smallest number of items that the Badge Seller can have for sale."""
-    display_name = "Badge Seller Minimum Items"
-    range_start = 0
-    range_end = 10
-    default = 4
-
-
-class BadgeSellerMaxItems(Range):
-    """The largest number of items that the Badge Seller can have for sale."""
-    display_name = "Badge Seller Maximum Items"
-    range_start = 0
-    range_end = 10
-    default = 8
-
-
-class EnableDLC1(Toggle):
-    """Shuffle content from The Arctic Cruise (Chapter 6) into the game. This also includes the Tour time rift.
-    DO NOT ENABLE THIS OPTION IF YOU DO NOT HAVE SEAL THE DEAL DLC INSTALLED!!!"""
-    display_name = "Shuffle Chapter 6"
-
-
-class Tasksanity(Toggle):
-    """If enabled, Ship Shape tasks will become checks. Requires DLC1 content to be enabled."""
-    display_name = "Tasksanity"
-
-
-class TasksanityTaskStep(Range):
-    """How many tasks the player must complete in Tasksanity to send a check."""
-    display_name = "Tasksanity Task Step"
-    range_start = 1
-    range_end = 3
-    default = 1
-
-
-class TasksanityCheckCount(Range):
-    """How many Tasksanity checks there will be in total."""
-    display_name = "Tasksanity Check Count"
-    range_start = 1
-    range_end = 30
-    default = 18
-
-
-class ExcludeTour(Toggle):
-    """Removes the Tour time rift from the game. This option is recommended if you don't want to deal with
-    important levels being shuffled onto the Tour time rift, or important items being shuffled onto Tour pages
-    when your goal is Time's End."""
-    display_name = "Exclude Tour Time Rift"
-
-
-class ShipShapeCustomTaskGoal(Range):
-    """Change the number of tasks required to complete Ship Shape. If this option's value is 0, the number of tasks
-    required will be TasksanityTaskStep x TasksanityCheckCount, if Tasksanity is enabled. If Tasksanity is disabled,
-    it will use the game's default of 18.
-    This option will not affect Cruisin' for a Bruisin'."""
-    display_name = "Ship Shape Custom Task Goal"
-    range_start = 0
-    range_end = 90
-    default = 0
-
-
-class EnableDLC2(Toggle):
-    """Shuffle content from Nyakuza Metro (Chapter 7) into the game.
-    DO NOT ENABLE THIS OPTION IF YOU DO NOT HAVE NYAKUZA METRO DLC INSTALLED!!!"""
-    display_name = "Shuffle Chapter 7"
-
-
-class MetroMinPonCost(Range):
-    """The cheapest an item can be in any Nyakuza Metro shop. Includes ticket booths."""
-    display_name = "Metro Shops Minimum Pon Cost"
-    range_start = 10
-    range_end = 800
-    default = 50
-
-
-class MetroMaxPonCost(Range):
-    """The most expensive an item can be in any Nyakuza Metro shop. Includes ticket booths."""
-    display_name = "Metro Shops Maximum Pon Cost"
-    range_start = 10
-    range_end = 800
-    default = 200
-
-
-class NyakuzaThugMinShopItems(Range):
-    """The smallest number of items that the thugs in Nyakuza Metro can have for sale."""
-    display_name = "Nyakuza Thug Minimum Shop Items"
-    range_start = 0
-    range_end = 5
-    default = 2
-
-
-class NyakuzaThugMaxShopItems(Range):
-    """The largest number of items that the thugs in Nyakuza Metro can have for sale."""
-    display_name = "Nyakuza Thug Maximum Shop Items"
-    range_start = 0
-    range_end = 5
-    default = 4
-
-
-class NoTicketSkips(Choice):
-    """Prevent metro gate skips from being in logic on higher difficulties.
-    Rush Hour option will only consider the ticket skips for Rush Hour in logic."""
-    display_name = "No Ticket Skips"
-    option_false = 0
-    option_true = 1
-    option_rush_hour = 2
-
-
-class BaseballBat(Toggle):
-    """Replace the Umbrella with the baseball bat from Nyakuza Metro.
-    DLC2 content does not have to be shuffled for this option but Nyakuza Metro still needs to be installed."""
-    display_name = "Baseball Bat"
-
-
-class EnableDeathWish(Toggle):
-    """Shuffle Death Wish contracts into the game. Each contract by default will have 1 check granted upon completion.
-    DO NOT ENABLE THIS OPTION IF YOU DO NOT HAVE SEAL THE DEAL DLC INSTALLED!!!"""
-    display_name = "Enable Death Wish"
-
-
-class DeathWishOnly(Toggle):
-    """An alternative gameplay mode that allows you to exclusively play Death Wish in a seed.
-    This has the following effects:
-    - Death Wish is instantly unlocked from the start
-    - All hats and other progression items are instantly given to you
-    - Useful items such as Fast Hatter Badge will still be in the item pool instead of in your inventory at the start
-    - All chapters and their levels are unlocked, act shuffle is forced off
-    - Any checks other than Death Wish contracts are completely removed
-    - All Pons in the item pool are replaced with Health Pons or random cosmetics
-    - The EndGoal option is forced to complete Seal the Deal"""
-    display_name = "Death Wish Only"
-
-
-class DWShuffle(Toggle):
-    """An alternative mode for Death Wish where each contract is unlocked one by one, in a random order.
-    Stamp requirements to unlock contracts is removed. Any excluded contracts will not be shuffled into the sequence.
-    If Seal the Deal is the end goal, it will always be the last Death Wish in the sequence.
-    Disabling candles is highly recommended."""
-    display_name = "Death Wish Shuffle"
-
-
-class DWShuffleCountMin(Range):
-    """The minimum number of Death Wishes that can be in the Death Wish shuffle sequence.
-    The final result is clamped at the number of non-excluded Death Wishes."""
-    display_name = "Death Wish Shuffle Minimum Count"
-    range_start = 5
-    range_end = 38
-    default = 18
-
-
-class DWShuffleCountMax(Range):
-    """The maximum number of Death Wishes that can be in the Death Wish shuffle sequence.
-    The final result is clamped at the number of non-excluded Death Wishes."""
-    display_name = "Death Wish Shuffle Maximum Count"
-    range_start = 5
-    range_end = 38
-    default = 25
-
-
-class DWEnableBonus(Toggle):
-    """In Death Wish, add a location for completing all of a DW contract's bonuses,
-    in addition to the location for completing the DW contract normally.
-    WARNING!! Only for the brave! This option can create VERY DIFFICULT SEEDS!
-    ONLY turn this on if you know what you are doing to yourself and everyone else in the multiworld!
-    Using Peace and Tranquility to auto-complete the bonuses will NOT count!"""
-    display_name = "Shuffle Death Wish Full Completions"
-
-
-class DWAutoCompleteBonuses(DefaultOnToggle):
-    """If enabled, auto complete all bonus stamps after completing the main objective in a Death Wish.
-    This option will have no effect if bonus checks (DWEnableBonus) are turned on."""
-    display_name = "Auto Complete Bonus Stamps"
-
-
-class DWExcludeAnnoyingContracts(DefaultOnToggle):
-    """Exclude Death Wish contracts from the pool that are particularly tedious or take a long time to reach/clear.
-    Excluded Death Wishes are automatically completed as soon as they are unlocked.
-    This option currently excludes the following contracts:
-    - Vault Codes in the Wind
-    - Boss Rush
-    - Camera Tourist
-    - The Mustache Gauntlet
-    - Rift Collapse: Deep Sea
-    - Cruisin' for a Bruisin'
-    - Seal the Deal (non-excluded if goal, but the checks are still excluded)"""
-    display_name = "Exclude Annoying Death Wish Contracts"
-
-
-class DWExcludeAnnoyingBonuses(DefaultOnToggle):
-    """If Death Wish full completions are shuffled in, exclude tedious Death Wish full completions from the pool.
-    Excluded bonus Death Wishes automatically reward their bonus stamps upon completion of the main objective.
-    This option currently excludes the following bonuses:
-    - So You're Back From Outer Space
-    - Encore! Encore!
-    - Snatcher's Hit List
-    - 10 Seconds until Self-Destruct
-    - Killing Two Birds
-    - Zero Jumps
-    - Bird Sanctuary
-    - Wound-Up Windmill
-    - Vault Codes in the Wind
-    - Boss Rush
-    - Camera Tourist
-    - The Mustache Gauntlet
-    - Rift Collapse: Deep Sea
-    - Cruisin' for a Bruisin'
-    - Seal the Deal"""
-    display_name = "Exclude Annoying Death Wish Full Completions"
-
-
-class DWExcludeCandles(DefaultOnToggle):
-    """If enabled, exclude all candle Death Wishes."""
-    display_name = "Exclude Candle Death Wishes"
-
-
-class DWTimePieceRequirement(Range):
-    """How many Time Pieces that will be required to unlock Death Wish."""
-    display_name = "Death Wish Time Piece Requirement"
-    range_start = 0
-    range_end = 35
-    default = 15
-
-
-class TrapChance(Range):
-    """The chance for any junk item in the pool to be replaced by a trap."""
-    display_name = "Trap Chance"
-    range_start = 0
-    range_end = 100
-    default = 0
-
-
-class BabyTrapWeight(Range):
-    """The weight of Baby Traps in the trap pool.
-    Baby Traps place a multitude of the Conductor's grandkids into Hat Kid's hands, causing her to lose her balance."""
-    display_name = "Baby Trap Weight"
-    range_start = 0
-    range_end = 100
-    default = 40
-
-
-class LaserTrapWeight(Range):
-    """The weight of Laser Traps in the trap pool.
-    Laser Traps will spawn multiple giant lasers (from Snatcher's boss fight) at Hat Kid's location."""
-    display_name = "Laser Trap Weight"
-    range_start = 0
-    range_end = 100
-    default = 40
-
-
-class ParadeTrapWeight(Range):
-    """The weight of Parade Traps in the trap pool.
-    Parade Traps will summon multiple Express Band owls with knives that chase Hat Kid by mimicking her movement."""
-    display_name = "Parade Trap Weight"
-    range_start = 0
-    range_end = 100
-    default = 20
-
-
-@dataclass
-class AHITOptions(PerGameCommonOptions):
-    EndGoal:                  EndGoal
-    ActRandomizer:            ActRandomizer
-    ActPlando:                ActPlando
-    ActBlacklist:             ActBlacklist
-    ShuffleAlpineZiplines:    ShuffleAlpineZiplines
-    FinaleShuffle:            FinaleShuffle
-    LogicDifficulty:          LogicDifficulty
-    YarnBalancePercent:       YarnBalancePercent
-    TimePieceBalancePercent:  TimePieceBalancePercent
-    RandomizeHatOrder:        RandomizeHatOrder
-    UmbrellaLogic:            UmbrellaLogic
-    StartWithCompassBadge:    StartWithCompassBadge
-    CompassBadgeMode:         CompassBadgeMode
-    ShuffleStorybookPages:    ShuffleStorybookPages
-    ShuffleActContracts:      ShuffleActContracts
-    ShuffleSubconPaintings:   ShuffleSubconPaintings
-    NoPaintingSkips:          NoPaintingSkips
-    StartingChapter:          StartingChapter
-    CTRLogic:                 CTRLogic
-
-    EnableDLC1:               EnableDLC1
-    Tasksanity:               Tasksanity
-    TasksanityTaskStep:       TasksanityTaskStep
-    TasksanityCheckCount:     TasksanityCheckCount
-    ExcludeTour:              ExcludeTour
-    ShipShapeCustomTaskGoal:  ShipShapeCustomTaskGoal
-
-    EnableDeathWish:              EnableDeathWish
-    DWShuffle:                    DWShuffle
-    DWShuffleCountMin:            DWShuffleCountMin
-    DWShuffleCountMax:            DWShuffleCountMax
-    DeathWishOnly:                DeathWishOnly
-    DWEnableBonus:                DWEnableBonus
-    DWAutoCompleteBonuses:        DWAutoCompleteBonuses
-    DWExcludeAnnoyingContracts:   DWExcludeAnnoyingContracts
-    DWExcludeAnnoyingBonuses:     DWExcludeAnnoyingBonuses
-    DWExcludeCandles:             DWExcludeCandles
-    DWTimePieceRequirement:       DWTimePieceRequirement
-
-    EnableDLC2:               EnableDLC2
-    BaseballBat:              BaseballBat
-    MetroMinPonCost:          MetroMinPonCost
-    MetroMaxPonCost:          MetroMaxPonCost
-    NyakuzaThugMinShopItems:  NyakuzaThugMinShopItems
-    NyakuzaThugMaxShopItems:  NyakuzaThugMaxShopItems
-    NoTicketSkips:            NoTicketSkips
-
-    LowestChapterCost:        LowestChapterCost
-    HighestChapterCost:       HighestChapterCost
-    ChapterCostIncrement:     ChapterCostIncrement
-    ChapterCostMinDifference: ChapterCostMinDifference
-    MaxExtraTimePieces:       MaxExtraTimePieces
-
-    FinalChapterMinCost:          FinalChapterMinCost
-    FinalChapterMaxCost:          FinalChapterMaxCost
-
-    YarnCostMin:              YarnCostMin
-    YarnCostMax:              YarnCostMax
-    YarnAvailable:            YarnAvailable
-    MinExtraYarn:             MinExtraYarn
-    HatItems:                 HatItems
-
-    MinPonCost:               MinPonCost
-    MaxPonCost:               MaxPonCost
-    BadgeSellerMinItems:      BadgeSellerMinItems
-    BadgeSellerMaxItems:      BadgeSellerMaxItems
-
-    TrapChance:               TrapChance
-    BabyTrapWeight:           BabyTrapWeight
-    LaserTrapWeight:          LaserTrapWeight
-    ParadeTrapWeight:         ParadeTrapWeight
-
-    death_link:               DeathLink
-
-
-ahit_option_groups: Dict[str, List[Any]] = {
-    "General Options": [EndGoal, ShuffleStorybookPages, ShuffleAlpineZiplines, ShuffleSubconPaintings,
-                        ShuffleActContracts, MinPonCost, MaxPonCost, BadgeSellerMinItems, BadgeSellerMaxItems,
-                        LogicDifficulty, NoPaintingSkips, CTRLogic],
-
-    "Act Options": [ActRandomizer, StartingChapter, LowestChapterCost, HighestChapterCost,
-                    ChapterCostIncrement, ChapterCostMinDifference, FinalChapterMinCost, FinalChapterMaxCost,
-                    FinaleShuffle, ActPlando, ActBlacklist],
-
-    "Item Options": [StartWithCompassBadge, CompassBadgeMode, RandomizeHatOrder, YarnAvailable, YarnCostMin,
-                     YarnCostMax, MinExtraYarn, HatItems, UmbrellaLogic, MaxExtraTimePieces, YarnBalancePercent,
-                     TimePieceBalancePercent],
-
-    "Arctic Cruise Options": [EnableDLC1, Tasksanity, TasksanityTaskStep, TasksanityCheckCount,
-                              ShipShapeCustomTaskGoal, ExcludeTour],
-
-    "Nyakuza Metro Options": [EnableDLC2, MetroMinPonCost, MetroMaxPonCost, NyakuzaThugMinShopItems,
-                              NyakuzaThugMaxShopItems, BaseballBat, NoTicketSkips],
-
-    "Death Wish Options": [EnableDeathWish, DWTimePieceRequirement, DWShuffle, DWShuffleCountMin, DWShuffleCountMax,
-                           DWEnableBonus, DWAutoCompleteBonuses, DWExcludeAnnoyingContracts, DWExcludeAnnoyingBonuses,
-                           DWExcludeCandles, DeathWishOnly],
-
-    "Trap Options": [TrapChance, BabyTrapWeight, LaserTrapWeight, ParadeTrapWeight]
-}
-
-
-slot_data_options: List[str] = [
-    "EndGoal",
-    "ActRandomizer",
-    "ShuffleAlpineZiplines",
-    "LogicDifficulty",
-    "CTRLogic",
-    "RandomizeHatOrder",
-    "UmbrellaLogic",
-    "StartWithCompassBadge",
-    "CompassBadgeMode",
-    "ShuffleStorybookPages",
-    "ShuffleActContracts",
-    "ShuffleSubconPaintings",
-    "NoPaintingSkips",
-    "HatItems",
-
-    "EnableDLC1",
-    "Tasksanity",
-    "TasksanityTaskStep",
-    "TasksanityCheckCount",
-    "ShipShapeCustomTaskGoal",
-    "ExcludeTour",
-
-    "EnableDeathWish",
-    "DWShuffle",
-    "DeathWishOnly",
-    "DWEnableBonus",
-    "DWAutoCompleteBonuses",
-    "DWTimePieceRequirement",
-
-    "EnableDLC2",
-    "MetroMinPonCost",
-    "MetroMaxPonCost",
-    "BaseballBat",
-    "NoTicketSkips",
-
-    "MinPonCost",
-    "MaxPonCost",
-
-    "death_link",
-]

worlds/ahit/Rules.py

@@ -1,959 +0,0 @@
-from worlds.AutoWorld import CollectionState
-from worlds.generic.Rules import add_rule, set_rule
-from .Locations import location_table, zipline_unlocks, is_location_valid, contract_locations, \
-    shop_locations, event_locs
-from .Types import HatType, ChapterIndex, hat_type_to_item, Difficulty, HitType
-from BaseClasses import Location, Entrance, Region
-from typing import TYPE_CHECKING, List, Callable, Union, Dict
-from .Options import EndGoal, CTRLogic, NoTicketSkips
-
-if TYPE_CHECKING:
-    from . import HatInTimeWorld
-    
-
-act_connections = {
-    "Mafia Town - Act 2": ["Mafia Town - Act 1"],
-    "Mafia Town - Act 3": ["Mafia Town - Act 1"],
-    "Mafia Town - Act 4": ["Mafia Town - Act 2", "Mafia Town - Act 3"],
-    "Mafia Town - Act 6": ["Mafia Town - Act 4"],
-    "Mafia Town - Act 7": ["Mafia Town - Act 4"],
-    "Mafia Town - Act 5": ["Mafia Town - Act 6", "Mafia Town - Act 7"],
-
-    "Battle of the Birds - Act 2": ["Battle of the Birds - Act 1"],
-    "Battle of the Birds - Act 3": ["Battle of the Birds - Act 1"],
-    "Battle of the Birds - Act 4": ["Battle of the Birds - Act 2", "Battle of the Birds - Act 3"],
-    "Battle of the Birds - Act 5": ["Battle of the Birds - Act 2", "Battle of the Birds - Act 3"],
-    "Battle of the Birds - Finale A": ["Battle of the Birds - Act 4", "Battle of the Birds - Act 5"],
-    "Battle of the Birds - Finale B": ["Battle of the Birds - Finale A"],
-
-    "Subcon Forest - Finale": ["Subcon Forest - Act 1", "Subcon Forest - Act 2",
-                               "Subcon Forest - Act 3", "Subcon Forest - Act 4",
-                               "Subcon Forest - Act 5"],
-
-    "The Arctic Cruise - Act 2":  ["The Arctic Cruise - Act 1"],
-    "The Arctic Cruise - Finale": ["The Arctic Cruise - Act 2"],
-}
-
-
-def can_use_hat(state: CollectionState, world: "HatInTimeWorld", hat: HatType) -> bool:
-    if world.options.HatItems:
-        return state.has(hat_type_to_item[hat], world.player)
-
-    if world.hat_yarn_costs[hat] <= 0:  # this means the hat was put into starting inventory
-        return True
-
-    return state.has("Yarn", world.player, get_hat_cost(world, hat))
-
-
-def get_hat_cost(world: "HatInTimeWorld", hat: HatType) -> int:
-    cost = 0
-    for h in world.hat_craft_order:
-        cost += world.hat_yarn_costs[h]
-        if h == hat:
-            break
-
-    return cost
-
-
-def painting_logic(world: "HatInTimeWorld") -> bool:
-    return bool(world.options.ShuffleSubconPaintings)
-
-
-# -1 = Normal, 0 = Moderate, 1 = Hard, 2 = Expert
-def get_difficulty(world: "HatInTimeWorld") -> Difficulty:
-    return Difficulty(world.options.LogicDifficulty)
-
-
-def has_paintings(state: CollectionState, world: "HatInTimeWorld", count: int, allow_skip: bool = True) -> bool:
-    if not painting_logic(world):
-        return True
-
-    if not world.options.NoPaintingSkips and allow_skip:
-        # In Moderate there is a very easy trick to skip all the walls, except for the one guarding the boss arena
-        if get_difficulty(world) >= Difficulty.MODERATE:
-            return True
-
-    return state.has("Progressive Painting Unlock", world.player, count)
-
-
-def zipline_logic(world: "HatInTimeWorld") -> bool:
-    return bool(world.options.ShuffleAlpineZiplines)
-
-
-def can_use_hookshot(state: CollectionState, world: "HatInTimeWorld"):
-    return state.has("Hookshot Badge", world.player)
-
-
-def can_hit(state: CollectionState, world: "HatInTimeWorld", umbrella_only: bool = False):
-    if not world.options.UmbrellaLogic:
-        return True
-
-    return state.has("Umbrella", world.player) or not umbrella_only and can_use_hat(state, world, HatType.BREWING)
-
-
-def has_relic_combo(state: CollectionState, world: "HatInTimeWorld", relic: str) -> bool:
-    return state.has_group(relic, world.player, len(world.item_name_groups[relic]))
-
-
-def get_relic_count(state: CollectionState, world: "HatInTimeWorld", relic: str) -> int:
-    return state.count_group(relic, world.player)
-
-
-# This is used to determine if the player can clear an act that's required to unlock a Time Rift
-def can_clear_required_act(state: CollectionState, world: "HatInTimeWorld", act_entrance: str) -> bool:
-    entrance: Entrance = world.multiworld.get_entrance(act_entrance, world.player)
-    if not state.can_reach(entrance.connected_region, "Region", world.player):
-        return False
-
-    if "Free Roam" in entrance.connected_region.name:
-        return True
-
-    name: str = f"Act Completion ({entrance.connected_region.name})"
-    return world.multiworld.get_location(name, world.player).access_rule(state)
-
-
-def can_clear_alpine(state: CollectionState, world: "HatInTimeWorld") -> bool:
-    return state.has("Birdhouse Cleared", world.player) and state.has("Lava Cake Cleared", world.player) \
-            and state.has("Windmill Cleared", world.player) and state.has("Twilight Bell Cleared", world.player)
-
-
-def can_clear_metro(state: CollectionState, world: "HatInTimeWorld") -> bool:
-    return state.has("Nyakuza Intro Cleared", world.player) \
-           and state.has("Yellow Overpass Station Cleared", world.player) \
-           and state.has("Yellow Overpass Manhole Cleared", world.player) \
-           and state.has("Green Clean Station Cleared", world.player) \
-           and state.has("Green Clean Manhole Cleared", world.player) \
-           and state.has("Bluefin Tunnel Cleared", world.player) \
-           and state.has("Pink Paw Station Cleared", world.player) \
-           and state.has("Pink Paw Manhole Cleared", world.player)
-
-
-def set_rules(world: "HatInTimeWorld"):
-    # First, chapter access
-    starting_chapter = ChapterIndex(world.options.StartingChapter)
-    world.chapter_timepiece_costs[starting_chapter] = 0
-
-    # Chapter costs increase progressively. Randomly decide the chapter order, except for Finale
-    chapter_list: List[ChapterIndex] = [ChapterIndex.MAFIA, ChapterIndex.BIRDS,
-                                        ChapterIndex.SUBCON, ChapterIndex.ALPINE]
-
-    final_chapter = ChapterIndex.FINALE
-    if world.options.EndGoal == EndGoal.option_rush_hour:
-        final_chapter = ChapterIndex.METRO
-        chapter_list.append(ChapterIndex.FINALE)
-    elif world.options.EndGoal == EndGoal.option_seal_the_deal:
-        final_chapter = None
-        chapter_list.append(ChapterIndex.FINALE)
-
-    if world.is_dlc1():
-        chapter_list.append(ChapterIndex.CRUISE)
-
-    if world.is_dlc2() and final_chapter is not ChapterIndex.METRO:
-        chapter_list.append(ChapterIndex.METRO)
-
-    chapter_list.remove(starting_chapter)
-    world.random.shuffle(chapter_list)
-
-    # Make sure Alpine is unlocked before any DLC chapters are, as the Alpine door needs to be open to access them
-    if starting_chapter is not ChapterIndex.ALPINE and (world.is_dlc1() or world.is_dlc2()):
-        index1 = 69
-        index2 = 69
-        pos: int
-        lowest_index: int
-        chapter_list.remove(ChapterIndex.ALPINE)
-
-        if world.is_dlc1():
-            index1 = chapter_list.index(ChapterIndex.CRUISE)
-
-        if world.is_dlc2() and final_chapter is not ChapterIndex.METRO:
-            index2 = chapter_list.index(ChapterIndex.METRO)
-
-        lowest_index = min(index1, index2)
-        if lowest_index == 0:
-            pos = 0
-        else:
-            pos = world.random.randint(0, lowest_index)
-
-        chapter_list.insert(pos, ChapterIndex.ALPINE)
-
-    lowest_cost: int = world.options.LowestChapterCost.value
-    highest_cost: int = world.options.HighestChapterCost.value
-    cost_increment: int = world.options.ChapterCostIncrement.value
-    min_difference: int = world.options.ChapterCostMinDifference.value
-    last_cost = 0
-
-    for i, chapter in enumerate(chapter_list):
-        min_range: int = lowest_cost + (cost_increment * i)
-        if min_range >= highest_cost:
-            min_range = highest_cost-1
-
-        value: int = world.random.randint(min_range, min(highest_cost, max(lowest_cost, last_cost + cost_increment)))
-        cost = world.random.randint(value, min(value + cost_increment, highest_cost))
-        if i >= 1:
-            if last_cost + min_difference > cost:
-                cost = last_cost + min_difference
-
-        cost = min(cost, highest_cost)
-        world.chapter_timepiece_costs[chapter] = cost
-        last_cost = cost
-
-    if final_chapter is not None:
-        final_chapter_cost: int
-        if world.options.FinalChapterMinCost == world.options.FinalChapterMaxCost:
-            final_chapter_cost = world.options.FinalChapterMaxCost.value
-        else:
-            final_chapter_cost = world.random.randint(world.options.FinalChapterMinCost.value,
-                                                      world.options.FinalChapterMaxCost.value)
-
-        world.chapter_timepiece_costs[final_chapter] = final_chapter_cost
-
-    add_rule(world.multiworld.get_entrance("Telescope -> Mafia Town", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.MAFIA]))
-
-    add_rule(world.multiworld.get_entrance("Telescope -> Battle of the Birds", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.BIRDS]))
-
-    add_rule(world.multiworld.get_entrance("Telescope -> Subcon Forest", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.SUBCON]))
-
-    add_rule(world.multiworld.get_entrance("Telescope -> Alpine Skyline", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.ALPINE]))
-
-    add_rule(world.multiworld.get_entrance("Telescope -> Time's End", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.FINALE])
-             and can_use_hat(state, world, HatType.BREWING) and can_use_hat(state, world, HatType.DWELLER))
-
-    if world.is_dlc1():
-        add_rule(world.multiworld.get_entrance("Telescope -> Arctic Cruise", world.player),
-                 lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.ALPINE])
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.CRUISE]))
-
-    if world.is_dlc2():
-        add_rule(world.multiworld.get_entrance("Telescope -> Nyakuza Metro", world.player),
-                 lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.ALPINE])
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.METRO])
-                 and can_use_hat(state, world, HatType.DWELLER) and can_use_hat(state, world, HatType.ICE))
-
-    if not world.options.ActRandomizer:
-        set_default_rift_rules(world)
-
-    table = {**location_table, **event_locs}
-    for (key, data) in table.items():
-        if not is_location_valid(world, key):
-            continue
-
-        if key in contract_locations.keys():
-            continue
-
-        loc = world.multiworld.get_location(key, world.player)
-
-        for hat in data.required_hats:
-            add_rule(loc, lambda state, h=hat: can_use_hat(state, world, h))
-
-        if data.hookshot:
-            add_rule(loc, lambda state: can_use_hookshot(state, world))
-
-        if data.paintings > 0 and world.options.ShuffleSubconPaintings:
-            add_rule(loc, lambda state, paintings=data.paintings: has_paintings(state, world, paintings))
-
-        if data.hit_type is not HitType.none and world.options.UmbrellaLogic:
-            if data.hit_type == HitType.umbrella:
-                add_rule(loc, lambda state: state.has("Umbrella", world.player))
-
-            elif data.hit_type == HitType.umbrella_or_brewing:
-                add_rule(loc, lambda state: state.has("Umbrella", world.player)
-                         or can_use_hat(state, world, HatType.BREWING))
-
-            elif data.hit_type == HitType.dweller_bell:
-                add_rule(loc, lambda state: state.has("Umbrella", world.player)
-                         or can_use_hat(state, world, HatType.BREWING)
-                         or can_use_hat(state, world, HatType.DWELLER))
-
-        for misc in data.misc_required:
-            add_rule(loc, lambda state, item=misc: state.has(item, world.player))
-
-    set_specific_rules(world)
-
-    # Putting all of this here, so it doesn't get overridden by anything
-    # Illness starts the player past the intro
-    alpine_entrance = world.multiworld.get_entrance("AFR -> Alpine Skyline Area", world.player)
-    add_rule(alpine_entrance, lambda state: can_use_hookshot(state, world))
-    if world.options.UmbrellaLogic:
-        add_rule(alpine_entrance, lambda state: state.has("Umbrella", world.player))
-
-    if zipline_logic(world):
-        add_rule(world.multiworld.get_entrance("-> The Birdhouse", world.player),
-                 lambda state: state.has("Zipline Unlock - The Birdhouse Path", world.player))
-
-        add_rule(world.multiworld.get_entrance("-> The Lava Cake", world.player),
-                 lambda state: state.has("Zipline Unlock - The Lava Cake Path", world.player))
-
-        add_rule(world.multiworld.get_entrance("-> The Windmill", world.player),
-                 lambda state: state.has("Zipline Unlock - The Windmill Path", world.player))
-
-        add_rule(world.multiworld.get_entrance("-> The Twilight Bell", world.player),
-                 lambda state: state.has("Zipline Unlock - The Twilight Bell Path", world.player))
-
-        add_rule(world.multiworld.get_location("Act Completion (The Illness has Spread)", world.player),
-                 lambda state: state.has("Zipline Unlock - The Birdhouse Path", world.player)
-                 and state.has("Zipline Unlock - The Lava Cake Path", world.player)
-                 and state.has("Zipline Unlock - The Windmill Path", world.player))
-
-    if zipline_logic(world):
-        for (loc, zipline) in zipline_unlocks.items():
-            add_rule(world.multiworld.get_location(loc, world.player),
-                     lambda state, z=zipline: state.has(z, world.player))
-
-    dummy_entrances: List[Entrance] = []
-      
-    for (key, acts) in act_connections.items():
-        if "Arctic Cruise" in key and not world.is_dlc1():
-            continue
-
-        entrance: Entrance = world.multiworld.get_entrance(key, world.player)
-        region: Region = entrance.connected_region
-        access_rules: List[Callable[[CollectionState], bool]] = []
-        dummy_entrances.append(entrance)
-
-        # Entrances to this act that we have to set access_rules on
-        entrances: List[Entrance] = []
-
-        for i, act in enumerate(acts, start=1):
-            act_entrance: Entrance = world.multiworld.get_entrance(act, world.player)
-            access_rules.append(act_entrance.access_rule)
-            required_region = act_entrance.connected_region
-            name: str = f"{key}: Connection {i}"
-            new_entrance: Entrance = required_region.connect(region, name)
-            entrances.append(new_entrance)
-
-            # Copy access rules from act completions
-            if "Free Roam" not in required_region.name:
-                rule: Callable[[CollectionState], bool]
-                name = f"Act Completion ({required_region.name})"
-                rule = world.multiworld.get_location(name, world.player).access_rule
-                access_rules.append(rule)
-
-        for e in entrances:
-            for rules in access_rules:
-                add_rule(e, rules)
-
-    for e in dummy_entrances:
-        set_rule(e, lambda state: False)
-
-    set_event_rules(world)
-
-    if world.options.EndGoal == EndGoal.option_finale:
-        world.multiworld.completion_condition[world.player] = lambda state: state.has("Time Piece Cluster", world.player)
-    elif world.options.EndGoal == EndGoal.option_rush_hour:
-        world.multiworld.completion_condition[world.player] = lambda state: state.has("Rush Hour Cleared", world.player)
-
-
-def set_specific_rules(world: "HatInTimeWorld"):
-    add_rule(world.multiworld.get_location("Mafia Boss Shop Item", world.player),
-             lambda state: state.has("Time Piece", world.player, 12)
-             and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.BIRDS]))
-
-    set_mafia_town_rules(world)
-    set_botb_rules(world)
-    set_subcon_rules(world)
-    set_alps_rules(world)
-
-    if world.is_dlc1():
-        set_dlc1_rules(world)
-
-    if world.is_dlc2():
-        set_dlc2_rules(world)
-
-    difficulty: Difficulty = get_difficulty(world)
-
-    if difficulty >= Difficulty.MODERATE:
-        set_moderate_rules(world)
-
-    if difficulty >= Difficulty.HARD:
-        set_hard_rules(world)
-
-    if difficulty >= Difficulty.EXPERT:
-        set_expert_rules(world)
-
-
-def set_moderate_rules(world: "HatInTimeWorld"):
-    # Moderate: Gallery without Brewing Hat
-    set_rule(world.multiworld.get_location("Act Completion (Time Rift - Gallery)", world.player), lambda state: True)
-
-    # Moderate: Above Boats via Ice Hat Sliding
-    add_rule(world.multiworld.get_location("Mafia Town - Above Boats", world.player),
-             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)
-
-    # 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:
-        set_rule(loc, lambda state: has_paintings(state, world, 1))
-
-    # Moderate: Vanessa Manor with nothing
-    for loc in world.multiworld.get_region("Queen Vanessa's Manor", world.player).locations:
-        set_rule(loc, lambda state: has_paintings(state, world, 1))
-
-    set_rule(world.multiworld.get_location("Subcon Forest - Manor Rooftop", world.player),
-             lambda state: has_paintings(state, world, 1))
-
-    # Moderate: Village Time Rift with nothing IF umbrella logic is off
-    if not world.options.UmbrellaLogic:
-        set_rule(world.multiworld.get_location("Act Completion (Time Rift - Village)", world.player), lambda state: True)
-
-    # Moderate: get to Birdhouse/Yellow Band Hills without Brewing Hat
-    set_rule(world.multiworld.get_entrance("-> The Birdhouse", world.player),
-             lambda state: can_use_hookshot(state, world))
-    set_rule(world.multiworld.get_location("Alpine Skyline - Yellow Band Hills", world.player),
-             lambda state: can_use_hookshot(state, world))
-
-    # Moderate: The Birdhouse - Dweller Platforms Relic with only Birdhouse access
-    set_rule(world.multiworld.get_location("Alpine Skyline - The Birdhouse: Dweller Platforms Relic", world.player),
-             lambda state: True)
-
-    # Moderate: Twilight Path without Dweller Mask
-    set_rule(world.multiworld.get_location("Alpine Skyline - The Twilight Path", world.player), lambda state: True)
-
-    # Moderate: Mystifying Time Mesa time trial without hats
-    set_rule(world.multiworld.get_location("Alpine Skyline - Mystifying Time Mesa: Zipline", world.player),
-             lambda state: can_use_hookshot(state, world))
-
-    # Moderate: Goat Refinery from TIHS with Sprint only
-    add_rule(world.multiworld.get_location("Alpine Skyline - Goat Refinery", world.player),
-             lambda state: state.has("TIHS Access", world.player)
-             and can_use_hat(state, world, HatType.SPRINT), "or")
-
-    # Moderate: Finale Telescope with only Ice Hat
-    add_rule(world.multiworld.get_entrance("Telescope -> Time's End", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.FINALE])
-             and can_use_hat(state, world, HatType.ICE), "or")
-
-    # Moderate: Finale without Hookshot
-    set_rule(world.multiworld.get_location("Act Completion (The Finale)", world.player),
-             lambda state: can_use_hat(state, world, HatType.DWELLER))
-
-    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)
-
-        # Moderate: clear Deep Sea without Ice Hat
-        set_rule(world.multiworld.get_location("Act Completion (Time Rift - Deep Sea)", world.player),
-                 lambda state: can_use_hookshot(state, world) and can_use_hat(state, world, HatType.DWELLER))
-
-    # There is a glitched fall damage volume near the Yellow Overpass time piece that warps the player to Pink Paw.
-    # Yellow Overpass time piece can also be reached without Hookshot quite easily.
-    if world.is_dlc2():
-        # No Hookshot
-        set_rule(world.multiworld.get_location("Act Completion (Yellow Overpass Station)", world.player),
-                 lambda state: True)
-
-        # No Dweller, Hookshot, or Time Stop for these
-        set_rule(world.multiworld.get_location("Pink Paw Station - Cat Vacuum", world.player), lambda state: True)
-        set_rule(world.multiworld.get_location("Pink Paw Station - Behind Fan", world.player), lambda state: True)
-        set_rule(world.multiworld.get_location("Pink Paw Station - Pink Ticket Booth", world.player), lambda state: True)
-        set_rule(world.multiworld.get_location("Act Completion (Pink Paw Station)", world.player), lambda state: True)
-        for key in shop_locations.keys():
-            if "Pink Paw Station Thug" in key and is_location_valid(world, key):
-                set_rule(world.multiworld.get_location(key, world.player), lambda state: True)
-
-        # Moderate: clear Rush Hour without Hookshot
-        set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
-                 lambda state: state.has("Metro Ticket - Pink", world.player)
-                 and state.has("Metro Ticket - Yellow", world.player)
-                 and state.has("Metro Ticket - Blue", world.player)
-                 and can_use_hat(state, world, HatType.ICE)
-                 and can_use_hat(state, world, HatType.BREWING))
-
-        # Moderate: Bluefin Tunnel + Pink Paw Station without tickets
-        if not world.options.NoTicketSkips:
-            set_rule(world.multiworld.get_entrance("-> Pink Paw Station", world.player), lambda state: True)
-            set_rule(world.multiworld.get_entrance("-> Bluefin Tunnel", world.player), lambda state: True)
-
-
-def set_hard_rules(world: "HatInTimeWorld"):
-    # Hard: clear Time Rift - The Twilight Bell with Sprint+Scooter only
-    add_rule(world.multiworld.get_location("Act Completion (Time Rift - The Twilight Bell)", world.player),
-             lambda state: can_use_hat(state, world, HatType.SPRINT)
-             and state.has("Scooter Badge", world.player), "or")
-
-    # No Dweller Mask required
-    set_rule(world.multiworld.get_location("Subcon Forest - Dweller Floating Rocks", world.player),
-             lambda state: has_paintings(state, world, 3))
-    set_rule(world.multiworld.get_location("Subcon Forest - Dweller Platforming Tree B", world.player),
-             lambda state: has_paintings(state, world, 3))
-
-    # Cherry bridge over boss arena gap (painting still expected)
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: has_paintings(state, world, 1, False) or state.has("YCHE Access", world.player))
-
-    set_rule(world.multiworld.get_location("Subcon Forest - Noose Treehouse", world.player),
-             lambda state: has_paintings(state, world, 2, True))
-    set_rule(world.multiworld.get_location("Subcon Forest - Long Tree Climb Chest", world.player),
-             lambda state: has_paintings(state, world, 2, True))
-    set_rule(world.multiworld.get_location("Subcon Forest - Tall Tree Hookshot Swing", world.player),
-             lambda state: has_paintings(state, world, 3, True))
-
-    # SDJ
-    add_rule(world.multiworld.get_location("Subcon Forest - Long Tree Climb Chest", world.player),
-             lambda state: can_use_hat(state, world, HatType.SPRINT) and has_paintings(state, world, 2), "or")
-
-    add_rule(world.multiworld.get_location("Act Completion (Time Rift - Curly Tail Trail)", world.player),
-             lambda state: can_use_hat(state, world, HatType.SPRINT), "or")
-
-    # Hard: Goat Refinery from TIHS with nothing
-    add_rule(world.multiworld.get_location("Alpine Skyline - Goat Refinery", world.player),
-             lambda state: state.has("TIHS Access", world.player), "or")
-
-    if world.is_dlc1():
-        # Hard: clear Deep Sea without Dweller Mask
-        set_rule(world.multiworld.get_location("Act Completion (Time Rift - Deep Sea)", world.player),
-                 lambda state: can_use_hookshot(state, world))
-
-    if world.is_dlc2():
-        # Hard: clear Green Clean Manhole without Dweller Mask
-        set_rule(world.multiworld.get_location("Act Completion (Green Clean Manhole)", world.player),
-                 lambda state: can_use_hat(state, world, HatType.ICE))
-
-        # Hard: clear Rush Hour with Brewing Hat only
-        if world.options.NoTicketSkips is not NoTicketSkips.option_true:
-            set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
-                     lambda state: can_use_hat(state, world, HatType.BREWING))
-        else:
-            set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
-                     lambda state: can_use_hat(state, world, HatType.BREWING)
-                     and state.has("Metro Ticket - Yellow", world.player)
-                     and state.has("Metro Ticket - Blue", world.player)
-                     and state.has("Metro Ticket - Pink", world.player))
-
-
-def set_expert_rules(world: "HatInTimeWorld"):
-    # Finale Telescope with no hats
-    set_rule(world.multiworld.get_entrance("Telescope -> Time's End", world.player),
-             lambda state: state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.FINALE]))
-
-    # Expert: Mafia Town - Above Boats, Top of Lighthouse, and Hot Air Balloon with nothing
-    set_rule(world.multiworld.get_location("Mafia Town - Above Boats", world.player), lambda state: True)
-    set_rule(world.multiworld.get_location("Mafia Town - Top of Lighthouse", world.player), lambda state: True)
-    set_rule(world.multiworld.get_location("Mafia Town - Hot Air Balloon", world.player), lambda state: True)
-
-    # Expert: Clear Dead Bird Studio with nothing
-    for loc in world.multiworld.get_region("Dead Bird Studio - Post Elevator Area", world.player).locations:
-        set_rule(loc, lambda state: True)
-
-    set_rule(world.multiworld.get_location("Act Completion (Dead Bird Studio)", world.player), lambda state: True)
-
-    # Expert: Clear Dead Bird Studio Basement without Hookshot
-    for loc in world.multiworld.get_region("Dead Bird Studio Basement", world.player).locations:
-        set_rule(loc, lambda state: True)
-
-    # Expert: get to and clear Twilight Bell without Dweller Mask.
-    # Dweller Mask OR Sprint Hat OR Brewing Hat OR Time Stop + Umbrella required to complete act.
-    add_rule(world.multiworld.get_entrance("-> The Twilight Bell", world.player),
-             lambda state: can_use_hookshot(state, world), "or")
-
-    add_rule(world.multiworld.get_location("Act Completion (The Twilight Bell)", world.player),
-             lambda state: can_use_hat(state, world, HatType.BREWING)
-             or can_use_hat(state, world, HatType.DWELLER)
-             or can_use_hat(state, world, HatType.SPRINT)
-             or (can_use_hat(state, world, HatType.TIME_STOP) and state.has("Umbrella", world.player)))
-
-    # Expert: Time Rift - Curly Tail Trail with nothing
-    # Time Rift - Twilight Bell and Time Rift - Village with nothing
-    set_rule(world.multiworld.get_location("Act Completion (Time Rift - Curly Tail Trail)", world.player),
-             lambda state: True)
-
-    set_rule(world.multiworld.get_location("Act Completion (Time Rift - Village)", world.player), lambda state: True)
-    set_rule(world.multiworld.get_location("Act Completion (Time Rift - The Twilight Bell)", world.player),
-             lambda state: True)
-
-    # Expert: Cherry Hovering
-    subcon_area = world.multiworld.get_region("Subcon Forest Area", world.player)
-    yche = world.multiworld.get_region("Your Contract has Expired", world.player)
-    entrance = yche.connect(subcon_area, "Subcon Forest Entrance YCHE")
-
-    if world.options.NoPaintingSkips:
-        add_rule(entrance, lambda state: has_paintings(state, world, 1))
-
-    set_rule(world.multiworld.get_location("Act Completion (Toilet of Doom)", world.player),
-             lambda state: can_use_hookshot(state, world) and can_hit(state, world)
-             and has_paintings(state, world, 1, True))
-
-    # Set painting rules only. Skipping paintings is determined in has_paintings
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: has_paintings(state, world, 1, True))
-    set_rule(world.multiworld.get_location("Subcon Forest - Magnet Badge Bush", world.player),
-             lambda state: has_paintings(state, world, 3, True))
-
-    # You can cherry hover to Snatcher's post-fight cutscene, which completes the level without having to fight him
-    subcon_area.connect(yche, "Snatcher Hover")
-    set_rule(world.multiworld.get_location("Act Completion (Your Contract has Expired)", world.player),
-             lambda state: True)
-
-    if world.is_dlc2():
-        # Expert: clear Rush Hour with nothing
-        if not world.options.NoTicketSkips:
-            set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player), lambda state: True)
-        else:
-            set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
-                     lambda state: state.has("Metro Ticket - Yellow", world.player)
-                     and state.has("Metro Ticket - Blue", world.player)
-                     and state.has("Metro Ticket - Pink", world.player))
-
-        # Expert: Yellow/Green Manhole with nothing using a Boop Clip
-        set_rule(world.multiworld.get_location("Act Completion (Yellow Overpass Manhole)", world.player),
-                 lambda state: True)
-        set_rule(world.multiworld.get_location("Act Completion (Green Clean Manhole)", world.player),
-                 lambda state: True)
-
-
-def set_mafia_town_rules(world: "HatInTimeWorld"):
-    add_rule(world.multiworld.get_location("Mafia Town - Behind HQ Chest", world.player),
-             lambda state: state.can_reach("Act Completion (Heating Up Mafia Town)", "Location", world.player)
-             or state.can_reach("Down with the Mafia!", "Region", world.player)
-             or state.can_reach("Cheating the Race", "Region", world.player)
-             or state.can_reach("The Golden Vault", "Region", world.player))
-
-    # Old guys don't appear in SCFOS
-    add_rule(world.multiworld.get_location("Mafia Town - Old Man (Steel Beams)", world.player),
-             lambda state: state.can_reach("Welcome to Mafia Town", "Region", world.player)
-             or state.can_reach("Barrel Battle", "Region", world.player)
-             or state.can_reach("Cheating the Race", "Region", world.player)
-             or state.can_reach("The Golden Vault", "Region", world.player)
-             or state.can_reach("Down with the Mafia!", "Region", world.player))
-
-    add_rule(world.multiworld.get_location("Mafia Town - Old Man (Seaside Spaghetti)", world.player),
-             lambda state: state.can_reach("Welcome to Mafia Town", "Region", world.player)
-             or state.can_reach("Barrel Battle", "Region", world.player)
-             or state.can_reach("Cheating the Race", "Region", world.player)
-             or state.can_reach("The Golden Vault", "Region", world.player)
-             or state.can_reach("Down with the Mafia!", "Region", world.player))
-
-    # Only available outside She Came from Outer Space
-    add_rule(world.multiworld.get_location("Mafia Town - Mafia Geek Platform", world.player),
-             lambda state: state.can_reach("Welcome to Mafia Town", "Region", world.player)
-             or state.can_reach("Barrel Battle", "Region", world.player)
-             or state.can_reach("Down with the Mafia!", "Region", world.player)
-             or state.can_reach("Cheating the Race", "Region", world.player)
-             or state.can_reach("Heating Up Mafia Town", "Region", world.player)
-             or state.can_reach("The Golden Vault", "Region", world.player))
-
-    # Only available outside Down with the Mafia! (for some reason)
-    add_rule(world.multiworld.get_location("Mafia Town - On Scaffolding", world.player),
-             lambda state: state.can_reach("Welcome to Mafia Town", "Region", world.player)
-             or state.can_reach("Barrel Battle", "Region", world.player)
-             or state.can_reach("She Came from Outer Space", "Region", world.player)
-             or state.can_reach("Cheating the Race", "Region", world.player)
-             or state.can_reach("Heating Up Mafia Town", "Region", world.player)
-             or state.can_reach("The Golden Vault", "Region", world.player))
-
-    # For some reason, the brewing crate is removed in HUMT
-    add_rule(world.multiworld.get_location("Mafia Town - Secret Cave", world.player),
-             lambda state: state.has("HUMT Access", world.player), "or")
-
-    # Can bounce across the lava to get this without Hookshot (need to die though)
-    add_rule(world.multiworld.get_location("Mafia Town - Above Boats", world.player),
-             lambda state: state.has("HUMT Access", world.player), "or")
-
-    if world.options.CTRLogic == CTRLogic.option_nothing:
-        set_rule(world.multiworld.get_location("Act Completion (Cheating the Race)", world.player), lambda state: True)
-    elif world.options.CTRLogic == CTRLogic.option_sprint:
-        add_rule(world.multiworld.get_location("Act Completion (Cheating the Race)", world.player),
-                 lambda state: can_use_hat(state, world, HatType.SPRINT), "or")
-    elif world.options.CTRLogic == CTRLogic.option_scooter:
-        add_rule(world.multiworld.get_location("Act Completion (Cheating the Race)", world.player),
-                 lambda state: can_use_hat(state, world, HatType.SPRINT)
-                 and state.has("Scooter Badge", world.player), "or")
-
-
-def set_botb_rules(world: "HatInTimeWorld"):
-    if not world.options.UmbrellaLogic and get_difficulty(world) < Difficulty.MODERATE:
-        set_rule(world.multiworld.get_location("Dead Bird Studio - DJ Grooves Sign Chest", world.player),
-                 lambda state: state.has("Umbrella", world.player) or can_use_hat(state, world, HatType.BREWING))
-        set_rule(world.multiworld.get_location("Dead Bird Studio - Tepee Chest", world.player),
-                 lambda state: state.has("Umbrella", world.player) or can_use_hat(state, world, HatType.BREWING))
-        set_rule(world.multiworld.get_location("Dead Bird Studio - Conductor Chest", world.player),
-                 lambda state: state.has("Umbrella", world.player) or can_use_hat(state, world, HatType.BREWING))
-        set_rule(world.multiworld.get_location("Act Completion (Dead Bird Studio)", world.player),
-                 lambda state: state.has("Umbrella", world.player) or can_use_hat(state, world, HatType.BREWING))
-
-
-def set_subcon_rules(world: "HatInTimeWorld"):
-    set_rule(world.multiworld.get_location("Act Completion (Time Rift - Village)", world.player),
-             lambda state: can_use_hat(state, world, HatType.BREWING) or state.has("Umbrella", world.player)
-             or can_use_hat(state, world, HatType.DWELLER))
-
-    # You can't skip over the boss arena wall without cherry hover, so these two need to be set this way
-    set_rule(world.multiworld.get_location("Subcon Forest - Boss Arena Chest", world.player),
-             lambda state: state.has("TOD Access", world.player) and can_use_hookshot(state, world)
-             and has_paintings(state, world, 1, False) or state.has("YCHE Access", world.player))
-
-    # The painting wall can't be skipped without cherry hover, which is Expert
-    set_rule(world.multiworld.get_location("Act Completion (Toilet of Doom)", world.player),
-             lambda state: can_use_hookshot(state, world) and can_hit(state, world)
-             and has_paintings(state, world, 1, False))
-
-    add_rule(world.multiworld.get_entrance("Subcon Forest - Act 2", world.player),
-             lambda state: state.has("Snatcher's Contract - The Subcon Well", world.player))
-
-    add_rule(world.multiworld.get_entrance("Subcon Forest - Act 3", world.player),
-             lambda state: state.has("Snatcher's Contract - Toilet of Doom", world.player))
-
-    add_rule(world.multiworld.get_entrance("Subcon Forest - Act 4", world.player),
-             lambda state: state.has("Snatcher's Contract - Queen Vanessa's Manor", world.player))
-
-    add_rule(world.multiworld.get_entrance("Subcon Forest - Act 5", world.player),
-             lambda state: state.has("Snatcher's Contract - Mail Delivery Service", world.player))
-
-    if painting_logic(world):
-        add_rule(world.multiworld.get_location("Act Completion (Contractual Obligations)", world.player),
-                 lambda state: has_paintings(state, world, 1, False))
-
-
-def set_alps_rules(world: "HatInTimeWorld"):
-    add_rule(world.multiworld.get_entrance("-> The Birdhouse", world.player),
-             lambda state: can_use_hookshot(state, world) and can_use_hat(state, world, HatType.BREWING))
-
-    add_rule(world.multiworld.get_entrance("-> The Lava Cake", world.player),
-             lambda state: can_use_hookshot(state, world))
-
-    add_rule(world.multiworld.get_entrance("-> The Windmill", world.player),
-             lambda state: can_use_hookshot(state, world))
-
-    add_rule(world.multiworld.get_entrance("-> The Twilight Bell", world.player),
-             lambda state: can_use_hookshot(state, world) and can_use_hat(state, world, HatType.DWELLER))
-
-    add_rule(world.multiworld.get_location("Alpine Skyline - Mystifying Time Mesa: Zipline", world.player),
-             lambda state: can_use_hat(state, world, HatType.SPRINT) or can_use_hat(state, world, HatType.TIME_STOP))
-
-    add_rule(world.multiworld.get_entrance("Alpine Skyline - Finale", world.player),
-             lambda state: can_clear_alpine(state, world))
-
-    add_rule(world.multiworld.get_location("Alpine Skyline - Goat Refinery", world.player),
-             lambda state: state.has("AFR Access", world.player)
-             and can_use_hookshot(state, world)
-             and can_hit(state, world, True))
-
-
-def set_dlc1_rules(world: "HatInTimeWorld"):
-    add_rule(world.multiworld.get_entrance("Cruise Ship Entrance BV", world.player),
-             lambda state: can_use_hookshot(state, world))
-
-    # This particular item isn't present in Act 3 for some reason, yes in vanilla too
-    add_rule(world.multiworld.get_location("The Arctic Cruise - Toilet", world.player),
-             lambda state: state.can_reach("Bon Voyage!", "Region", world.player)
-             or state.can_reach("Ship Shape", "Region", world.player))
-
-
-def set_dlc2_rules(world: "HatInTimeWorld"):
-    add_rule(world.multiworld.get_entrance("-> Bluefin Tunnel", world.player),
-             lambda state: state.has("Metro Ticket - Green", world.player)
-             or state.has("Metro Ticket - Blue", world.player))
-
-    add_rule(world.multiworld.get_entrance("-> Pink Paw Station", world.player),
-             lambda state: state.has("Metro Ticket - Pink", world.player)
-             or state.has("Metro Ticket - Yellow", world.player) and state.has("Metro Ticket - Blue", world.player))
-
-    add_rule(world.multiworld.get_entrance("Nyakuza Metro - Finale", world.player),
-             lambda state: can_clear_metro(state, world))
-
-    add_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
-             lambda state: state.has("Metro Ticket - Yellow", world.player)
-             and state.has("Metro Ticket - Blue", world.player)
-             and state.has("Metro Ticket - Pink", world.player))
-
-    for key in shop_locations.keys():
-        if "Green Clean Station Thug B" in key and is_location_valid(world, key):
-            add_rule(world.multiworld.get_location(key, world.player),
-                     lambda state: state.has("Metro Ticket - Yellow", world.player), "or")
-
-
-def reg_act_connection(world: "HatInTimeWorld", region: Union[str, Region], unlocked_entrance: Union[str, Entrance]):
-    reg: Region
-    entrance: Entrance
-    if isinstance(region, str):
-        reg = world.multiworld.get_region(region, world.player)
-    else:
-        reg = region
-
-    if isinstance(unlocked_entrance, str):
-        entrance = world.multiworld.get_entrance(unlocked_entrance, world.player)
-    else:
-        entrance = unlocked_entrance
-
-    world.multiworld.register_indirect_condition(reg, entrance)
-
-
-# See randomize_act_entrances in Regions.py
-# Called before set_rules
-def set_rift_rules(world: "HatInTimeWorld", regions: Dict[str, Region]):
-
-    # This is accessing the regions in place of these time rifts, so we can set the rules on all the entrances.
-    for entrance in regions["Time Rift - Gallery"].entrances:
-        add_rule(entrance, lambda state: can_use_hat(state, world, HatType.BREWING)
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.BIRDS]))
-
-    for entrance in regions["Time Rift - The Lab"].entrances:
-        add_rule(entrance, lambda state: can_use_hat(state, world, HatType.DWELLER)
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.ALPINE]))
-
-    for entrance in regions["Time Rift - Sewers"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Mafia Town - Act 4"))
-        reg_act_connection(world, world.multiworld.get_entrance("Mafia Town - Act 4",
-                                                                world.player).connected_region, entrance)
-
-    for entrance in regions["Time Rift - Bazaar"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Mafia Town - Act 6"))
-        reg_act_connection(world, world.multiworld.get_entrance("Mafia Town - Act 6",
-                                                                world.player).connected_region, entrance)
-
-    for entrance in regions["Time Rift - Mafia of Cooks"].entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "Burger"))
-
-    for entrance in regions["Time Rift - The Owl Express"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 2"))
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 3"))
-        reg_act_connection(world, world.multiworld.get_entrance("Battle of the Birds - Act 2",
-                                                                world.player).connected_region, entrance)
-        reg_act_connection(world, world.multiworld.get_entrance("Battle of the Birds - Act 3",
-                                                                world.player).connected_region, entrance)
-
-    for entrance in regions["Time Rift - The Moon"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 4"))
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 5"))
-        reg_act_connection(world, world.multiworld.get_entrance("Battle of the Birds - Act 4",
-                                                                world.player).connected_region, entrance)
-        reg_act_connection(world, world.multiworld.get_entrance("Battle of the Birds - Act 5",
-                                                                world.player).connected_region, entrance)
-
-    for entrance in regions["Time Rift - Dead Bird Studio"].entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "Train"))
-
-    for entrance in regions["Time Rift - Pipe"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 2"))
-        reg_act_connection(world, world.multiworld.get_entrance("Subcon Forest - Act 2",
-                                                                world.player).connected_region, entrance)
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 2))
-
-    for entrance in regions["Time Rift - Village"].entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 4"))
-        reg_act_connection(world, world.multiworld.get_entrance("Subcon Forest - Act 4",
-                                                                world.player).connected_region, entrance)
-
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 2))
-
-    for entrance in regions["Time Rift - Sleepy Subcon"].entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "UFO"))
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 3))
-
-    for entrance in regions["Time Rift - Curly Tail Trail"].entrances:
-        add_rule(entrance, lambda state: state.has("Windmill Cleared", world.player))
-
-    for entrance in regions["Time Rift - The Twilight Bell"].entrances:
-        add_rule(entrance, lambda state: state.has("Twilight Bell Cleared", world.player))
-
-    for entrance in regions["Time Rift - Alpine Skyline"].entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "Crayon"))
-
-    if world.is_dlc1():
-        for entrance in regions["Time Rift - Balcony"].entrances:
-            add_rule(entrance, lambda state: can_clear_required_act(state, world, "The Arctic Cruise - Finale"))
-
-        for entrance in regions["Time Rift - Deep Sea"].entrances:
-            add_rule(entrance, lambda state: has_relic_combo(state, world, "Cake"))
-
-    if world.is_dlc2():
-        for entrance in regions["Time Rift - Rumbi Factory"].entrances:
-            add_rule(entrance, lambda state: has_relic_combo(state, world, "Necklace"))
-
-
-# Basically the same as above, but without the need of the dict since we are just setting defaults
-# Called if Act Rando is disabled
-def set_default_rift_rules(world: "HatInTimeWorld"):
-
-    for entrance in world.multiworld.get_region("Time Rift - Gallery", world.player).entrances:
-        add_rule(entrance, lambda state: can_use_hat(state, world, HatType.BREWING)
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.BIRDS]))
-
-    for entrance in world.multiworld.get_region("Time Rift - The Lab", world.player).entrances:
-        add_rule(entrance, lambda state: can_use_hat(state, world, HatType.DWELLER)
-                 and state.has("Time Piece", world.player, world.chapter_timepiece_costs[ChapterIndex.ALPINE]))
-
-    for entrance in world.multiworld.get_region("Time Rift - Sewers", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Mafia Town - Act 4"))
-        reg_act_connection(world, "Down with the Mafia!", entrance.name)
-
-    for entrance in world.multiworld.get_region("Time Rift - Bazaar", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Mafia Town - Act 6"))
-        reg_act_connection(world, "Heating Up Mafia Town", entrance.name)
-
-    for entrance in world.multiworld.get_region("Time Rift - Mafia of Cooks", world.player).entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "Burger"))
-
-    for entrance in world.multiworld.get_region("Time Rift - The Owl Express", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 2"))
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 3"))
-        reg_act_connection(world, "Murder on the Owl Express", entrance.name)
-        reg_act_connection(world, "Picture Perfect", entrance.name)
-
-    for entrance in world.multiworld.get_region("Time Rift - The Moon", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 4"))
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Battle of the Birds - Act 5"))
-        reg_act_connection(world, "Train Rush", entrance.name)
-        reg_act_connection(world, "The Big Parade", entrance.name)
-
-    for entrance in world.multiworld.get_region("Time Rift - Dead Bird Studio", world.player).entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "Train"))
-
-    for entrance in world.multiworld.get_region("Time Rift - Pipe", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 2"))
-        reg_act_connection(world, "The Subcon Well", entrance.name)
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 2))
-
-    for entrance in world.multiworld.get_region("Time Rift - Village", world.player).entrances:
-        add_rule(entrance, lambda state: can_clear_required_act(state, world, "Subcon Forest - Act 4"))
-        reg_act_connection(world, "Queen Vanessa's Manor", entrance.name)
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 2))
-
-    for entrance in world.multiworld.get_region("Time Rift - Sleepy Subcon", world.player).entrances:
-        add_rule(entrance, lambda state: has_relic_combo(state, world, "UFO"))
-        if painting_logic(world):
-            add_rule(entrance, lambda state: has_paintings(state, world, 3))
-
-    for entrance in world.multiworld.get_region("Time Rift - Curly Tail Trail", world.player).entrances:
-        add_rule(entrance, lambda state: state.has("Windmill Cleared", world.player))
-
-    for entrance in world.multiworld.get_region("Time Rift - The Twilight Bell", world.player).entrances:
-        add_rule(entrance, lambda state: state.has("Twilight Bell Cleared", world.player))
-
-    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 world.is_dlc1():
-        for entrance in world.multiworld.get_region("Time Rift - Balcony", world.player).entrances:
-            add_rule(entrance, lambda state: can_clear_required_act(state, world, "The Arctic Cruise - Finale"))
-
-        for entrance in world.multiworld.get_region("Time Rift - Deep Sea", world.player).entrances:
-            add_rule(entrance, lambda state: has_relic_combo(state, world, "Cake"))
-
-    if world.is_dlc2():
-        for entrance in world.multiworld.get_region("Time Rift - Rumbi Factory", world.player).entrances:
-            add_rule(entrance, lambda state: has_relic_combo(state, world, "Necklace"))
-
-
-def set_event_rules(world: "HatInTimeWorld"):
-    for (name, data) in event_locs.items():
-        if not is_location_valid(world, name):
-            continue
-
-        event: Location = world.multiworld.get_location(name, world.player)
-
-        if data.act_event:
-            add_rule(event, world.multiworld.get_location(f"Act Completion ({data.region})", world.player).access_rule)

worlds/ahit/Types.py

@@ -1,86 +0,0 @@
-from enum import IntEnum, IntFlag
-from typing import NamedTuple, Optional, List
-from BaseClasses import Location, Item, ItemClassification
-
-
-class HatInTimeLocation(Location):
-    game = "A Hat in Time"
-
-
-class HatInTimeItem(Item):
-    game = "A Hat in Time"
-
-
-class HatType(IntEnum):
-    SPRINT = 0
-    BREWING = 1
-    ICE = 2
-    DWELLER = 3
-    TIME_STOP = 4
-
-
-class HitType(IntEnum):
-    none = 0
-    umbrella = 1
-    umbrella_or_brewing = 2
-    dweller_bell = 3
-
-
-class HatDLC(IntFlag):
-    none = 0b000
-    dlc1 = 0b001
-    dlc2 = 0b010
-    death_wish = 0b100
-    dlc1_dw = 0b101
-    dlc2_dw = 0b110
-
-
-class ChapterIndex(IntEnum):
-    SPACESHIP = 0
-    MAFIA = 1
-    BIRDS = 2
-    SUBCON = 3
-    ALPINE = 4
-    FINALE = 5
-    CRUISE = 6
-    METRO = 7
-
-
-class Difficulty(IntEnum):
-    NORMAL = -1
-    MODERATE = 0
-    HARD = 1
-    EXPERT = 2
-
-
-class LocData(NamedTuple):
-    id: int = 0
-    region: str = ""
-    required_hats: List[HatType] = []
-    hookshot: bool = False
-    dlc_flags: HatDLC = HatDLC.none
-    paintings: int = 0  # Paintings required for Subcon painting shuffle
-    misc_required: List[str] = []
-
-    # For UmbrellaLogic setting only.
-    hit_type: HitType = HitType.none
-
-    # Other
-    act_event: bool = False  # Only used for event locations. Copy access rule from act completion
-    nyakuza_thug: str = ""  # Name of Nyakuza thug NPC (for metro shops)
-    snatcher_coin: str = ""  # Only for Snatcher Coin event locations, name of the Snatcher Coin item
-
-
-class ItemData(NamedTuple):
-    code: Optional[int]
-    classification: ItemClassification
-    dlc_flags: Optional[HatDLC] = HatDLC.none
-
-
-hat_type_to_item = {
-    HatType.SPRINT:     "Sprint Hat",
-    HatType.BREWING:    "Brewing Hat",
-    HatType.ICE:        "Ice Hat",
-    HatType.DWELLER:    "Dweller Mask",
-    HatType.TIME_STOP:  "Time Stop Hat",
-}

worlds/ahit/__init__.py

@@ -1,374 +0,0 @@
-from BaseClasses import Item, ItemClassification, Tutorial, Location, MultiWorld
-from .Items import item_table, create_item, relic_groups, act_contracts, create_itempool, get_shop_trap_name, \
-    calculate_yarn_costs
-from .Regions import create_regions, randomize_act_entrances, chapter_act_info, create_events, get_shuffled_region
-from .Locations import location_table, contract_locations, is_location_valid, get_location_names, TASKSANITY_START_ID, \
-    get_total_locations
-from .Rules import set_rules
-from .Options import AHITOptions, slot_data_options, adjust_options, RandomizeHatOrder, EndGoal, create_option_groups
-from .Types import HatType, ChapterIndex, HatInTimeItem, hat_type_to_item
-from .DeathWishLocations import create_dw_regions, dw_classes, death_wishes
-from .DeathWishRules import set_dw_rules, create_enemy_events, hit_list, bosses
-from worlds.AutoWorld import World, WebWorld, CollectionState
-from typing import List, Dict, TextIO
-from worlds.LauncherComponents import Component, components, icon_paths, launch_subprocess, Type
-from Utils import local_path
-
-
-def launch_client():
-    from .Client import launch
-    launch_subprocess(launch, name="AHITClient")
-
-
-components.append(Component("A Hat in Time Client", "AHITClient", func=launch_client,
-                            component_type=Type.CLIENT, icon='yatta'))
-
-icon_paths['yatta'] = local_path('data', 'yatta.png')
-
-
-class AWebInTime(WebWorld):
-    theme = "partyTime"
-    option_groups = create_option_groups()
-    tutorials = [Tutorial(
-        "Multiworld Setup Guide",
-        "A guide for setting up A Hat in Time to be played in Archipelago.",
-        "English",
-        "ahit_en.md",
-        "setup/en",
-        ["CookieCat"]
-    )]
-
-
-class HatInTimeWorld(World):
-    """
-    A Hat in Time is a cute-as-peck 3D platformer featuring a little girl who stitches hats for wicked powers!
-    Freely explore giant worlds and recover Time Pieces to travel to new heights!
-    """
-
-    game = "A Hat in Time"
-    item_name_to_id = {name: data.code for name, data in item_table.items()}
-    location_name_to_id = get_location_names()
-    options_dataclass = AHITOptions
-    options: AHITOptions
-    item_name_groups = relic_groups
-    web = AWebInTime()
-
-    def __init__(self, multiworld: "MultiWorld", player: int):
-        super().__init__(multiworld, player)
-        self.act_connections: Dict[str, str] = {}
-        self.shop_locs: List[str] = []
-
-        self.hat_craft_order: List[HatType] = [HatType.SPRINT, HatType.BREWING, HatType.ICE,
-                                               HatType.DWELLER, HatType.TIME_STOP]
-
-        self.hat_yarn_costs: Dict[HatType, int] = {HatType.SPRINT: -1, HatType.BREWING: -1, HatType.ICE: -1,
-                                                   HatType.DWELLER: -1, HatType.TIME_STOP: -1}
-
-        self.chapter_timepiece_costs: Dict[ChapterIndex, int] = {ChapterIndex.MAFIA: -1,
-                                                                 ChapterIndex.BIRDS: -1,
-                                                                 ChapterIndex.SUBCON: -1,
-                                                                 ChapterIndex.ALPINE: -1,
-                                                                 ChapterIndex.FINALE: -1,
-                                                                 ChapterIndex.CRUISE: -1,
-                                                                 ChapterIndex.METRO: -1}
-        self.excluded_dws: List[str] = []
-        self.excluded_bonuses: List[str] = []
-        self.dw_shuffle: List[str] = []
-        self.nyakuza_thug_items: Dict[str, int] = {}
-        self.badge_seller_count: int = 0
-
-    def generate_early(self):
-        adjust_options(self)
-
-        if self.options.StartWithCompassBadge:
-            self.multiworld.push_precollected(self.create_item("Compass Badge"))
-
-        if self.is_dw_only():
-            return
-
-        # If our starting chapter is 4 and act rando isn't on, force hookshot into inventory
-        # If starting chapter is 3 and painting shuffle is enabled, and act rando isn't, give one free painting unlock
-        start_chapter: ChapterIndex = ChapterIndex(self.options.StartingChapter)
-
-        if start_chapter == ChapterIndex.ALPINE or start_chapter == ChapterIndex.SUBCON:
-            if not self.options.ActRandomizer:
-                if start_chapter == ChapterIndex.ALPINE:
-                    self.multiworld.push_precollected(self.create_item("Hookshot Badge"))
-                    if self.options.UmbrellaLogic:
-                        self.multiworld.push_precollected(self.create_item("Umbrella"))
-
-                if start_chapter == ChapterIndex.SUBCON and self.options.ShuffleSubconPaintings:
-                    self.multiworld.push_precollected(self.create_item("Progressive Painting Unlock"))
-
-    def create_regions(self):
-        # noinspection PyClassVar
-        self.topology_present = bool(self.options.ActRandomizer)
-
-        create_regions(self)
-        if self.options.EnableDeathWish:
-            create_dw_regions(self)
-
-        if self.is_dw_only():
-            return
-
-        create_events(self)
-        if self.is_dw():
-            if "Snatcher's Hit List" not in self.excluded_dws or "Camera Tourist" not in self.excluded_dws:
-                create_enemy_events(self)
-
-        # place vanilla contract locations if contract shuffle is off
-        if not self.options.ShuffleActContracts:
-            for name in contract_locations.keys():
-                self.multiworld.get_location(name, self.player).place_locked_item(create_item(self, name))
-
-    def create_items(self):
-        if self.has_yarn():
-            calculate_yarn_costs(self)
-
-            if self.options.RandomizeHatOrder:
-                self.random.shuffle(self.hat_craft_order)
-                if self.options.RandomizeHatOrder == RandomizeHatOrder.option_time_stop_last:
-                    self.hat_craft_order.remove(HatType.TIME_STOP)
-                    self.hat_craft_order.append(HatType.TIME_STOP)
-
-            # move precollected hats to the start of the list
-            for i in range(5):
-                hat = HatType(i)
-                if self.is_hat_precollected(hat):
-                    self.hat_craft_order.remove(hat)
-                    self.hat_craft_order.insert(0, hat)
-
-        self.multiworld.itempool += create_itempool(self)
-
-    def set_rules(self):
-        if self.is_dw_only():
-            # we already have all items if this is the case, no need for rules
-            self.multiworld.push_precollected(HatInTimeItem("Death Wish Only Mode", ItemClassification.progression,
-                                              None, self.player))
-
-            self.multiworld.completion_condition[self.player] = lambda state: state.has("Death Wish Only Mode",
-                                                                                        self.player)
-
-            if not self.options.DWEnableBonus:
-                for name in death_wishes:
-                    if name == "Snatcher Coins in Nyakuza Metro" and not self.is_dlc2():
-                        continue
-
-                    if self.options.DWShuffle and name not in self.dw_shuffle:
-                        continue
-
-                    full_clear = self.multiworld.get_location(f"{name} - All Clear", self.player)
-                    full_clear.address = None
-                    full_clear.place_locked_item(HatInTimeItem("Nothing", ItemClassification.filler, None, self.player))
-                    full_clear.show_in_spoiler = False
-
-            return
-
-        if self.options.ActRandomizer:
-            randomize_act_entrances(self)
-
-        set_rules(self)
-
-        if self.is_dw():
-            set_dw_rules(self)
-
-    def create_item(self, name: str) -> Item:
-        return create_item(self, name)
-
-    def fill_slot_data(self) -> dict:
-        slot_data: dict = {"Chapter1Cost": self.chapter_timepiece_costs[ChapterIndex.MAFIA],
-                           "Chapter2Cost": self.chapter_timepiece_costs[ChapterIndex.BIRDS],
-                           "Chapter3Cost": self.chapter_timepiece_costs[ChapterIndex.SUBCON],
-                           "Chapter4Cost": self.chapter_timepiece_costs[ChapterIndex.ALPINE],
-                           "Chapter5Cost": self.chapter_timepiece_costs[ChapterIndex.FINALE],
-                           "Chapter6Cost": self.chapter_timepiece_costs[ChapterIndex.CRUISE],
-                           "Chapter7Cost": self.chapter_timepiece_costs[ChapterIndex.METRO],
-                           "BadgeSellerItemCount": self.badge_seller_count,
-                           "SeedNumber": str(self.multiworld.seed),  # For shop prices
-                           "SeedName": self.multiworld.seed_name,
-                           "TotalLocations": get_total_locations(self)}
-
-        if self.has_yarn():
-            slot_data.setdefault("SprintYarnCost", self.hat_yarn_costs[HatType.SPRINT])
-            slot_data.setdefault("BrewingYarnCost", self.hat_yarn_costs[HatType.BREWING])
-            slot_data.setdefault("IceYarnCost", self.hat_yarn_costs[HatType.ICE])
-            slot_data.setdefault("DwellerYarnCost", self.hat_yarn_costs[HatType.DWELLER])
-            slot_data.setdefault("TimeStopYarnCost", self.hat_yarn_costs[HatType.TIME_STOP])
-            slot_data.setdefault("Hat1", int(self.hat_craft_order[0]))
-            slot_data.setdefault("Hat2", int(self.hat_craft_order[1]))
-            slot_data.setdefault("Hat3", int(self.hat_craft_order[2]))
-            slot_data.setdefault("Hat4", int(self.hat_craft_order[3]))
-            slot_data.setdefault("Hat5", int(self.hat_craft_order[4]))
-
-        if self.options.ActRandomizer:
-            for name in self.act_connections.keys():
-                slot_data[name] = self.act_connections[name]
-
-        if self.is_dlc2() and not self.is_dw_only():
-            for name in self.nyakuza_thug_items.keys():
-                slot_data[name] = self.nyakuza_thug_items[name]
-
-        if self.is_dw():
-            i = 0
-            for name in self.excluded_dws:
-                if self.options.EndGoal.value == EndGoal.option_seal_the_deal and name == "Seal the Deal":
-                    continue
-
-                slot_data[f"excluded_dw{i}"] = dw_classes[name]
-                i += 1
-
-            i = 0
-            if not self.options.DWAutoCompleteBonuses:
-                for name in self.excluded_bonuses:
-                    if name in self.excluded_dws:
-                        continue
-
-                    slot_data[f"excluded_bonus{i}"] = dw_classes[name]
-                    i += 1
-
-            if self.options.DWShuffle:
-                shuffled_dws = self.dw_shuffle
-                for i in range(len(shuffled_dws)):
-                    slot_data[f"dw_{i}"] = dw_classes[shuffled_dws[i]]
-
-        shop_item_names: Dict[str, str] = {}
-        for name in self.shop_locs:
-            loc: Location = self.multiworld.get_location(name, self.player)
-            assert loc.item
-            item_name: str
-            if loc.item.classification is ItemClassification.trap and loc.item.game == "A Hat in Time":
-                item_name = get_shop_trap_name(self)
-            else:
-                item_name = loc.item.name
-
-            shop_item_names.setdefault(str(loc.address), item_name)
-
-        slot_data["ShopItemNames"] = shop_item_names
-
-        for name, value in self.options.as_dict(*self.options_dataclass.type_hints).items():
-            if name in slot_data_options:
-                slot_data[name] = value
-
-        return slot_data
-
-    def extend_hint_information(self, hint_data: Dict[int, Dict[int, str]]):
-        if self.is_dw_only() or not self.options.ActRandomizer:
-            return
-
-        new_hint_data = {}
-        alpine_regions = ["The Birdhouse", "The Lava Cake", "The Windmill",
-                          "The Twilight Bell", "Alpine Skyline Area", "Alpine Skyline Area (TIHS)"]
-
-        metro_regions = ["Yellow Overpass Station", "Green Clean Station", "Bluefin Tunnel", "Pink Paw Station"]
-
-        for key, data in location_table.items():
-            if not is_location_valid(self, key):
-                continue
-
-            location = self.multiworld.get_location(key, self.player)
-            region_name: str
-
-            if data.region in alpine_regions:
-                region_name = "Alpine Free Roam"
-            elif data.region in metro_regions:
-                region_name = "Nyakuza Free Roam"
-            elif "Dead Bird Studio - " in data.region:
-                region_name = "Dead Bird Studio"
-            elif data.region in chapter_act_info.keys():
-                region_name = location.parent_region.name
-            else:
-                continue
-
-            new_hint_data[location.address] = get_shuffled_region(self, region_name)
-
-        if self.is_dlc1() and self.options.Tasksanity:
-            ship_shape_region = get_shuffled_region(self, "Ship Shape")
-            id_start: int = TASKSANITY_START_ID
-            for i in range(self.options.TasksanityCheckCount):
-                new_hint_data[id_start+i] = ship_shape_region
-
-        hint_data[self.player] = new_hint_data
-
-    def write_spoiler_header(self, spoiler_handle: TextIO):
-        for i in self.chapter_timepiece_costs:
-            spoiler_handle.write("Chapter %i Cost: %i\n" % (i, self.chapter_timepiece_costs[ChapterIndex(i)]))
-
-        for hat in self.hat_craft_order:
-            spoiler_handle.write("Hat Cost: %s: %i\n" % (hat, self.hat_yarn_costs[hat]))
-
-    def collect(self, state: "CollectionState", item: "Item") -> bool:
-        old_count: int = state.count(item.name, self.player)
-        change = super().collect(state, item)
-        if change and old_count == 0:
-            if "Stamp" in item.name:
-                if "2 Stamp" in item.name:
-                    state.prog_items[self.player]["Stamps"] += 2
-                else:
-                    state.prog_items[self.player]["Stamps"] += 1
-            elif "(Zero Jumps)" in item.name:
-                state.prog_items[self.player]["Zero Jumps"] += 1
-            elif item.name in hit_list.keys():
-                if item.name not in bosses:
-                    state.prog_items[self.player]["Enemy"] += 1
-                else:
-                    state.prog_items[self.player]["Boss"] += 1
-
-        return change
-
-    def remove(self, state: "CollectionState", item: "Item") -> bool:
-        old_count: int = state.count(item.name, self.player)
-        change = super().collect(state, item)
-        if change and old_count == 1:
-            if "Stamp" in item.name:
-                if "2 Stamp" in item.name:
-                    state.prog_items[self.player]["Stamps"] -= 2
-                else:
-                    state.prog_items[self.player]["Stamps"] -= 1
-            elif "(Zero Jumps)" in item.name:
-                state.prog_items[self.player]["Zero Jumps"] -= 1
-            elif item.name in hit_list.keys():
-                if item.name not in bosses:
-                    state.prog_items[self.player]["Enemy"] -= 1
-                else:
-                    state.prog_items[self.player]["Boss"] -= 1
-
-        return change
-
-    def has_yarn(self) -> bool:
-        return not self.is_dw_only() and not self.options.HatItems
-
-    def is_hat_precollected(self, hat: HatType) -> bool:
-        for item in self.multiworld.precollected_items[self.player]:
-            if item.name == hat_type_to_item[hat]:
-                return True
-
-        return False
-
-    def is_dlc1(self) -> bool:
-        return bool(self.options.EnableDLC1)
-
-    def is_dlc2(self) -> bool:
-        return bool(self.options.EnableDLC2)
-
-    def is_dw(self) -> bool:
-        return bool(self.options.EnableDeathWish)
-
-    def is_dw_only(self) -> bool:
-        return self.is_dw() and bool(self.options.DeathWishOnly)
-
-    def is_dw_excluded(self, name: str) -> bool:
-        # don't exclude Seal the Deal if it's our goal
-        if self.options.EndGoal.value == EndGoal.option_seal_the_deal and name == "Seal the Deal" \
-           and f"{name} - Main Objective" not in self.options.exclude_locations:
-            return False
-
-        if name in self.excluded_dws:
-            return True
-
-        return f"{name} - Main Objective" in self.options.exclude_locations
-
-    def is_bonus_excluded(self, name: str) -> bool:
-        if self.is_dw_excluded(name) or name in self.excluded_bonuses:
-            return True
-
-        return f"{name} - All Clear" in self.options.exclude_locations

worlds/ahit/docs/en_A Hat in Time.md

@@ -1,53 +0,0 @@
-# A Hat in Time
-
-## Where is the options page?
-
-The [player options page for this game](../player-options) contains all the options you need to configure and export a
-config file.
-
-## What does randomization do to this game?
-
-Items which the player would normally acquire throughout the game have been moved around. 
-Chapter costs are randomized in a progressive order based on your options, 
-so for example you could go to Subcon Forest -> Battle of the Birds -> Alpine Skyline, etc. in that order. 
-If act shuffle is turned on, the levels and Time Rifts in these chapters will be randomized as well.
- 
-To unlock and access a chapter's Time Rift in act shuffle, 
-the levels in place of the original acts required to unlock the Time Rift in the vanilla game must be completed, 
-and then you must enter a level that allows you to access that Time Rift. 
-For example, Time Rift: Bazaar requires Heating Up Mafia Town to be completed in the vanilla game. 
-To unlock this Time Rift in act shuffle (and therefore the level it contains) 
-you must complete the level that was shuffled in place of Heating Up Mafia Town 
-and then enter the Time Rift through a Mafia Town level.
-
-## What items and locations get shuffled?
-
-Time Pieces, Relics, Yarn, Badges, and most other items are shuffled. 
-Unlike in the vanilla game, yarn is typeless, and hats will be automatically stitched 
-in a set order once you gather enough yarn for each hat. 
-Hats can also optionally be shuffled as individual items instead. 
-Any items in the world, shops, act completions, 
-and optionally storybook pages or Death Wish contracts are locations.
-
-Any freestanding items that are considered to be progression or useful 
-will have a rainbow streak particle attached to them. 
-Filler items will have a white glow attached to them instead.
-
-## Which items can be in another player's world?
-
-Any of the items which can be shuffled may also be placed into another player's world. It is possible to choose to limit
-certain items to your own world.
-
-## What does another world's item look like in A Hat in Time?
-
-Items belonging to other worlds are represented by a badge with the Archipelago logo on it.
-
-## When the player receives an item, what happens?
-
-When the player receives an item, it will play the item collect effect and information about the item 
-will be printed on the screen and in the in-game developer console.
-
-## Is the DLC required to play A Hat in Time in Archipelago?
-
-No, the DLC expansions are not required to play. Their content can be enabled through certain options 
-that are disabled by default, but please don't turn them on if you don't own the respective DLC.

worlds/ahit/docs/setup_en.md

@@ -1,102 +0,0 @@
-# Setup Guide for A Hat in Time in Archipelago
-
-## Required Software
-- [Steam release of A Hat in Time](https://store.steampowered.com/app/253230/A_Hat_in_Time/)
-
-- [Archipelago Workshop Mod for A Hat in Time](https://steamcommunity.com/sharedfiles/filedetails/?id=3026842601)
-
-
-## Optional Software
-- [A Hat in Time Archipelago Map Tracker](https://github.com/Mysteryem/ahit-poptracker/releases), for use with [PopTracker](https://github.com/black-sliver/PopTracker/releases)
-
-
-## Instructions
-
-1. Have Steam running. Open the Steam console with this link: [steam://open/console](steam://open/console)   
-This may not work for some browsers. If that's the case, and you're on Windows, open the Run dialog using Win+R,
-paste the link into the box, and hit Enter.
-
-
-2. In the Steam console, enter the following command: 
-`download_depot 253230 253232 7770543545116491859`. ***Wait for the console to say the download is finished!***
-This can take a while to finish (30+ minutes) depending on your connection speed, so please be patient. Additionally,
-**try to prevent your connection from being interrupted or slowed while Steam is downloading the depot,**
-or else the download may potentially become corrupted (see first FAQ issue below).
-
-
-3. Once the download finishes, go to `steamapps/content/app_253230` in Steam's program folder.
-
-
-4. There should be a folder named `depot_253232`. Rename it to HatinTime_AP and move it to your `steamapps/common` folder.
-
-
-5. In the HatinTime_AP folder, navigate to `Binaries/Win64` and create a new file: `steam_appid.txt`. 
-In this new text file, input the number **253230** on the first line.
-
-
-6. Create a shortcut of `HatinTimeGame.exe` from that folder and move it to wherever you'd like. 
-You will use this shortcut to open the Archipelago-compatible version of A Hat in Time.
-
-
-7. Start up the game using your new shortcut. To confirm if you are on the correct version, 
-go to Settings -> Game Settings. If you don't see an option labelled ***Live Game Events*** you should be running 
-the correct version of the game. In Game Settings, make sure ***Enable Developer Console*** is checked.
-
-
-## Connecting to the Archipelago server
-
-To connect to the multiworld server, simply run the **ArchipelagoAHITClient** 
-(or run it from the Launcher if you have the apworld installed) and connect it to the Archipelago server. 
-The game will connect to the client automatically when you create a new save file.
-
-
-## Console Commands
-
-Commands will not work on the title screen, you must be in-game to use them. To use console commands, 
-make sure ***Enable Developer Console*** is checked in Game Settings and press the tilde key or TAB while in-game.
-
-`ap_say <message>` - Send a chat message to the server. Supports commands, such as `!hint` or `!release`.
-
-`ap_deathlink` - Toggle Death Link.
-
-
-## FAQ/Common Issues
-### I followed the setup, but I receive an odd error message upon starting the game or creating a save file!
-If you receive an error message such as 
-**"Failed to find default engine .ini to retrieve My Documents subdirectory to use. Force quitting."** or
-**"Failed to load map "hub_spaceship"** after booting up the game or creating a save file respectively, then the depot
-download was likely corrupted. The only way to fix this is to start the entire download all over again.
-Unfortunately, this appears to be an underlying issue with Steam's depot downloader. The only way to really prevent this
-from happening is to ensure that your connection is not interrupted or slowed while downloading.
-
-### The game keeps crashing on startup after the splash screen!
-This issue is unfortunately very hard to fix, and the underlying cause is not known. If it does happen however,
-try the following:
-
-- Close Steam **entirely**.
-- Open the downpatched version of the game (with Steam closed) and allow it to load to the titlescreen.
-- Close the game, and then open Steam again. 
-- After launching the game, the issue should hopefully disappear. If not, repeat the above steps until it does.
-
-### I followed the setup, but "Live Game Events" still shows up in the options menu!
-The most common cause of this is the `steam_appid.txt` file. If you're on Windows 10, file extensions are hidden by 
-default (thanks Microsoft). You likely made the mistake of still naming the file `steam_appid.txt`, which, since file 
-extensions are hidden, would result in the file being named `steam_appid.txt.txt`, which is incorrect. 
-To show file extensions in Windows 10, open any folder, click the View tab at the top, and check
-"File name extensions". Then you can correct the name of the file. If the name of the file is correct, 
-and you're still running into the issue, re-read the setup guide again in case you missed a step. 
-If you still can't get it to work, ask for help in the Discord thread.
-
-### The game is running on the older version, but it's not connecting when starting a new save!
-For unknown reasons, the mod will randomly disable itself in the mod menu. To fix this, go to the Mods menu 
-(rocket icon) in-game, and re-enable the mod.
-
-### Why do relics disappear from the stands in the Spaceship after they're completed?
-This is intentional behaviour. Because of how randomizer logic works, there is no way to predict the order that 
-a player will place their relics. Since there are a limited amount of relic stands in the Spaceship, relics are removed 
-after being completed to allow for the placement of more relics without being potentially locked out. 
-The level that the relic set unlocked will stay unlocked.
-
-### When I start a new save file, the intro cinematic doesn't get skipped, Hat Kid's body is missing and the mod doesn't work!
-There is a bug on older versions of A Hat in Time that causes save file creation to fail to work properly 
-if you have too many save files. Delete them and it should fix the problem.

worlds/ahit/test/__init__.py

@@ -1,5 +0,0 @@
-from test.bases import WorldTestBase
-
-
-class HatInTimeTestBase(WorldTestBase):
-    game = "A Hat in Time"

worlds/ahit/test/test_acts.py

@@ -1,31 +0,0 @@
-from ..Regions import act_chapters
-from ..Rules import act_connections
-from . import HatInTimeTestBase
-
-
-class TestActs(HatInTimeTestBase):
-    run_default_tests = False
-
-    options = {
-        "ActRandomizer": 2,
-        "EnableDLC1": 1,
-        "EnableDLC2": 1,
-        "ShuffleActContracts": 0,
-    }
-
-    def test_act_shuffle(self):
-        for i in range(300):
-            self.world_setup()
-            self.collect_all_but([""])
-
-            for name in act_chapters.keys():
-                region = self.multiworld.get_region(name, 1)
-                for entrance in region.entrances:
-                    if entrance.name in act_connections.keys():
-                        continue
-
-                    self.assertTrue(self.can_reach_entrance(entrance.name),
-                                    f"Can't reach {name} from {entrance}\n"
-                                    f"{entrance.parent_region.entrances[0]} -> {entrance.parent_region} "
-                                    f"-> {entrance} -> {name}"
-                                    f" (expected method of access)")

worlds/alttp/Client.py

@@ -339,7 +339,7 @@ async def track_locations(ctx, roomid, roomdata) -> bool:
     def new_check(location_id):
         new_locations.append(location_id)
         ctx.locations_checked.add(location_id)
-        location = ctx.location_names.lookup_in_slot(location_id)
+        location = ctx.location_names[location_id]
         snes_logger.info(
             f'New Check: {location} ' +
             f'({len(ctx.checked_locations) + 1 if ctx.checked_locations else len(ctx.locations_checked)}/' +
@@ -552,9 +552,9 @@ class ALTTPSNIClient(SNIClient):
             item = ctx.items_received[recv_index]
             recv_index += 1
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names.lookup_in_slot(item.item), 'red', 'bold'),
+                color(ctx.item_names[item.item], 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names.lookup_in_slot(item.location, item.player), recv_index, len(ctx.items_received)))
+                ctx.location_names[item.location], recv_index, len(ctx.items_received)))
 
             snes_buffered_write(ctx, RECV_PROGRESS_ADDR,
                                 bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))

worlds/alttp/Options.py

@@ -1,11 +1,8 @@
 import typing
 
 from BaseClasses import MultiWorld
-from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, \
-    StartInventoryPool, PlandoBosses, PlandoConnections, PlandoTexts, FreeText, Removed
-from .EntranceShuffle import default_connections, default_dungeon_connections, \
-    inverted_default_connections, inverted_default_dungeon_connections
-from .Text import TextTable
+from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, StartInventoryPool, PlandoBosses,\
+    FreeText, Removed
 
 
 class GlitchesRequired(Choice):
@@ -724,27 +721,7 @@ class AllowCollect(DefaultOnToggle):
     display_name = "Allow Collection of checks for other players"
 
 
-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 (
-        *default_connections, *default_dungeon_connections, *inverted_default_connections,
-        *inverted_default_dungeon_connections)])
-
-
-class ALttPPlandoTexts(PlandoTexts):
-    """Text plando. Format is:
-    - text: 'This is your text'
-      at: text_key
-      percentage: 100
-    Percentage is an integer from 1 to 100, and defaults to 100 when omitted."""
-    valid_keys = TextTable.valid_keys
-
-
 alttp_options: typing.Dict[str, type(Option)] = {
-    "plando_connections": ALttPPlandoConnections,
-    "plando_texts": ALttPPlandoTexts,
     "start_inventory_from_pool": StartInventoryPool,
     "goal": Goal,
     "mode": Mode,

worlds/alttp/Rom.py

@@ -1269,8 +1269,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
         rom.write_int32(0x18020C, 0)  # starting time (in frames, sint32)
 
     # set up goals for treasure hunt
-    rom.write_int16(0x180163, max(0, local_world.treasure_hunt_required -
-                    sum(1 for item in world.precollected_items[player] if item.name == "Triforce Piece")))
+    rom.write_int16(0x180163, local_world.treasure_hunt_required)
     rom.write_bytes(0x180165, [0x0E, 0x28])  #  Triforce Piece Sprite
     rom.write_byte(0x180194, 1)  # Must turn in triforced pieces (instant win not enabled)
 
@@ -1373,7 +1372,7 @@ def patch_rom(world: MultiWorld, rom: LocalRom, player: int, enemized: bool):
                          'Golden Sword', 'Tempered Sword', 'Master Sword', 'Fighter Sword', 'Progressive Sword',
                          'Mirror Shield', 'Red Shield', 'Blue Shield', 'Progressive Shield',
                          'Red Mail', 'Blue Mail', 'Progressive Mail',
-                         'Magic Upgrade (1/4)', 'Magic Upgrade (1/2)', 'Triforce Piece'}:
+                         'Magic Upgrade (1/4)', 'Magic Upgrade (1/2)'}:
             continue
 
         set_table = {'Book of Mudora': (0x34E, 1), 'Hammer': (0x34B, 1), 'Bug Catching Net': (0x34D, 1),
@@ -2476,9 +2475,6 @@ def write_strings(rom, world, player):
     tt['sahasrahla_quest_have_master_sword'] = Sahasrahla2_texts[local_random.randint(0, len(Sahasrahla2_texts) - 1)]
     tt['blind_by_the_light'] = Blind_texts[local_random.randint(0, len(Blind_texts) - 1)]
 
-    triforce_pieces_required = max(0, w.treasure_hunt_required -
-                                   sum(1 for item in world.precollected_items[player] if item.name == "Triforce Piece"))
-
     if world.goal[player] in ['triforce_hunt', 'local_triforce_hunt']:
         tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Get the Triforce Pieces.'
         tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
@@ -2486,16 +2482,16 @@ def write_strings(rom, world, player):
             tt['sign_ganon'] = 'Go find the Triforce pieces with your friends... Ganon is invincible!'
         else:
             tt['sign_ganon'] = 'Go find the Triforce pieces... Ganon is invincible!'
-        if triforce_pieces_required > 1:
+        if w.treasure_hunt_required > 1:
             tt['murahdahla'] = "Hello @. I\nam Murahdahla, brother of\nSahasrahla and Aginah. Behold the power of\n" \
                                "invisibility.\n\n\n\n… … …\n\nWait! you can see me? I knew I should have\n" \
                                "hidden in  a hollow tree. If you bring\n%d Triforce pieces out of %d, I can reassemble it." % \
-                               (triforce_pieces_required, w.treasure_hunt_total)
+                               (w.treasure_hunt_required, w.treasure_hunt_total)
         else:
             tt['murahdahla'] = "Hello @. I\nam Murahdahla, brother of\nSahasrahla and Aginah. Behold the power of\n" \
                                "invisibility.\n\n\n\n… … …\n\nWait! you can see me? I knew I should have\n" \
                                "hidden in  a hollow tree. If you bring\n%d Triforce piece out of %d, I can reassemble it." % \
-                               (triforce_pieces_required, w.treasure_hunt_total)
+                               (w.treasure_hunt_required, w.treasure_hunt_total)
     elif world.goal[player] in ['pedestal']:
         tt['ganon_fall_in_alt'] = 'Why are you even here?\n You can\'t even hurt me! Your goal is at the pedestal.'
         tt['ganon_phase_3_alt'] = 'Seriously? Go Away, I will not Die.'
@@ -2504,20 +2500,20 @@ def write_strings(rom, world, player):
         tt['ganon_fall_in'] = Ganon1_texts[local_random.randint(0, len(Ganon1_texts) - 1)]
         tt['ganon_fall_in_alt'] = 'You cannot defeat me until you finish your goal!'
         tt['ganon_phase_3_alt'] = 'Got wax in\nyour ears?\nI can not die!'
-        if triforce_pieces_required > 1:
+        if w.treasure_hunt_required > 1:
             if world.goal[player] == 'ganon_triforce_hunt' and world.players > 1:
                 tt['sign_ganon'] = 'You need to find %d Triforce pieces out of %d with your friends to defeat Ganon.' % \
-                                   (triforce_pieces_required, w.treasure_hunt_total)
+                                   (w.treasure_hunt_required, w.treasure_hunt_total)
             elif world.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
                 tt['sign_ganon'] = 'You need to find %d Triforce pieces out of %d to defeat Ganon.' % \
-                                   (triforce_pieces_required, w.treasure_hunt_total)
+                                   (w.treasure_hunt_required, w.treasure_hunt_total)
         else:
             if world.goal[player] == 'ganon_triforce_hunt' and world.players > 1:
                 tt['sign_ganon'] = 'You need to find %d Triforce piece out of %d with your friends to defeat Ganon.' % \
-                                   (triforce_pieces_required, w.treasure_hunt_total)
+                                   (w.treasure_hunt_required, w.treasure_hunt_total)
             elif world.goal[player] in ['ganon_triforce_hunt', 'local_ganon_triforce_hunt']:
                 tt['sign_ganon'] = 'You need to find %d Triforce piece out of %d to defeat Ganon.' % \
-                                   (triforce_pieces_required, w.treasure_hunt_total)
+                                   (w.treasure_hunt_required, w.treasure_hunt_total)
 
     tt['kakariko_tavern_fisherman'] = TavernMan_texts[local_random.randint(0, len(TavernMan_texts) - 1)]
 
@@ -2542,12 +2538,12 @@ def write_strings(rom, world, player):
         tt['menu_start_2'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n{CHOICE3}"
         tt['menu_start_3'] = "{MENU}\n{SPEED0}\n≥@'s house\n Dark Chapel\n Mountain Cave\n{CHOICE2}"
 
-    for at, text, _ in world.plando_texts[player]:
+    for at, text in world.plando_texts[player].items():
 
         if at not in tt:
             raise Exception(f"No text target \"{at}\" found.")
         else:
-            tt[at] = "\n".join(text)
+            tt[at] = text
 
     rom.write_bytes(0xE0000, tt.getBytes())
 

worlds/alttp/Shops.py

@@ -9,9 +9,9 @@ from worlds.generic.Rules import add_rule
 
 from BaseClasses import CollectionState
 from .SubClasses import ALttPLocation
-
+from .EntranceShuffle import door_addresses
 from .Items import item_name_groups
-
+from .Options import small_key_shuffle, RandomizeShopInventories
 from .StateHelpers import has_hearts, can_use_bombs, can_hold_arrows
 
 logger = logging.getLogger("Shops")
@@ -66,7 +66,6 @@ class Shop:
         return 0
 
     def get_bytes(self) -> List[int]:
-        from .EntranceShuffle import door_addresses
         # [id][roomID-low][roomID-high][doorID][zero][shop_config][shopkeeper_config][sram_index]
         entrances = self.region.entrances
         config = self.item_count
@@ -182,7 +181,7 @@ def push_shop_inventories(multiworld):
 
 
 def create_shops(multiworld, player: int):
-    from .Options import RandomizeShopInventories
+
     player_shop_table = shop_table.copy()
     if multiworld.include_witch_hut[player]:
         player_shop_table["Potion Shop"] = player_shop_table["Potion Shop"]._replace(locked=False)
@@ -305,7 +304,6 @@ shop_generation_types = {
 
 
 def set_up_shops(multiworld, player: int):
-    from .Options import small_key_shuffle
     # TODO: move hard+ mode changes for shields here, utilizing the new shops
 
     if multiworld.retro_bow[player]:
@@ -428,7 +426,7 @@ def get_price_modifier(item):
 
 def get_price(multiworld, item, player: int, price_type=None):
     """Converts a raw Rupee price into a special price type"""
-    from .Options import small_key_shuffle
+
     if price_type:
         price_types = [price_type]
     else:

worlds/alttp/Text.py

@@ -1289,415 +1289,6 @@ class LargeCreditBottomMapper(CharTextMapper):
 class TextTable(object):
     SIZE = 0x7355
 
-    valid_keys = [
-        "set_cursor",
-        "set_cursor2",
-        "game_over_menu",
-        "var_test",
-        "follower_no_enter",
-        "choice_1_3",
-        "choice_2_3",
-        "choice_3_3",
-        "choice_1_2",
-        "choice_2_2",
-        "uncle_leaving_text",
-        "uncle_dying_sewer",
-        "tutorial_guard_1",
-        "tutorial_guard_2",
-        "tutorial_guard_3",
-        "tutorial_guard_4",
-        "tutorial_guard_5",
-        "tutorial_guard_6",
-        "tutorial_guard_7",
-        "priest_sanctuary_before_leave",
-        "sanctuary_enter",
-        "zelda_sanctuary_story",
-        "priest_sanctuary_before_pendants",
-        "priest_sanctuary_after_pendants_before_master_sword",
-        "priest_sanctuary_dying",
-        "zelda_save_sewers",
-        "priest_info",
-        "zelda_sanctuary_before_leave",
-        "telepathic_intro",
-        "telepathic_reminder",
-        "zelda_go_to_throne",
-        "zelda_push_throne",
-        "zelda_switch_room_pull",
-        "zelda_save_lets_go",
-        "zelda_save_repeat",
-        "zelda_before_pendants",
-        "zelda_after_pendants_before_master_sword",
-        "telepathic_zelda_right_after_master_sword",
-        "zelda_sewers",
-        "zelda_switch_room",
-        "kakariko_saharalasa_wife",
-        "kakariko_saharalasa_wife_sword_story",
-        "kakariko_saharalasa_wife_closing",
-        "kakariko_saharalasa_after_master_sword",
-        "kakariko_alert_guards",
-        "sahasrahla_quest_have_pendants",
-        "sahasrahla_quest_have_master_sword",
-        "sahasrahla_quest_information",
-        "sahasrahla_bring_courage",
-        "sahasrahla_have_ice_rod",
-        "telepathic_sahasrahla_beat_agahnim",
-        "telepathic_sahasrahla_beat_agahnim_no_pearl",
-        "sahasrahla_have_boots_no_icerod",
-        "sahasrahla_have_courage",
-        "sahasrahla_found",
-        "sign_rain_north_of_links_house",
-        "sign_north_of_links_house",
-        "sign_path_to_death_mountain",
-        "sign_lost_woods",
-        "sign_zoras",
-        "sign_outside_magic_shop",
-        "sign_death_mountain_cave_back",
-        "sign_east_of_links_house",
-        "sign_south_of_lumberjacks",
-        "sign_east_of_desert",
-        "sign_east_of_sanctuary",
-        "sign_east_of_castle",
-        "sign_north_of_lake",
-        "sign_desert_thief",
-        "sign_lumberjacks_house",
-        "sign_north_kakariko",
-        "witch_bring_mushroom",
-        "witch_brewing_the_item",
-        "witch_assistant_no_bottle",
-        "witch_assistant_no_empty_bottle",
-        "witch_assistant_informational",
-        "witch_assistant_no_bottle_buying",
-        "potion_shop_no_empty_bottles",
-        "item_get_lamp",
-        "item_get_boomerang",
-        "item_get_bow",
-        "item_get_shovel",
-        "item_get_magic_cape",
-        "item_get_powder",
-        "item_get_flippers",
-        "item_get_power_gloves",
-        "item_get_pendant_courage",
-        "item_get_pendant_power",
-        "item_get_pendant_wisdom",
-        "item_get_mushroom",
-        "item_get_book",
-        "item_get_moonpearl",
-        "item_get_compass",
-        "item_get_map",
-        "item_get_ice_rod",
-        "item_get_fire_rod",
-        "item_get_ether",
-        "item_get_bombos",
-        "item_get_quake",
-        "item_get_hammer",
-        "item_get_flute",
-        "item_get_cane_of_somaria",
-        "item_get_hookshot",
-        "item_get_bombs",
-        "item_get_bottle",
-        "item_get_big_key",
-        "item_get_titans_mitts",
-        "item_get_magic_mirror",
-        "item_get_fake_mastersword",
-        "post_item_get_mastersword",
-        "item_get_red_potion",
-        "item_get_green_potion",
-        "item_get_blue_potion",
-        "item_get_bug_net",
-        "item_get_blue_mail",
-        "item_get_red_mail",
-        "item_get_temperedsword",
-        "item_get_mirror_shield",
-        "item_get_cane_of_byrna",
-        "missing_big_key",
-        "missing_magic",
-        "item_get_pegasus_boots",
-        "talking_tree_info_start",
-        "talking_tree_info_1",
-        "talking_tree_info_2",
-        "talking_tree_info_3",
-        "talking_tree_info_4",
-        "talking_tree_other",
-        "item_get_pendant_power_alt",
-        "item_get_pendant_wisdom_alt",
-        "game_shooting_choice",
-        "game_shooting_yes",
-        "game_shooting_no",
-        "game_shooting_continue",
-        "pond_of_wishing",
-        "pond_item_select",
-        "pond_item_test",
-        "pond_will_upgrade",
-        "pond_item_test_no",
-        "pond_item_test_no_no",
-        "pond_item_boomerang",
-        "pond_item_shield",
-        "pond_item_silvers",
-        "pond_item_bottle_filled",
-        "pond_item_sword",
-        "pond_of_wishing_happiness",
-        "pond_of_wishing_choice",
-        "pond_of_wishing_bombs",
-        "pond_of_wishing_arrows",
-        "pond_of_wishing_full_upgrades",
-        "mountain_old_man_first",
-        "mountain_old_man_deadend",
-        "mountain_old_man_turn_right",
-        "mountain_old_man_lost_and_alone",
-        "mountain_old_man_drop_off",
-        "mountain_old_man_in_his_cave_pre_agahnim",
-        "mountain_old_man_in_his_cave",
-        "mountain_old_man_in_his_cave_post_agahnim",
-        "tavern_old_man_awake",
-        "tavern_old_man_unactivated_flute",
-        "tavern_old_man_know_tree_unactivated_flute",
-        "tavern_old_man_have_flute",
-        "chicken_hut_lady",
-        "running_man",
-        "game_race_sign",
-        "sign_bumper_cave",
-        "sign_catfish",
-        "sign_north_village_of_outcasts",
-        "sign_south_of_bumper_cave",
-        "sign_east_of_pyramid",
-        "sign_east_of_bomb_shop",
-        "sign_east_of_mire",
-        "sign_village_of_outcasts",
-        "sign_before_wishing_pond",
-        "sign_before_catfish_area",
-        "castle_wall_guard",
-        "gate_guard",
-        "telepathic_tile_eastern_palace",
-        "telepathic_tile_tower_of_hera_floor_4",
-        "hylian_text_1",
-        "mastersword_pedestal_translated",
-        "telepathic_tile_spectacle_rock",
-        "telepathic_tile_swamp_entrance",
-        "telepathic_tile_thieves_town_upstairs",
-        "telepathic_tile_misery_mire",
-        "hylian_text_2",
-        "desert_entry_translated",
-        "telepathic_tile_under_ganon",
-        "telepathic_tile_palace_of_darkness",
-        "telepathic_tile_desert_bonk_torch_room",
-        "telepathic_tile_castle_tower",
-        "telepathic_tile_ice_large_room",
-        "telepathic_tile_turtle_rock",
-        "telepathic_tile_ice_entrance",
-        "telepathic_tile_ice_stalfos_knights_room",
-        "telepathic_tile_tower_of_hera_entrance",
-        "houlihan_room",
-        "caught_a_bee",
-        "caught_a_fairy",
-        "no_empty_bottles",
-        "game_race_boy_time",
-        "game_race_girl",
-        "game_race_boy_success",
-        "game_race_boy_failure",
-        "game_race_boy_already_won",
-        "game_race_boy_sneaky",
-        "bottle_vendor_choice",
-        "bottle_vendor_get",
-        "bottle_vendor_no",
-        "bottle_vendor_already_collected",
-        "bottle_vendor_bee",
-        "bottle_vendor_fish",
-        "hobo_item_get_bottle",
-        "blacksmiths_what_you_want",
-        "blacksmiths_paywall",
-        "blacksmiths_extra_okay",
-        "blacksmiths_tempered_already",
-        "blacksmiths_temper_no",
-        "blacksmiths_bogart_sword",
-        "blacksmiths_get_sword",
-        "blacksmiths_shop_before_saving",
-        "blacksmiths_shop_saving",
-        "blacksmiths_collect_frog",
-        "blacksmiths_still_working",
-        "blacksmiths_saving_bows",
-        "blacksmiths_hammer_anvil",
-        "dark_flute_boy_storytime",
-        "dark_flute_boy_get_shovel",
-        "dark_flute_boy_no_get_shovel",
-        "dark_flute_boy_flute_not_found",
-        "dark_flute_boy_after_shovel_get",
-        "shop_fortune_teller_lw_hint_0",
-        "shop_fortune_teller_lw_hint_1",
-        "shop_fortune_teller_lw_hint_2",
-        "shop_fortune_teller_lw_hint_3",
-        "shop_fortune_teller_lw_hint_4",
-        "shop_fortune_teller_lw_hint_5",
-        "shop_fortune_teller_lw_hint_6",
-        "shop_fortune_teller_lw_hint_7",
-        "shop_fortune_teller_lw_no_rupees",
-        "shop_fortune_teller_lw",
-        "shop_fortune_teller_lw_post_hint",
-        "shop_fortune_teller_lw_no",
-        "shop_fortune_teller_lw_hint_8",
-        "shop_fortune_teller_lw_hint_9",
-        "shop_fortune_teller_lw_hint_10",
-        "shop_fortune_teller_lw_hint_11",
-        "shop_fortune_teller_lw_hint_12",
-        "shop_fortune_teller_lw_hint_13",
-        "shop_fortune_teller_lw_hint_14",
-        "shop_fortune_teller_lw_hint_15",
-        "dark_sanctuary",
-        "dark_sanctuary_hint_0",
-        "dark_sanctuary_no",
-        "dark_sanctuary_hint_1",
-        "dark_sanctuary_yes",
-        "dark_sanctuary_hint_2",
-        "sick_kid_no_bottle",
-        "sick_kid_trade",
-        "sick_kid_post_trade",
-        "desert_thief_sitting",
-        "desert_thief_following",
-        "desert_thief_question",
-        "desert_thief_question_yes",
-        "desert_thief_after_item_get",
-        "desert_thief_reassure",
-        "hylian_text_3",
-        "tablet_ether_book",
-        "tablet_bombos_book",
-        "magic_bat_wake",
-        "magic_bat_give_half_magic",
-        "intro_main",
-        "intro_throne_room",
-        "intro_zelda_cell",
-        "intro_agahnim",
-        "pickup_purple_chest",
-        "bomb_shop",
-        "bomb_shop_big_bomb",
-        "bomb_shop_big_bomb_buy",
-        "item_get_big_bomb",
-        "kiki_second_extortion",
-        "kiki_second_extortion_no",
-        "kiki_second_extortion_yes",
-        "kiki_first_extortion",
-        "kiki_first_extortion_yes",
-        "kiki_first_extortion_no",
-        "kiki_leaving_screen",
-        "blind_in_the_cell",
-        "blind_by_the_light",
-        "blind_not_that_way",
-        "aginah_l1sword_no_book",
-        "aginah_l1sword_with_pendants",
-        "aginah",
-        "aginah_need_better_sword",
-        "aginah_have_better_sword",
-        "catfish",
-        "catfish_after_item",
-        "lumberjack_right",
-        "lumberjack_left",
-        "lumberjack_left_post_agahnim",
-        "fighting_brothers_right",
-        "fighting_brothers_right_opened",
-        "fighting_brothers_left",
-        "maiden_crystal_1",
-        "maiden_crystal_2",
-        "maiden_crystal_3",
-        "maiden_crystal_4",
-        "maiden_crystal_5",
-        "maiden_crystal_6",
-        "maiden_crystal_7",
-        "maiden_ending",
-        "maiden_confirm_understood",
-        "barrier_breaking",
-        "maiden_crystal_7_again",
-        "agahnim_zelda_teleport",
-        "agahnim_magic_running_away",
-        "agahnim_hide_and_seek_found",
-        "agahnim_defeated",
-        "agahnim_final_meeting",
-        "zora_meeting",
-        "zora_tells_cost",
-        "zora_get_flippers",
-        "zora_no_cash",
-        "zora_no_buy_item",
-        "kakariko_saharalasa_grandson",
-        "kakariko_saharalasa_grandson_next",
-        "dark_palace_tree_dude",
-        "fairy_wishing_ponds",
-        "fairy_wishing_ponds_no",
-        "pond_of_wishing_no",
-        "pond_of_wishing_return_item",
-        "pond_of_wishing_throw",
-        "pond_pre_item_silvers",
-        "pond_of_wishing_great_luck",
-        "pond_of_wishing_good_luck",
-        "pond_of_wishing_meh_luck",
-        "pond_of_wishing_bad_luck",
-        "pond_of_wishing_fortune",
-        "item_get_14_heart",
-        "item_get_24_heart",
-        "item_get_34_heart",
-        "item_get_whole_heart",
-        "item_get_sanc_heart",
-        "fairy_fountain_refill",
-        "death_mountain_bullied_no_pearl",
-        "death_mountain_bullied_with_pearl",
-        "death_mountain_bully_no_pearl",
-        "death_mountain_bully_with_pearl",
-        "shop_darkworld_enter",
-        "game_chest_village_of_outcasts",
-        "game_chest_no_cash",
-        "game_chest_not_played",
-        "game_chest_played",
-        "game_chest_village_of_outcasts_play",
-        "shop_first_time",
-        "shop_already_have",
-        "shop_buy_shield",
-        "shop_buy_red_potion",
-        "shop_buy_arrows",
-        "shop_buy_bombs",
-        "shop_buy_bee",
-        "shop_buy_heart",
-        "shop_first_no_bottle_buy",
-        "shop_buy_no_space",
-        "ganon_fall_in",
-        "ganon_phase_3",
-        "lost_woods_thief",
-        "blinds_hut_dude",
-        "end_triforce",
-        "toppi_fallen",
-        "kakariko_tavern_fisherman",
-        "thief_money",
-        "thief_desert_rupee_cave",
-        "thief_ice_rupee_cave",
-        "telepathic_tile_south_east_darkworld_cave",
-        "cukeman",
-        "cukeman_2",
-        "potion_shop_no_cash",
-        "kakariko_powdered_chicken",
-        "game_chest_south_of_kakariko",
-        "game_chest_play_yes",
-        "game_chest_play_no",
-        "game_chest_lost_woods",
-        "kakariko_flophouse_man_no_flippers",
-        "kakariko_flophouse_man",
-        "menu_start_2",
-        "menu_start_3",
-        "menu_pause",
-        "game_digging_choice",
-        "game_digging_start",
-        "game_digging_no_cash",
-        "game_digging_end_time",
-        "game_digging_come_back_later",
-        "game_digging_no_follower",
-        "menu_start_4",
-        "ganon_fall_in_alt",
-        "ganon_phase_3_alt",
-        "sign_east_death_mountain_bridge",
-        "fish_money",
-        "sign_ganons_tower",
-        "sign_ganon",
-        "ganon_phase_3_no_bow",
-        "ganon_phase_3_no_silvers_alt",
-        "ganon_phase_3_no_silvers",
-        "ganon_phase_3_silvers",
-        "murahdahla",
-    ]
-
     def __init__(self):
         self._text = OrderedDict()
         self.setDefaultText()

worlds/alttp/__init__.py

@@ -213,6 +213,7 @@ class ALTTPWorld(World):
     item_name_to_id = {name: data.item_code for name, data in item_table.items() if type(data.item_code) == int}
     location_name_to_id = lookup_name_to_id
 
+    data_version = 9
     required_client_version = (0, 4, 1)
     web = ALTTPWeb()
 

worlds/apsudoku/__init__.py

@@ -1,34 +0,0 @@
-from typing import Dict
-
-from BaseClasses import Tutorial
-from ..AutoWorld import WebWorld, World
-
-class AP_SudokuWebWorld(WebWorld):
-    options_page = "games/Sudoku/info/en"
-    theme = 'partyTime'
-
-    setup_en = Tutorial(
-        tutorial_name='Setup Guide',
-        description='A guide to playing APSudoku',
-        language='English',
-        file_name='setup_en.md',
-        link='setup/en',
-        authors=['EmilyV']
-    )
-    
-    tutorials = [setup_en]
-
-class AP_SudokuWorld(World):
-    """
-    Play a little Sudoku while you're in BK mode to maybe get some useful hints
-    """
-    game = "Sudoku"
-    web = AP_SudokuWebWorld()
-
-    item_name_to_id: Dict[str, int] = {}
-    location_name_to_id: Dict[str, int] = {}
-
-    @classmethod
-    def stage_assert_generate(cls, multiworld):
-        raise Exception("APSudoku cannot be used for generating worlds, the client can instead connect to any slot from any world")
-

worlds/apsudoku/docs/en_Sudoku.md

@@ -1,13 +0,0 @@
-# APSudoku
-
-## Hint Games
-
-HintGames do not need to be added at the start of a seed, and do not create a 'slot'- instead, you connect the HintGame client to a different game's slot. By playing a HintGame, you can earn hints for the connected slot.
-
-## What is this game?
-
-Play Sudoku puzzles of varying difficulties, earning a hint for each puzzle correctly solved. Harder puzzles are more likely to grant a hint towards a Progression item, though otherwise what hint is granted is random.
-
-## Where is the options page?
-
-There is no options page; this game cannot be used in your .yamls. Instead, the client can connect to any slot in a multiworld.

worlds/apsudoku/docs/setup_en.md

@@ -1,37 +0,0 @@
-# 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.
-
-## General Concept
-
-This is a HintGame client, which can connect to any multiworld slot, allowing you to play Sudoku to unlock random hints for that slot's locations.
-
-Does not need to be added at the start of a seed, as it does not create any slots of its own, nor does it have any YAML files.
-
-## 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.
-
-## Joining a MultiWorld Game
-
-1. Run APSudoku.exe
-2. Under the 'Archipelago' tab at the top-right:
-	- Enter the server url & 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.
-
-## 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.
-- On receiving a DeathLink from another player, your puzzle resets.