fix type

.github/pyright-config.json

@@ -1,21 +1,8 @@
 {
   "include": [
-    "../BizHawkClient.py",
-    "../Patch.py",
-    "../test/param.py",
-    "../test/general/test_groups.py",
-    "../test/general/test_helpers.py",
-    "../test/general/test_memory.py",
-    "../test/general/test_names.py",
-    "../test/multiworld/__init__.py",
-    "../test/multiworld/test_multiworlds.py",
-    "../test/netutils/__init__.py",
-    "../test/programs/__init__.py",
-    "../test/programs/test_multi_server.py",
-    "../test/utils/__init__.py",
-    "../test/webhost/test_descriptions.py",
+    "type_check.py",
     "../worlds/AutoSNIClient.py",
-    "type_check.py"
+    "../Patch.py"
   ],
 
   "exclude": [

.github/workflows/analyze-modified-files.yml

@@ -65,7 +65,7 @@ jobs:
         continue-on-error: false
         if: env.diff != '' && matrix.task == 'flake8'
         run: |
-          flake8 --count --select=E9,F63,F7,F82 --ignore F824 --show-source --statistics ${{ env.diff }}
+          flake8 --count --select=E9,F63,F7,F82 --show-source --statistics ${{ env.diff }}
 
       - name: "flake8: Lint modified files"
         continue-on-error: true

.github/workflows/build.yml

@@ -21,17 +21,12 @@ env:
   ENEMIZER_VERSION: 7.1
   APPIMAGETOOL_VERSION: 13
 
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
-
 jobs:
   # build-release-macos: # LF volunteer
 
-  build-win: # RCs and releases may still be built and signed by hand
+  build-win: # RCs will still be built and signed by hand
     runs-on: windows-latest
     steps:
-      # - copy code below to release.yml -
       - uses: actions/checkout@v4
       - name: Install python
         uses: actions/setup-python@v5
@@ -70,18 +65,6 @@ jobs:
           $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
           $SETUP_NAME=$contents[0].Name
           echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      # - copy code above to release.yml -
-      - name: Attest Build
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher.exe
-            build/exe.*/ArchipelagoLauncherDebug.exe
-            build/exe.*/ArchipelagoGenerate.exe
-            build/exe.*/ArchipelagoServer.exe
-            dist/${{ env.ZIP_NAME }}
-            setups/${{ env.SETUP_NAME }}
       - name: Check build loads expected worlds
         shell: bash
         run: |
@@ -116,8 +99,8 @@ jobs:
           if-no-files-found: error
           retention-days: 7  # keep for 7 days, should be enough
 
-  build-ubuntu2204:
-    runs-on: ubuntu-22.04
+  build-ubuntu2004:
+    runs-on: ubuntu-20.04
     steps:
       # - copy code below to release.yml -
       - uses: actions/checkout@v4
@@ -149,7 +132,7 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
           python setup.py build_exe --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"
@@ -159,16 +142,6 @@ jobs:
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
-      - name: Attest Build
-        if: ${{ github.event_name == 'workflow_dispatch' }}
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher
-            build/exe.*/ArchipelagoGenerate
-            build/exe.*/ArchipelagoServer
-            dist/${{ env.APPIMAGE_NAME }}*
-            dist/${{ env.TAR_NAME }}
       - name: Build Again
         run: |
           source venv/bin/activate

.github/workflows/ctest.yml

@@ -11,7 +11,7 @@ on:
       - '**.hh?'
       - '**.hpp'
       - '**.hxx'
-      - '**/CMakeLists.txt'
+      - '**.CMakeLists'
       - '.github/workflows/ctest.yml'
   pull_request:
     paths:
@@ -21,7 +21,7 @@ on:
       - '**.hh?'
       - '**.hpp'
       - '**.hxx'
-      - '**/CMakeLists.txt'
+      - '**.CMakeLists'
       - '.github/workflows/ctest.yml'
 
 jobs:
@@ -36,9 +36,9 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
-    - uses: ilammy/msvc-dev-cmd@0b201ec74fa43914dc39ae48a89fd1d8cb592756
+    - uses: ilammy/msvc-dev-cmd@v1
       if: startsWith(matrix.os,'windows')
-    - uses: Bacondish2023/setup-googletest@49065d1f7a6d21f6134864dd65980fe5dbe06c73
+    - uses: Bacondish2023/setup-googletest@v1
       with:
         build-type: 'Release'
     - name: Build tests

.github/workflows/release.yml

@@ -11,11 +11,6 @@ env:
   ENEMIZER_VERSION: 7.1
   APPIMAGETOOL_VERSION: 13
 
-permissions:  # permissions required for attestation
-  id-token: 'write'
-  attestations: 'write'
-  contents: 'write'  # additionally required for release
-
 jobs:
   create-release:
     runs-on: ubuntu-latest
@@ -31,79 +26,11 @@ jobs:
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+  # build-release-windows: # this is done by hand because of signing
   # build-release-macos: # LF volunteer
 
-  build-release-win:
-    runs-on: windows-latest
-    if: ${{ true }}  # change to false to skip if release is built by hand
-    needs: create-release
-    steps:
-      - name: Set env
-        shell: bash
-        run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-      # - code below copied from build.yml -
-      - uses: actions/checkout@v4
-      - name: Install python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '~3.12.7'
-          check-latest: true
-      - name: Download run-time dependencies
-        run: |
-          Invoke-WebRequest -Uri https://github.com/Ijwu/Enemizer/releases/download/${Env:ENEMIZER_VERSION}/win-x64.zip -OutFile enemizer.zip
-          Expand-Archive -Path enemizer.zip -DestinationPath EnemizerCLI -Force
-          choco install innosetup --version=6.2.2 --allow-downgrade
-      - name: Build
-        run: |
-          python -m pip install --upgrade pip
-          python setup.py build_exe --yes
-          if ( $? -eq $false ) {
-            Write-Error "setup.py failed!"
-            exit 1
-          }
-          $NAME="$(ls build | Select-String -Pattern 'exe')".Split('.',2)[1]
-          $ZIP_NAME="Archipelago_$NAME.7z"
-          echo "$NAME -> $ZIP_NAME"
-          echo "ZIP_NAME=$ZIP_NAME" >> $Env:GITHUB_ENV
-          New-Item -Path dist -ItemType Directory -Force
-          cd build
-          Rename-Item "exe.$NAME" Archipelago
-          7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
-          Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
-      - name: Build Setup
-        run: |
-          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
-          if ( $? -eq $false ) {
-            Write-Error "Building setup failed!"
-            exit 1
-          }
-          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
-          $SETUP_NAME=$contents[0].Name
-          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
-      # - code above copied from build.yml -
-      - name: Attest Build
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher.exe
-            build/exe.*/ArchipelagoLauncherDebug.exe
-            build/exe.*/ArchipelagoGenerate.exe
-            build/exe.*/ArchipelagoServer.exe
-            setups/*
-      - name: Add to Release
-        uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
-        with:
-          draft: true  # see above
-          prerelease: false
-          name: Archipelago ${{ env.RELEASE_VERSION }}
-          files: |
-            setups/*
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  build-release-ubuntu2204:
-    runs-on: ubuntu-22.04
-    needs: create-release
+  build-release-ubuntu2004:
+    runs-on: ubuntu-20.04
     steps:
       - name: Set env
         run: echo "RELEASE_VERSION=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
@@ -137,7 +64,7 @@ jobs:
           # charset-normalizer was somehow incomplete in the github runner
           "${{ env.PYTHON }}" -m venv venv
           source venv/bin/activate
-          "${{ env.PYTHON }}" -m pip install --upgrade pip "PyGObject<3.51.0" charset-normalizer
+          "${{ env.PYTHON }}" -m pip install --upgrade pip PyGObject charset-normalizer
           python setup.py build_exe --yes bdist_appimage --yes
           echo -e "setup.py build output:\n `ls build`"
           echo -e "setup.py dist output:\n `ls dist`"
@@ -147,14 +74,6 @@ jobs:
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -
-      - name: Attest Build
-        uses: actions/attest-build-provenance@v2
-        with:
-          subject-path: |
-            build/exe.*/ArchipelagoLauncher
-            build/exe.*/ArchipelagoGenerate
-            build/exe.*/ArchipelagoServer
-            dist/*
       - name: Add to Release
         uses: softprops/action-gh-release@975c1b265e11dd76618af1c374e7981f9a6ff44a
         with:

.github/workflows/strict-type-check.yml

@@ -26,7 +26,7 @@ jobs:
 
       - name: "Install dependencies"
         run: |
-          python -m pip install --upgrade pip pyright==1.1.392.post0
+          python -m pip install --upgrade pip pyright==1.1.358
           python ModuleUpdate.py --append "WebHostLib/requirements.txt" --force --yes
 
       - name: "pyright: strict check on specific files"

.gitignore

@@ -4,13 +4,11 @@
 *_Spoiler.txt
 *.bmbp
 *.apbp
-*.apcivvi
 *.apl2ac
 *.apm3
 *.apmc
 *.apz5
 *.aptloz
-*.aptww
 *.apemerald
 *.pyc
 *.pyd

AHITClient.py

@@ -1,4 +1,3 @@
-import sys
 from worlds.ahit.Client import launch
 import Utils
 import ModuleUpdate
@@ -6,4 +5,4 @@ ModuleUpdate.update()
 
 if __name__ == "__main__":
     Utils.init_logging("AHITClient", exception_logger="Client")
-    launch(*sys.argv[1:])
+    launch()

AdventureClient.py

@@ -511,7 +511,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

BaseClasses.py

@@ -9,9 +9,8 @@ from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Literal, Mapping, NamedTuple,
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
                     Optional, Protocol, Set, Tuple, Union, TYPE_CHECKING)
-import dataclasses
 
 from typing_extensions import NotRequired, TypedDict
 
@@ -55,21 +54,12 @@ class HasNameAndPlayer(Protocol):
     player: int
 
 
-@dataclasses.dataclass
-class PlandoItemBlock:
-    player: int
-    from_pool: bool
-    force: bool | Literal["silent"]
-    worlds: set[int] = dataclasses.field(default_factory=set)
-    items: list[str] = dataclasses.field(default_factory=list)
-    locations: list[str] = dataclasses.field(default_factory=list)
-    resolved_locations: list[Location] = dataclasses.field(default_factory=list)
-    count: dict[str, int] = dataclasses.field(default_factory=dict)
-
-
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
+    plando_texts: List[Dict[str, str]]
+    plando_items: List[List[Dict[str, Any]]]
+    plando_connections: List
     worlds: Dict[int, "AutoWorld.World"]
     groups: Dict[int, Group]
     regions: RegionManager
@@ -93,8 +83,6 @@ class MultiWorld():
     start_location_hints: Dict[int, Options.StartLocationHints]
     item_links: Dict[int, Options.ItemLinks]
 
-    plando_item_blocks: Dict[int, List[PlandoItemBlock]]
-
     game: Dict[int, str]
 
     random: random.Random
@@ -172,12 +160,13 @@ class MultiWorld():
         self.local_early_items = {player: {} for player in self.player_ids}
         self.indirect_connections = {}
         self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
-        self.plando_item_blocks = {}
 
         for player in range(1, players + 1):
             def set_player_attr(attr: str, val) -> None:
                 self.__dict__.setdefault(attr, {})[player] = val
-            set_player_attr('plando_item_blocks', [])
+            set_player_attr('plando_items', [])
+            set_player_attr('plando_texts', {})
+            set_player_attr('plando_connections', [])
             set_player_attr('game', "Archipelago")
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
@@ -234,7 +223,7 @@ class MultiWorld():
                               AutoWorld.AutoWorldRegister.world_types[self.game[player]].options_dataclass.type_hints}
         for option_key in all_keys:
             option = Utils.DeprecateDict(f"Getting options from multiworld is now deprecated. "
-                                         f"Please use `self.options.{option_key}` instead.", True)
+                                         f"Please use `self.options.{option_key}` instead.")
             option.update(getattr(args, option_key, {}))
             setattr(self, option_key, option)
 
@@ -384,7 +373,8 @@ class MultiWorld():
                         items_to_add.append(AutoWorld.call_single(self, "create_item", item_player,
                             group["replacement_items"][player]))
                     else:
-                        items_to_add.append(AutoWorld.call_single(self, "create_filler", item_player))
+                        items_to_add.append(AutoWorld.call_single(self, "create_filler", item_player,
+                                                                  AutoWorld.FillerReason.item_link))
                 self.random.shuffle(items_to_add)
                 self.itempool.extend(items_to_add[:itemcount - len(self.itempool)])
 
@@ -438,8 +428,7 @@ class MultiWorld():
     def get_location(self, location_name: str, player: int) -> Location:
         return self.regions.location_cache[player][location_name]
 
-    def get_all_state(self, use_cache: bool, allow_partial_entrances: bool = False,
-                      collect_pre_fill_items: bool = True) -> CollectionState:
+    def get_all_state(self, use_cache: bool, allow_partial_entrances: bool = False) -> CollectionState:
         cached = getattr(self, "_all_state", None)
         if use_cache and cached:
             return cached.copy()
@@ -448,11 +437,10 @@ class MultiWorld():
 
         for item in self.itempool:
             self.worlds[item.player].collect(ret, item)
-        if collect_pre_fill_items:
-            for player in self.player_ids:
-                subworld = self.worlds[player]
-                for item in subworld.get_pre_fill_items():
-                    subworld.collect(ret, item)
+        for player in self.player_ids:
+            subworld = self.worlds[player]
+            for item in subworld.get_pre_fill_items():
+                subworld.collect(ret, item)
         ret.sweep_for_advancements()
 
         if use_cache:
@@ -629,7 +617,7 @@ class MultiWorld():
         locations: Set[Location] = set()
         events: Set[Location] = set()
         for location in self.get_filled_locations():
-            if type(location.item.code) is int and type(location.address) is int:
+            if type(location.item.code) is int:
                 locations.add(location)
             else:
                 events.add(location)
@@ -882,40 +870,21 @@ class CollectionState():
     def has(self, item: str, player: int, count: int = 1) -> bool:
         return self.prog_items[player][item] >= count
 
-    # for loops are specifically used in all/any/count methods, instead of all()/any()/sum(), to avoid the overhead of
-    # creating and iterating generator instances. In `return all(player_prog_items[item] for item in items)`, the
-    # argument to all() would be a new generator instance, for example.
     def has_all(self, items: Iterable[str], player: int) -> bool:
         """Returns True if each item name of items is in state at least once."""
-        player_prog_items = self.prog_items[player]
-        for item in items:
-            if not player_prog_items[item]:
-                return False
-        return True
+        return all(self.prog_items[player][item] for item in items)
 
     def has_any(self, items: Iterable[str], player: int) -> bool:
         """Returns True if at least one item name of items is in state at least once."""
-        player_prog_items = self.prog_items[player]
-        for item in items:
-            if player_prog_items[item]:
-                return True
-        return False
+        return any(self.prog_items[player][item] for item in items)
 
     def has_all_counts(self, item_counts: Mapping[str, int], player: int) -> bool:
         """Returns True if each item name is in the state at least as many times as specified."""
-        player_prog_items = self.prog_items[player]
-        for item, count in item_counts.items():
-            if player_prog_items[item] < count:
-                return False
-        return True
+        return all(self.prog_items[player][item] >= count for item, count in item_counts.items())
 
     def has_any_count(self, item_counts: Mapping[str, int], player: int) -> bool:
         """Returns True if at least one item name is in the state at least as many times as specified."""
-        player_prog_items = self.prog_items[player]
-        for item, count in item_counts.items():
-            if player_prog_items[item] >= count:
-                return True
-        return False
+        return any(self.prog_items[player][item] >= count for item, count in item_counts.items())
 
     def count(self, item: str, player: int) -> int:
         return self.prog_items[player][item]
@@ -943,20 +912,11 @@ class CollectionState():
 
     def count_from_list(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state."""
-        player_prog_items = self.prog_items[player]
-        total = 0
-        for item_name in items:
-            total += player_prog_items[item_name]
-        return total
+        return sum(self.prog_items[player][item_name] for item_name in items)
 
     def count_from_list_unique(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state. Ignores duplicates of the same item."""
-        player_prog_items = self.prog_items[player]
-        total = 0
-        for item_name in items:
-            if player_prog_items[item_name] > 0:
-                total += 1
-        return total
+        return sum(self.prog_items[player][item_name] > 0 for item_name in items)
 
     # item name group related
     def has_group(self, item_name_group: str, player: int, count: int = 1) -> bool:
@@ -1035,6 +995,9 @@ class Entrance:
     connected_region: Optional[Region] = None
     randomization_group: int
     randomization_type: EntranceType
+    # LttP specific, TODO: should make a LttPEntrance
+    addresses = None
+    target = None
 
     def __init__(self, player: int, name: str = "", parent: Optional[Region] = None,
                  randomization_group: int = 0, randomization_type: EntranceType = EntranceType.ONE_WAY) -> None:
@@ -1053,8 +1016,10 @@ class Entrance:
 
         return False
 
-    def connect(self, region: Region) -> None:
+    def connect(self, region: Region, addresses: Any = None, target: Any = None) -> None:
         self.connected_region = region
+        self.target = target
+        self.addresses = addresses
         region.entrances.append(self)
 
     def is_valid_source_transition(self, er_state: "ERPlacementState") -> bool:
@@ -1114,9 +1079,6 @@ class Region:
         def __len__(self) -> int:
             return self._list.__len__()
 
-        def __iter__(self):
-            return iter(self._list)
-
         # This seems to not be needed, but that's a bit suspicious.
         # def __del__(self):
         #     self.clear()
@@ -1211,48 +1173,6 @@ class Region:
         for location, address in locations.items():
             self.locations.append(location_type(self.player, location, address, self))
 
-    def add_event(
-        self,
-        location_name: str,
-        item_name: str | None = None,
-        rule: Callable[[CollectionState], bool] | None = None,
-        location_type: type[Location] | None = None,
-        item_type: type[Item] | None = None,
-        show_in_spoiler: bool = True,
-    ) -> Item:
-        """
-        Adds an event location/item pair to the region.
-
-        :param location_name: Name for the event location.
-        :param item_name: Name for the event item. If not provided, defaults to location_name.
-        :param rule: Callable to determine access for this event location within its region.
-        :param location_type: Location class to create the event location with. Defaults to BaseClasses.Location.
-        :param item_type: Item class to create the event item with. Defaults to BaseClasses.Item.
-        :param show_in_spoiler: Will be passed along to the created event Location's show_in_spoiler attribute.
-        :return: The created Event Item
-        """
-        if location_type is None:
-            location_type = Location
-
-        if item_name is None:
-            item_name = location_name
-
-        if item_type is None:
-            item_type = Item
-
-        event_location = location_type(self.player, location_name, None, self)
-        event_location.show_in_spoiler = show_in_spoiler
-        if rule is not None:
-            event_location.access_rule = rule
-
-        event_item = item_type(item_name, ItemClassification.progression, None, self.player)
-
-        event_location.place_locked_item(event_item)
-
-        self.locations.append(event_location)
-
-        return event_item
-
     def connect(self, connecting_region: Region, name: Optional[str] = None,
                 rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
         """
@@ -1363,6 +1283,9 @@ class Location:
         multiworld = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
+    def __hash__(self):
+        return hash((self.name, self.player))
+
     def __lt__(self, other: Location):
         return (self.player, self.name) < (other.player, other.name)
 
@@ -1466,10 +1389,6 @@ class Item:
     def flags(self) -> int:
         return self.classification.as_flag()
 
-    @property
-    def is_event(self) -> bool:
-        return self.code is None
-
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Item):
             return NotImplemented

CommonClient.py

@@ -31,7 +31,6 @@ import ssl
 
 if typing.TYPE_CHECKING:
     import kvui
-    import argparse
 
 logger = logging.getLogger("Client")
 
@@ -196,11 +195,25 @@ class CommonContext:
             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:
@@ -240,6 +253,7 @@ class CommonContext:
             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.
@@ -341,6 +355,7 @@ class CommonContext:
 
         self.item_names = self.NameLookupDict(self, "item")
         self.location_names = self.NameLookupDict(self, "location")
+        self.versions = {}
         self.checksums = {}
 
         self.jsontotextparser = JSONtoTextParser(self)
@@ -397,8 +412,7 @@ class CommonContext:
             await self.server.socket.close()
         if self.server_task is not None:
             await self.server_task
-        if self.ui:
-            self.ui.update_hints()
+        self.ui.update_hints()
 
     async def send_msgs(self, msgs: typing.List[typing.Any]) -> None:
         """ `msgs` JSON serializable """
@@ -445,13 +459,6 @@ class CommonContext:
         await self.send_msgs([payload])
         await self.send_msgs([{"cmd": "Get", "keys": ["_read_race_mode"]}])
 
-    async def check_locations(self, locations: typing.Collection[int]) -> set[int]:
-        """Send new location checks to the server. Returns the set of actually new locations that were sent."""
-        locations = set(locations) & self.missing_locations
-        if locations:
-            await self.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(locations)}])
-        return locations
-
     async def console_input(self) -> str:
         if self.ui:
             self.ui.focus_textinput()
@@ -555,6 +562,7 @@ class CommonContext:
     
     # DataPackage
     async def prepare_data_package(self, relevant_games: typing.Set[str],
+                                   remote_date_package_versions: typing.Dict[str, int],
                                    remote_data_package_checksums: typing.Dict[str, str]):
         """Validate that all data is present for the current multiworld.
         Download, assimilate and cache missing data from the server."""
@@ -563,26 +571,33 @@ class CommonContext:
 
         needed_updates: typing.Set[str] = set()
         for game in relevant_games:
-            if game not in remote_data_package_checksums:
+            if game not in remote_date_package_versions and game not in remote_data_package_checksums:
                 continue
 
+            remote_version: int = remote_date_package_versions.get(game, 0)
             remote_checksum: typing.Optional[str] = remote_data_package_checksums.get(game)
 
-            if not remote_checksum:  # custom data package and no checksum for this game
+            if remote_version == 0 and not remote_checksum:  # custom data package and no checksum for this game
                 needed_updates.add(game)
                 continue
 
+            cached_version: int = self.versions.get(game, 0)
             cached_checksum: typing.Optional[str] = self.checksums.get(game)
             # no action required if cached version is new enough
-            if remote_checksum != cached_checksum:
+            if (not remote_checksum and (remote_version > cached_version or remote_version == 0)) \
+                    or remote_checksum != cached_checksum:
+                local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
                 local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
-                if remote_checksum == local_checksum:
+                if ((remote_checksum or remote_version <= local_version and remote_version != 0)
+                        and remote_checksum == local_checksum):
                     self.update_game(network_data_package["games"][game], game)
                 else:
                     cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                    cache_version: int = cached_game.get("version", 0)
                     cache_checksum: typing.Optional[str] = cached_game.get("checksum")
                     # download remote version if cache is not new enough
-                    if remote_checksum != cache_checksum:
+                    if (not remote_checksum and (remote_version > cache_version or remote_version == 0)) \
+                            or remote_checksum != cache_checksum:
                         needed_updates.add(game)
                     else:
                         self.update_game(cached_game, game)
@@ -592,6 +607,7 @@ class CommonContext:
     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"])
+        self.versions[game] = game_package.get("version", 0)
         self.checksums[game] = game_package.get("checksum")
 
     def update_data_package(self, data_package: dict):
@@ -600,6 +616,9 @@ class CommonContext:
 
     def consume_network_data_package(self, data_package: dict):
         self.update_data_package(data_package)
+        current_cache = Utils.persistent_load().get("datapackage", {}).get("games", {})
+        current_cache.update(data_package["games"])
+        Utils.persistent_store("datapackage", "games", current_cache)
         logger.info(f"Got new ID/Name DataPackage for {', '.join(data_package['games'])}")
         for game, game_data in data_package["games"].items():
             Utils.store_data_package_for_checksum(game, game_data)
@@ -682,16 +701,8 @@ class CommonContext:
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
         self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
 
-    def make_gui(self) -> "type[kvui.GameManager]":
-        """
-        To return the Kivy `App` class needed for `run_gui` so it can be overridden before being built
-
-        Common changes are changing `base_title` to update the window title of the client and
-        updating `logging_pairs` to automatically make new tabs that can be filled with their respective logger.
-
-        ex. `logging_pairs.append(("Foo", "Bar"))`
-        will add a "Bar" tab which follows the logger returned from `logging.getLogger("Foo")`
-        """
+    def make_gui(self) -> typing.Type["kvui.GameManager"]:
+        """To return the Kivy App class needed for run_gui so it can be overridden before being built"""
         from kvui import GameManager
 
         class TextManager(GameManager):
@@ -862,8 +873,9 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
                         logger.info('    %s (Player %d)' % (network_player.alias, network_player.slot))
 
             # update data package
+            data_package_versions = args.get("datapackage_versions", {})
             data_package_checksums = args.get("datapackage_checksums", {})
-            await ctx.prepare_data_package(set(args["games"]), data_package_checksums)
+            await ctx.prepare_data_package(set(args["games"]), data_package_versions, data_package_checksums)
 
             await ctx.server_auth(args['password'])
 
@@ -879,7 +891,6 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
             ctx.disconnected_intentionally = True
             ctx.event_invalid_game()
         elif 'IncompatibleVersion' in errors:
-            ctx.disconnected_intentionally = True
             raise Exception('Server reported your client version as incompatible. '
                             'This probably means you have to update.')
         elif 'InvalidItemsHandling' in errors:
@@ -1030,32 +1041,6 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-def handle_url_arg(args: "argparse.Namespace",
-                   parser: "typing.Optional[argparse.ArgumentParser]" = None) -> "argparse.Namespace":
-    """
-    Parse the url arg "archipelago://name:pass@host:port" from launcher into correct launch args for CommonClient
-    If alternate data is required the urlparse response is saved back to args.url if valid
-    """
-    if not args.url:
-        return args
-        
-    url = urllib.parse.urlparse(args.url)
-    if url.scheme != "archipelago":
-        if not parser:
-            parser = get_base_parser()
-        parser.error(f"bad url, found {args.url}, expected url in form of archipelago://archipelago.gg:38281")
-        return args
-
-    args.url = url
-    args.connect = url.netloc
-    if url.username:
-        args.name = urllib.parse.unquote(url.username)
-    if url.password:
-        args.password = urllib.parse.unquote(url.password)
-
-    return args
-
-
 def run_as_textclient(*args):
     class TextContext(CommonContext):
         # Text Mode to use !hint and such with games that have no text entry
@@ -1068,7 +1053,7 @@ def run_as_textclient(*args):
             if password_requested and not self.password:
                 await super(TextContext, self).server_auth(password_requested)
             await self.get_username()
-            await self.send_connect(game="")
+            await self.send_connect()
 
         def on_package(self, cmd: str, args: dict):
             if cmd == "Connected":
@@ -1097,10 +1082,20 @@ def run_as_textclient(*args):
     parser.add_argument("url", nargs="?", help="Archipelago connection url")
     args = parser.parse_args(args)
 
-    args = handle_url_arg(args, parser=parser)
+    # handle if text client is launched using the "archipelago://name:pass@host:port" url from webhost
+    if args.url:
+        url = urllib.parse.urlparse(args.url)
+        if url.scheme == "archipelago":
+            args.connect = url.netloc
+            if url.username:
+                args.name = urllib.parse.unquote(url.username)
+            if url.password:
+                args.password = urllib.parse.unquote(url.password)
+        else:
+            parser.error(f"bad url, found {args.url}, expected url in form of archipelago://archipelago.gg:38281")
 
     # use colorama to display colored text highlighting on windows
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main(args))
     colorama.deinit()

FF1Client.py

@@ -261,7 +261,7 @@ if __name__ == '__main__':
 
     parser = get_base_parser()
     args = parser.parse_args()
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main(args))
     colorama.deinit()

FactorioClient.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import ModuleUpdate
+ModuleUpdate.update()
+
+from worlds.factorio.Client import check_stdin, launch
+import Utils
+
+if __name__ == "__main__":
+    Utils.init_logging("FactorioClient", exception_logger="Client")
+    check_stdin()
+    launch()

Fill.py

@@ -4,10 +4,10 @@ import logging
 import typing
 from collections import Counter, deque
 
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, PlandoItemBlock
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
 from Options import Accessibility
 
-from worlds.AutoWorld import call_all
+from worlds.AutoWorld import call_all, FillerReason
 from worlds.generic.Rules import add_item_rule
 
 
@@ -75,11 +75,9 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                 items_to_place.append(reachable_items[next_player].pop())
 
         for item in items_to_place:
-            # The items added into `reachable_items` are placed starting from the end of each deque in
-            # `reachable_items`, so the items being placed are more likely to be found towards the end of `item_pool`.
-            for p, pool_item in enumerate(reversed(item_pool), start=1):
+            for p, pool_item in enumerate(item_pool):
                 if pool_item is item:
-                    del item_pool[-p]
+                    item_pool.pop(p)
                     break
 
         maximum_exploration_state = sweep_from_pool(
@@ -100,7 +98,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
             # if minimal accessibility, only check whether location is reachable if game not beatable
             if multiworld.worlds[item_to_place.player].options.accessibility == Accessibility.option_minimal:
                 perform_access_check = not multiworld.has_beaten_game(maximum_exploration_state,
-                                                                      item_to_place.player) \
+                                                                 item_to_place.player) \
                     if single_player_placement else not has_beaten_game
             else:
                 perform_access_check = True
@@ -242,7 +240,7 @@ def remaining_fill(multiworld: MultiWorld,
     unplaced_items: typing.List[Item] = []
     placements: typing.List[Location] = []
     swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
-    total = min(len(itempool), len(locations))
+    total = min(len(itempool),  len(locations))
     placed = 0
 
     # Optimisation: Decide whether to do full location.can_fill check (respect excluded), or only check the item rule
@@ -318,7 +316,7 @@ def remaining_fill(multiworld: MultiWorld,
             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())
+                last_batch.append(multiworld.worlds[item.player].create_filler(FillerReason.panic_fill))
             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"
@@ -343,19 +341,17 @@ def fast_fill(multiworld: MultiWorld,
 
 def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, locations, pool=[]):
     maximum_exploration_state = sweep_from_pool(state, pool)
-    minimal_players = {player for player in multiworld.player_ids if
-                       multiworld.worlds[player].options.accessibility == "minimal"}
-    unreachable_locations = [location for location in multiworld.get_locations() if
-                             location.player in minimal_players and
+    minimal_players = {player for player in multiworld.player_ids if multiworld.worlds[player].options.accessibility == "minimal"}
+    unreachable_locations = [location for location in multiworld.get_locations() if location.player in minimal_players and
                              not location.can_reach(maximum_exploration_state)]
     for location in unreachable_locations:
         if (location.item is not None and location.item.advancement and location.address is not None and not
                 location.locked and location.item.player not in minimal_players):
             pool.append(location.item)
+            state.remove(location.item)
             location.item = None
             if location in state.advancements:
                 state.advancements.remove(location)
-                state.remove(location.item)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
@@ -367,7 +363,7 @@ def inaccessible_location_rules(multiworld: MultiWorld, state: CollectionState,
     unreachable_locations = [location for location in locations if not location.can_reach(maximum_exploration_state)]
     if unreachable_locations:
         def forbid_important_item_rule(item: Item):
-            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != "minimal")
+            return not ((item.classification & 0b0011) and multiworld.worlds[item.player].options.accessibility != 'minimal')
 
         for location in unreachable_locations:
             add_item_rule(location, forbid_important_item_rule)
@@ -504,37 +500,28 @@ def distribute_items_restrictive(multiworld: MultiWorld,
 
     if prioritylocations:
         # "priority fill"
-        maximum_exploration_state = sweep_from_pool(multiworld.state)
-        fill_restrictive(multiworld, maximum_exploration_state, prioritylocations, progitempool,
+        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
                          single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                         name="Priority", one_item_per_player=True, allow_partial=True)
-
-        if prioritylocations:
-            # retry with one_item_per_player off because some priority fills can fail to fill with that optimization
-            maximum_exploration_state = sweep_from_pool(multiworld.state)
-            fill_restrictive(multiworld, maximum_exploration_state, prioritylocations, progitempool,
-                            single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                            name="Priority Retry", one_item_per_player=False)
+                         name="Priority", one_item_per_player=False)
         accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
         # "advancement/progression fill"
-        maximum_exploration_state = sweep_from_pool(multiworld.state)
         if panic_method == "swap":
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=True,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=True,
                              name="Progression", single_player_placement=single_player)
         elif panic_method == "raise":
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=False,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
                              name="Progression", single_player_placement=single_player)
         elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, maximum_exploration_state, defaultlocations, progitempool, swap=False,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
                              allow_partial=True, name="Progression", single_player_placement=single_player)
             if progitempool:
                 for item in progitempool:
                     logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
                     multiworld.push_precollected(item)
-                    filleritempool.append(multiworld.worlds[item.player].create_filler())
+                    filleritempool.append(multiworld.worlds[item.player].create_filler(FillerReason.panic_fill))
                 logging.warning(f"{len(progitempool)} items moved to start inventory,"
                                 f" due to failure in Progression fill step.")
                 progitempool[:] = []
@@ -558,7 +545,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")
+                   move_unplaceable_to_start_inventory=panic_method == "start_inventory")
 
     if excludedlocations:
         raise FillError(
@@ -570,7 +557,7 @@ def distribute_items_restrictive(multiworld: MultiWorld,
     restitempool = filleritempool + usefulitempool
 
     remaining_fill(multiworld, defaultlocations, restitempool,
-                   move_unplaceable_to_start_inventory=panic_method=="start_inventory")
+                   move_unplaceable_to_start_inventory=panic_method == "start_inventory")
 
     unplaced = restitempool
     unfilled = defaultlocations
@@ -584,26 +571,6 @@ def distribute_items_restrictive(multiworld: MultiWorld,
         print_data = {"items": items_counter, "locations": locations_counter}
         logging.info(f"Per-Player counts: {print_data})")
 
-        more_locations = locations_counter - items_counter
-        more_items = items_counter - locations_counter
-        for player in multiworld.player_ids:
-            if more_locations[player]:
-                logging.error(
-                    f"Player {multiworld.get_player_name(player)} had {more_locations[player]} more locations than items.")
-            elif more_items[player]:
-                logging.warning(
-                    f"Player {multiworld.get_player_name(player)} had {more_items[player]} more items than locations.")
-        if unfilled:
-            raise FillError(
-                f"Unable to fill all locations.\n" +
-                f"Unfilled locations({len(unfilled)}): {unfilled}"
-            )
-        else:
-            logging.warning(
-                f"Unable to place all items.\n" +
-                f"Unplaced items({len(unplaced)}): {unplaced}"
-            )
-
 
 def flood_items(multiworld: MultiWorld) -> None:
     # get items to distribute
@@ -679,9 +646,9 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
         if multiworld.worlds[player].options.progression_balancing > 0
     }
     if not balanceable_players:
-        logging.info("Skipping multiworld progression balancing.")
+        logging.info('Skipping multiworld progression balancing.')
     else:
-        logging.info(f"Balancing multiworld progression for {len(balanceable_players)} Players.")
+        logging.info(f'Balancing multiworld progression for {len(balanceable_players)} Players.')
         logging.debug(balanceable_players)
         state: CollectionState = CollectionState(multiworld)
         checked_locations: typing.Set[Location] = set()
@@ -779,7 +746,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                                 if player in threshold_percentages):
                             break
                         elif not balancing_sphere:
-                            raise RuntimeError("Not all required items reachable. Something went terribly wrong here.")
+                            raise RuntimeError('Not all required items reachable. Something went terribly wrong here.')
                     # Gather a set of locations which we can swap items into
                     unlocked_locations: typing.Dict[int, typing.Set[Location]] = collections.defaultdict(set)
                     for l in unchecked_locations:
@@ -795,8 +762,8 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             testing = items_to_test.pop()
                             reducing_state = state.copy()
                             for location in itertools.chain((
-                                    l for l in items_to_replace
-                                    if l.item.player == player
+                                l for l in items_to_replace
+                                if l.item.player == player
                             ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
@@ -869,30 +836,52 @@ def swap_location_item(location_1: Location, location_2: Location, check_locked:
     location_2.item.location = location_2
 
 
-def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlock]]:
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
+def distribute_planned(multiworld: MultiWorld) -> None:
+    def warn(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure', 'none', False, 'warn', 'warning']:
+            logging.warning(f'{warning}')
         else:
-            logging.debug(f"{warning}")
+            logging.debug(f'{warning}')
 
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
+    def failed(warning: str, force: typing.Union[bool, str]) -> None:
+        if force in [True, 'fail', 'failure']:
             raise Exception(warning)
         else:
             warn(warning, force)
 
+    swept_state = multiworld.state.copy()
+    swept_state.sweep_for_advancements()
+    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
+    early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
+    for loc in multiworld.get_unfilled_locations():
+        if loc in reachable:
+            early_locations[loc.player].append(loc.name)
+        else:  # not reachable with swept state
+            non_early_locations[loc.player].append(loc.name)
+
     world_name_lookup = multiworld.world_name_lookup
 
-    plando_blocks: dict[int, list[PlandoItemBlock]] = dict()
-    player_ids: set[int] = set(multiworld.player_ids)
+    block_value = typing.Union[typing.List[str], typing.Dict[str, typing.Any], str]
+    plando_blocks: typing.List[typing.Dict[str, typing.Any]] = []
+    player_ids = set(multiworld.player_ids)
     for player in player_ids:
-        plando_blocks[player] = []
-        for block in multiworld.worlds[player].options.plando_items:
-            new_block: PlandoItemBlock = PlandoItemBlock(player, block.from_pool, block.force)
-            target_world = block.world
+        for block in multiworld.plando_items[player]:
+            block['player'] = player
+            if 'force' not in block:
+                block['force'] = 'silent'
+            if 'from_pool' not in block:
+                block['from_pool'] = True
+            elif not isinstance(block['from_pool'], bool):
+                from_pool_type = type(block['from_pool'])
+                raise Exception(f'Plando "from_pool" has to be boolean, not {from_pool_type} for player {player}.')
+            if 'world' not in block:
+                target_world = False
+            else:
+                target_world = block['world']
+
             if target_world is False or multiworld.players == 1:  # target own world
-                worlds: set[int] = {player}
+                worlds: typing.Set[int] = {player}
             elif target_world is True:  # target any worlds besides own
                 worlds = set(multiworld.player_ids) - {player}
             elif target_world is None:  # target all worlds
@@ -902,197 +891,172 @@ def parse_planned_blocks(multiworld: MultiWorld) -> dict[int, list[PlandoItemBlo
                 for listed_world in target_world:
                     if listed_world not in world_name_lookup:
                         failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                               block.force)
+                               block['force'])
                         continue
                     worlds.add(world_name_lookup[listed_world])
             elif type(target_world) == int:  # target world by slot number
                 if target_world not in range(1, multiworld.players + 1):
                     failed(
                         f"Cannot place item in world {target_world} as it is not in range of (1, {multiworld.players})",
-                        block.force)
+                        block['force'])
                     continue
                 worlds = {target_world}
             else:  # target world by slot name
                 if target_world not in world_name_lookup:
                     failed(f"Cannot place item to {target_world}'s world as that world does not exist.",
-                           block.force)
+                           block['force'])
                     continue
                 worlds = {world_name_lookup[target_world]}
-            new_block.worlds = worlds
+            block['world'] = worlds
 
-            items: list[str] | dict[str, typing.Any] = block.items
+            items: block_value = []
+            if "items" in block:
+                items = block["items"]
+                if 'count' not in block:
+                    block['count'] = False
+            elif "item" in block:
+                items = block["item"]
+                if 'count' not in block:
+                    block['count'] = 1
+            else:
+                failed("You must specify at least one item to place items with plando.", block['force'])
+                continue
             if isinstance(items, dict):
-                item_list: list[str] = []
+                item_list: typing.List[str] = []
                 for key, value in items.items():
                     if value is True:
                         value = multiworld.itempool.count(multiworld.worlds[player].create_item(key))
                     item_list += [key] * value
                 items = item_list
-            new_block.items = items
+            if isinstance(items, str):
+                items = [items]
+            block['items'] = items
 
-            locations: list[str] = block.locations
+            locations: block_value = []
+            if 'location' in block:
+                locations = block['location']  # just allow 'location' to keep old yamls compatible
+            elif 'locations' in block:
+                locations = block['locations']
             if isinstance(locations, str):
                 locations = [locations]
 
-            locations_from_groups: list[str] = []
-            resolved_locations: list[Location] = []
-            for target_player in worlds:
-                world_locations = multiworld.get_unfilled_locations(target_player)
-                for group in multiworld.worlds[target_player].location_name_groups:
-                    if group in locations:
-                        locations_from_groups.extend(multiworld.worlds[target_player].location_name_groups[group])
-                resolved_locations.extend(location for location in world_locations
-                                          if location.name in [*locations, *locations_from_groups])
-            new_block.locations = sorted(dict.fromkeys(locations))
-            new_block.resolved_locations = sorted(set(resolved_locations))
+            if isinstance(locations, dict):
+                location_list = []
+                for key, value in locations.items():
+                    location_list += [key] * value
+                locations = location_list
 
-            count = block.count
-            if not count:
-                count = len(new_block.items)
-            if isinstance(count, int):
-                count = {"min": count, "max": count}
-            if "min" not in count:
-                count["min"] = 0
-            if "max" not in count:
-                count["max"] = len(new_block.items)
-
-            new_block.count = count
-            plando_blocks[player].append(new_block)
-
-    return plando_blocks
-
-
-def resolve_early_locations_for_planned(multiworld: MultiWorld):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
-
-    swept_state = multiworld.state.copy()
-    swept_state.sweep_for_advancements()
-    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
-    early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    non_early_locations: dict[int, list[Location]] = collections.defaultdict(list)
-    for loc in multiworld.get_unfilled_locations():
-        if loc in reachable:
-            early_locations[loc.player].append(loc)
-        else:  # not reachable with swept state
-            non_early_locations[loc.player].append(loc)
-
-    for player in multiworld.plando_item_blocks:
-        removed = []
-        for block in multiworld.plando_item_blocks[player]:
-            locations = block.locations
-            resolved_locations = block.resolved_locations
-            worlds = block.worlds
             if "early_locations" in locations:
+                locations.remove("early_locations")
                 for target_player in worlds:
-                    resolved_locations += early_locations[target_player]
+                    locations += early_locations[target_player]
             if "non_early_locations" in locations:
+                locations.remove("non_early_locations")
                 for target_player in worlds:
-                    resolved_locations += non_early_locations[target_player]
+                    locations += non_early_locations[target_player]
 
-            if block.count["max"] > len(block.items):
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than items specified", block.force)
-                block.count["max"] = len(block.items)
-                if block.count["min"] > len(block.items):
-                    block.count["min"] = len(block.items)
-            if block.count["max"] > len(block.resolved_locations) > 0:
-                count = block.count["max"]
-                failed(f"Plando count {count} greater than locations specified", block.force)
-                block.count["max"] = len(block.resolved_locations)
-                if block.count["min"] > len(block.resolved_locations):
-                    block.count["min"] = len(block.resolved_locations)
-            block.count["target"] = multiworld.random.randint(block.count["min"],
-                                                                     block.count["max"])
+            block['locations'] = list(dict.fromkeys(locations))
 
-            if not block.count["target"]:
-                removed.append(block)
+            if not block['count']:
+                block['count'] = (min(len(block['items']), len(block['locations'])) if
+                                  len(block['locations']) > 0 else len(block['items']))
+            if isinstance(block['count'], int):
+                block['count'] = {'min': block['count'], 'max': block['count']}
+            if 'min' not in block['count']:
+                block['count']['min'] = 0
+            if 'max' not in block['count']:
+                block['count']['max'] = (min(len(block['items']), len(block['locations'])) if
+                                         len(block['locations']) > 0 else len(block['items']))
+            if block['count']['max'] > len(block['items']):
+                count = block['count']
+                failed(f"Plando count {count} greater than items specified", block['force'])
+                block['count'] = len(block['items'])
+            if block['count']['max'] > len(block['locations']) > 0:
+                count = block['count']
+                failed(f"Plando count {count} greater than locations specified", block['force'])
+                block['count'] = len(block['locations'])
+            block['count']['target'] = multiworld.random.randint(block['count']['min'], block['count']['max'])
 
-        for block in removed:
-            multiworld.plando_item_blocks[player].remove(block)
-
-
-def distribute_planned_blocks(multiworld: MultiWorld, plando_blocks: list[PlandoItemBlock]):
-    def warn(warning: str, force: bool | str) -> None:
-        if isinstance(force, bool):
-            logging.warning(f"{warning}")
-        else:
-            logging.debug(f"{warning}")
-
-    def failed(warning: str, force: bool | str) -> None:
-        if force is True:
-            raise Exception(warning)
-        else:
-            warn(warning, force)
+            if block['count']['target'] > 0:
+                plando_blocks.append(block)
 
     # shuffle, but then sort blocks by number of locations minus number of items,
     # so less-flexible blocks get priority
     multiworld.random.shuffle(plando_blocks)
-    plando_blocks.sort(key=lambda block: (len(block.resolved_locations) - block.count["target"]
-                                          if len(block.resolved_locations) > 0
-                                          else len(multiworld.get_unfilled_locations(block.player)) -
-                                          block.count["target"]))
+    plando_blocks.sort(key=lambda block: (len(block['locations']) - block['count']['target']
+                                          if len(block['locations']) > 0
+                                          else len(multiworld.get_unfilled_locations(player)) - block['count']['target']))
+
     for placement in plando_blocks:
-        player = placement.player
+        player = placement['player']
         try:
-            worlds = placement.worlds
-            locations = placement.resolved_locations
-            items = placement.items
-            maxcount = placement.count["target"]
-            from_pool = placement.from_pool
+            worlds = placement['world']
+            locations = placement['locations']
+            items = placement['items']
+            maxcount = placement['count']['target']
+            from_pool = placement['from_pool']
 
-            item_candidates = []
-            if from_pool:
-                instances = [item for item in multiworld.itempool if item.player == player and item.name in items]
-                for item in multiworld.random.sample(items, maxcount):
-                    candidate = next((i for i in instances if i.name == item), None)
-                    if candidate is None:
-                        warn(f"Could not remove {item} from pool for {multiworld.player_name[player]} as "
-                             f"it's already missing from it", placement.force)
-                        candidate = multiworld.worlds[player].create_item(item)
-                    else:
-                        multiworld.itempool.remove(candidate)
-                        instances.remove(candidate)
-                    item_candidates.append(candidate)
-            else:
-                item_candidates = [multiworld.worlds[player].create_item(item)
-                                   for item in multiworld.random.sample(items, maxcount)]
-            if any(item.code is None for item in item_candidates) \
-               and not all(item.code is None for item in item_candidates):
-                failed(f"Plando block for player {player} ({multiworld.player_name[player]}) contains both "
-                       f"event items and non-event items. "
-                       f"Event items: {[item for item in item_candidates if item.code is None]}, "
-                       f"Non-event items: {[item for item in item_candidates if item.code is not None]}",
-                       placement.force)
-                continue
-            else:
-                is_real = item_candidates[0].code is not None
-            candidates = [candidate for candidate in locations if candidate.item is None
-                          and bool(candidate.address) == is_real]
+            candidates = list(multiworld.get_unfilled_locations_for_players(locations, sorted(worlds)))
             multiworld.random.shuffle(candidates)
-            allstate = multiworld.get_all_state(False)
-            mincount = placement.count["min"]
-            allowed_margin = len(item_candidates) - mincount
-            fill_restrictive(multiworld, allstate, candidates, item_candidates, lock=True,
-                             allow_partial=True, name="Plando Main Fill")
+            multiworld.random.shuffle(items)
+            count = 0
+            err: typing.List[str] = []
+            successful_pairs: typing.List[typing.Tuple[int, Item, Location]] = []
+            claimed_indices: typing.Set[typing.Optional[int]] = set()
+            for item_name in items:
+                index_to_delete: typing.Optional[int] = None
+                if from_pool:
+                    try:
+                        # If from_pool, try to find an existing item with this name & player in the itempool and use it
+                        index_to_delete, item = next(
+                            (i, item) for i, item in enumerate(multiworld.itempool)
+                            if item.player == player and item.name == item_name and i not in claimed_indices
+                        )
+                    except StopIteration:
+                        warn(
+                        f"Could not remove {item_name} from pool for {multiworld.player_name[player]} as it's already missing from it.",
+                        placement['force'])
+                        item = multiworld.worlds[player].create_item(item_name)
+                else:
+                    item = multiworld.worlds[player].create_item(item_name)
+
+                for location in reversed(candidates):
+                    if (location.address is None) == (item.code is None):  # either both None or both not None
+                        if not location.item:
+                            if location.item_rule(item):
+                                if location.can_fill(multiworld.state, item, False):
+                                    successful_pairs.append((index_to_delete, item, location))
+                                    claimed_indices.add(index_to_delete)
+                                    candidates.remove(location)
+                                    count = count + 1
+                                    break
+                                else:
+                                    err.append(f"Can't place item at {location} due to fill condition not met.")
+                            else:
+                                err.append(f"{item_name} not allowed at {location}.")
+                        else:
+                            err.append(f"Cannot place {item_name} into already filled location {location}.")
+                    else:
+                        err.append(f"Mismatch between {item_name} and {location}, only one is an event.")
+
+                if count == maxcount:
+                    break
+            if count < placement['count']['min']:
+                m = placement['count']['min']
+                failed(
+                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
+                    placement['force'])
+
+            # Sort indices in reverse so we can remove them one by one
+            successful_pairs = sorted(successful_pairs, key=lambda successful_pair: successful_pair[0] or 0, reverse=True)
+
+            for (index, item, location) in successful_pairs:
+                multiworld.push_item(location, item, collect=False)
+                location.locked = True
+                logging.debug(f"Plando placed {item} at {location}")
+                if index is not None:  # If this item is from_pool and was found in the pool, remove it.
+                    multiworld.itempool.pop(index)
 
-            if len(item_candidates) > allowed_margin:
-                failed(f"Could not place {len(item_candidates)} "
-                       f"of {mincount + allowed_margin} item(s) "
-                       f"for {multiworld.player_name[player]}, "
-                       f"remaining items: {item_candidates}",
-                       placement.force)
-            if from_pool:
-                multiworld.itempool.extend([item for item in item_candidates if item.code is not None])
         except Exception as e:
             raise Exception(
                 f"Error running plando for player {player} ({multiworld.player_name[player]})") from e

Generate.py

@@ -10,8 +10,8 @@ import sys
 import urllib.parse
 import urllib.request
 from collections import Counter
+from typing import Any, Dict, Tuple, Union
 from itertools import chain
-from typing import Any
 
 import ModuleUpdate
 
@@ -42,9 +42,7 @@ def mystery_argparse():
                         help="Path to output folder. Absolute or relative to cwd.")  # absolute or relative to cwd
     parser.add_argument('--race', action='store_true', default=defaults.race)
     parser.add_argument('--meta_file_path', default=defaults.meta_file_path)
-    parser.add_argument('--log_level', default=defaults.loglevel, help='Sets log level')
-    parser.add_argument('--log_time', help="Add timestamps to STDOUT",
-                        default=defaults.logtime, action='store_true')
+    parser.add_argument('--log_level', default='info', help='Sets log level')
     parser.add_argument("--csv_output", action="store_true",
                         help="Output rolled player options to csv (made for async multiworld).")
     parser.add_argument("--plando", default=defaults.plando_options,
@@ -54,22 +52,12 @@ def mystery_argparse():
     parser.add_argument("--skip_output", action="store_true",
                         help="Skips generation assertion and output stages and skips multidata and spoiler output. "
                              "Intended for debugging and testing purposes.")
-    parser.add_argument("--spoiler_only", action="store_true",
-                        help="Skips generation assertion and multidata, outputting only a spoiler log. "
-                             "Intended for debugging and testing purposes.")
     args = parser.parse_args()
-
-    if args.skip_output and args.spoiler_only:
-        parser.error("Cannot mix --skip_output and --spoiler_only")
-    elif args.spoiler == 0 and args.spoiler_only:
-        parser.error("Cannot use --spoiler_only when --spoiler=0. Use --skip_output or set --spoiler to a different value")
-
     if not os.path.isabs(args.weights_file_path):
         args.weights_file_path = os.path.join(args.player_files_path, args.weights_file_path)
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
     args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
-
     return args
 
 
@@ -77,7 +65,7 @@ def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None) -> tuple[argparse.Namespace, int]:
+def main(args=None) -> Tuple[argparse.Namespace, int]:
     # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
     if __name__ == "__main__" and "worlds" in sys.modules:
         raise Exception("Worlds system should not be loaded before logging init.")
@@ -87,7 +75,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
 
     seed = get_seed(args.seed)
 
-    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
     random.seed(seed)
     seed_name = get_seed_name(random)
 
@@ -95,7 +83,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
         logging.info("Race mode enabled. Using non-deterministic random source.")
         random.seed()  # reset to time-based random source
 
-    weights_cache: dict[str, tuple[Any, ...]] = {}
+    weights_cache: Dict[str, Tuple[Any, ...]] = {}
     if args.weights_file_path and os.path.exists(args.weights_file_path):
         try:
             weights_cache[args.weights_file_path] = read_weights_yamls(args.weights_file_path)
@@ -118,8 +106,6 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
             raise Exception("Cannot mix --sameoptions with --meta")
     else:
         meta_weights = None
-
-
     player_id = 1
     player_files = {}
     for file in os.scandir(args.player_files_path):
@@ -176,11 +162,10 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     erargs.outputpath = args.outputpath
     erargs.skip_prog_balancing = args.skip_prog_balancing
     erargs.skip_output = args.skip_output
-    erargs.spoiler_only = args.spoiler_only
     erargs.name = {}
     erargs.csv_output = args.csv_output
 
-    settings_cache: dict[str, tuple[argparse.Namespace, ...]] = \
+    settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
         {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
          for fname, yamls in weights_cache.items()}
 
@@ -212,7 +197,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
         path = player_path_cache[player]
         if path:
             try:
-                settings: tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
+                settings: Tuple[argparse.Namespace, ...] = settings_cache[path] if settings_cache[path] else \
                     tuple(roll_settings(yaml, args.plando) for yaml in weights_cache[path])
                 for settingsObject in settings:
                     for k, v in vars(settingsObject).items():
@@ -242,7 +227,7 @@ def main(args=None) -> tuple[argparse.Namespace, int]:
     return erargs, seed
 
 
-def read_weights_yamls(path) -> tuple[Any, ...]:
+def read_weights_yamls(path) -> Tuple[Any, ...]:
     try:
         if urllib.parse.urlparse(path).scheme in ('https', 'file'):
             yaml = str(urllib.request.urlopen(path).read(), "utf-8-sig")
@@ -252,20 +237,7 @@ def read_weights_yamls(path) -> tuple[Any, ...]:
     except Exception as e:
         raise Exception(f"Failed to read weights ({path})") from e
 
-    from yaml.error import MarkedYAMLError
-    try:
-        return tuple(parse_yamls(yaml))
-    except MarkedYAMLError as ex:
-        if ex.problem_mark:
-            lines = yaml.splitlines()
-            if ex.context_mark:
-                relevant_lines = "\n".join(lines[ex.context_mark.line:ex.problem_mark.line+1])
-            else:
-                relevant_lines = lines[ex.problem_mark.line]
-            error_line = " " * ex.problem_mark.column + "^"
-            raise Exception(f"{ex.context} {ex.problem} on line {ex.problem_mark.line}:"
-                            f"\n{relevant_lines}\n{error_line}")
-        raise ex
+    return tuple(parse_yamls(yaml))
 
 
 def interpret_on_off(value) -> bool:
@@ -305,35 +277,33 @@ def get_choice(option, root, value=None) -> Any:
     raise RuntimeError(f"All options specified in \"{option}\" are weighted as zero.")
 
 
-class SafeFormatter(string.Formatter):
-    def get_value(self, key, args, kwargs):
-        if isinstance(key, int):
-            if key < len(args):
-                return args[key]
-            else:
-                return "{" + str(key) + "}"
-        else:
-            return kwargs.get(key, "{" + key + "}")
+class SafeDict(dict):
+    def __missing__(self, key):
+        return '{' + key + '}'
 
 
 def handle_name(name: str, player: int, name_counter: Counter):
     name_counter[name.lower()] += 1
     number = name_counter[name.lower()]
     new_name = "%".join([x.replace("%number%", "{number}").replace("%player%", "{player}") for x in name.split("%%")])
-
-    new_name = SafeFormatter().vformat(new_name, (), {"number": number,
-                                                      "NUMBER": (number if number > 1 else ''),
-                                                      "player": player,
-                                                      "PLAYER": (player if player > 1 else '')})
+    new_name = string.Formatter().vformat(new_name, (), SafeDict(number=number,
+                                                                 NUMBER=(number if number > 1 else ''),
+                                                                 player=player,
+                                                                 PLAYER=(player if player > 1 else '')))
     # Run .strip twice for edge case where after the initial .slice new_name has a leading whitespace.
     # Could cause issues for some clients that cannot handle the additional whitespace.
     new_name = new_name.strip()[:16].strip()
-
     if new_name == "Archipelago":
         raise Exception(f"You cannot name yourself \"{new_name}\"")
     return new_name
 
 
+def roll_percentage(percentage: Union[int, float]) -> bool:
+    """Roll a percentage chance.
+    percentage is expected to be in range [0, 100]"""
+    return random.random() < (float(percentage) / 100)
+
+
 def update_weights(weights: dict, new_weights: dict, update_type: str, name: str) -> dict:
     logging.debug(f'Applying {new_weights}')
     cleaned_weights = {}
@@ -378,7 +348,7 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
     return weights
 
 
-def roll_meta_option(option_key, game: str, category_dict: dict) -> Any:
+def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
     from worlds import AutoWorldRegister
 
     if not game:
@@ -399,7 +369,7 @@ def roll_linked_options(weights: dict) -> dict:
         if "name" not in option_set:
             raise ValueError("One of your linked options does not have a name.")
         try:
-            if Options.roll_percentage(option_set["percentage"]):
+            if roll_percentage(option_set["percentage"]):
                 logging.debug(f"Linked option {option_set['name']} triggered.")
                 new_options = option_set["options"]
                 for category_name, category_options in new_options.items():
@@ -432,7 +402,7 @@ def roll_triggers(weights: dict, triggers: list, valid_keys: set) -> dict:
             trigger_result = get_choice("option_result", option_set)
             result = get_choice(key, currently_targeted_weights)
             currently_targeted_weights[key] = result
-            if result == trigger_result and Options.roll_percentage(get_choice("percentage", option_set, 100)):
+            if result == trigger_result and roll_percentage(get_choice("percentage", option_set, 100)):
                 for category_name, category_options in option_set["options"].items():
                     currently_targeted_weights = weights
                     if category_name:
@@ -463,20 +433,12 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
 
 
 def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
-    """
-    Roll options from specified weights, usually originating from a .yaml options file.
-
-    Important note:
-    The same weights dict is shared between all slots using the same yaml (e.g. generic weights file for filler slots).
-    This means it should never be modified without making a deepcopy first.
-    """
-
     from worlds import AutoWorldRegister
 
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
-    valid_keys = {"triggers"}
+    valid_keys = set()
     if "triggers" in weights:
         weights = roll_triggers(weights, weights["triggers"], valid_keys)
 
@@ -535,18 +497,15 @@ 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)
-
-    if ret.game == "A Link to the Past":
-        # TODO there are still more LTTP options not on the options system
-        valid_keys |= {"sprite_pool", "sprite", "random_sprite_on_event"}
-        roll_alttp_settings(ret, game_weights)
-
-    # log a warning for options within a game section that aren't determined as valid
     for option_key in game_weights:
-        if option_key in valid_keys:
+        if option_key in {"triggers", *valid_keys}:
             continue
         logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers "
                         f"for player {ret.name}.")
+    if PlandoOptions.items in plando_options:
+        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
+    if ret.game == "A Link to the Past":
+        roll_alttp_settings(ret, game_weights)
 
     return ret
 

Launcher.py

@@ -1,14 +1,16 @@
 """
-Archipelago Launcher
+Archipelago launcher for bundled app.
 
-* If run with a patch file as argument, launch corresponding client with the patch file as an argument.
-* If run with component name as argument, run it passing argv[2:] as arguments.
-* If run without arguments or unknown arguments, open launcher GUI.
+* if run with APBP as argument, launch corresponding client.
+* if run with executable as argument, run it passing argv[2:] as arguments
+* if run without arguments, open launcher GUI
 
-Additional components can be added to worlds.LauncherComponents.components.
+Scroll down to components= to add components to the launcher as well as setup.py
 """
 
+
 import argparse
+import itertools
 import logging
 import multiprocessing
 import shlex
@@ -16,14 +18,12 @@ import subprocess
 import sys
 import urllib.parse
 import webbrowser
-from collections.abc import Callable, Sequence
 from os.path import isfile
 from shutil import which
-from typing import Any
+from typing import Callable, Optional, Sequence, Tuple, Union
 
 if __name__ == "__main__":
     import ModuleUpdate
-
     ModuleUpdate.update()
 
 import settings
@@ -85,16 +85,12 @@ def browse_files():
 def open_folder(folder_path):
     if is_linux:
         exe = which('xdg-open') or which('gnome-open') or which('kde-open')
+        subprocess.Popen([exe, folder_path])
     elif is_macos:
         exe = which("open")
-    else:
-        webbrowser.open(folder_path)
-        return
-
-    if exe:
         subprocess.Popen([exe, folder_path])
     else:
-        logging.warning(f"No file browser available to open {folder_path}")
+        webbrowser.open(folder_path)
 
 
 def update_settings():
@@ -109,17 +105,16 @@ components.extend([
     Component("Generate Template Options", func=generate_yamls),
     Component("Archipelago Website", func=lambda: webbrowser.open("https://archipelago.gg/")),
     Component("Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/8Z65BR2")),
-    Component("Unrated/18+ Discord Server", icon="discord",
-              func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
+    Component("Unrated/18+ Discord Server", icon="discord", func=lambda: webbrowser.open("https://discord.gg/fqvNCCRsu4")),
     Component("Browse Files", func=browse_files),
 ])
 
 
-def handle_uri(path: str, launch_args: tuple[str, ...]) -> None:
+def handle_uri(path: str, launch_args: Tuple[str, ...]) -> None:
     url = urllib.parse.urlparse(path)
     queries = urllib.parse.parse_qs(url.query)
     launch_args = (path, *launch_args)
-    client_component = []
+    client_component = None
     text_client_component = None
     if "game" in queries:
         game = queries["game"][0]
@@ -127,43 +122,52 @@ def handle_uri(path: str, launch_args: tuple[str, ...]) -> None:
         game = "Archipelago"
     for component in components:
         if component.supports_uri and component.game_name == game:
-            client_component.append(component)
+            client_component = component
         elif component.display_name == "Text Client":
             text_client_component = component
 
-    from kvui import MDButton, MDButtonText
-    from kivymd.uix.dialog import MDDialog, MDDialogHeadlineText, MDDialogContentContainer, MDDialogSupportingText
-    from kivymd.uix.divider import MDDivider
-
-    if not client_component:
+    if client_component is None:
         run_component(text_client_component, *launch_args)
         return
-    else:
-        popup_text = MDDialogSupportingText(text="Select client to open and connect with.")
-        component_buttons = [MDDivider()]
-        for component in [text_client_component, *client_component]:
-            component_buttons.append(MDButton(
-                MDButtonText(text=component.display_name),
-                on_release=lambda *args, comp=component: run_component(comp, *launch_args),
-                style="text"
-            ))
-        component_buttons.append(MDDivider())
 
-    MDDialog(
-        # Headline
-        MDDialogHeadlineText(text="Connect to Multiworld"),
-        # Text
-        popup_text,
-        # Content
-        MDDialogContentContainer(
-            *component_buttons,
-            orientation="vertical"
-        ),
+    from kvui import App, Button, BoxLayout, Label, Window
 
-    ).open()
+    class Popup(App):
+        def __init__(self):
+            self.title = "Connect to Multiworld"
+            self.icon = r"data/icon.png"
+            super().__init__()
+
+        def build(self):
+            layout = BoxLayout(orientation="vertical")
+            layout.add_widget(Label(text="Select client to open and connect with."))
+            button_row = BoxLayout(orientation="horizontal", size_hint=(1, 0.4))
+
+            text_client_button = Button(
+                text=text_client_component.display_name,
+                on_release=lambda *args: run_component(text_client_component, *launch_args)
+            )
+            button_row.add_widget(text_client_button)
+
+            game_client_button = Button(
+                text=client_component.display_name,
+                on_release=lambda *args: run_component(client_component, *launch_args)
+            )
+            button_row.add_widget(game_client_button)
+
+            layout.add_widget(button_row)
+
+            return layout
+
+        def _stop(self, *largs):
+            # see run_gui Launcher _stop comment for details
+            self.root_window.close()
+            super()._stop(*largs)
+
+    Popup().run()
 
 
-def identify(path: None | str) -> tuple[None | str, None | Component]:
+def identify(path: Union[None, str]) -> Tuple[Union[None, str], Union[None, Component]]:
     if path is None:
         return None, None
     for component in components:
@@ -174,7 +178,7 @@ def identify(path: None | str) -> tuple[None | str, None | Component]:
     return None, None
 
 
-def get_exe(component: str | Component) -> Sequence[str] | None:
+def get_exe(component: Union[str, Component]) -> Optional[Sequence[str]]:
     if isinstance(component, str):
         name = component
         component = None
@@ -216,189 +220,100 @@ def launch(exe, in_terminal=False):
     subprocess.Popen(exe)
 
 
-def create_shortcut(button: Any, component: Component) -> None:
-    from pyshortcuts import make_shortcut
-    script = sys.argv[0]
-    wkdir = Utils.local_path()
-
-    script = f"{script} \"{component.display_name}\""
-    make_shortcut(script, name=f"Archipelago {component.display_name}", icon=local_path("data", "icon.ico"),
-                  startmenu=False, terminal=False, working_dir=wkdir)
-    button.menu.dismiss()
+refresh_components: Optional[Callable[[], None]] = None
 
 
-refresh_components: Callable[[], None] | None = None
-
-
-def run_gui(path: str, args: Any) -> None:
-    from kvui import (ThemedApp, MDFloatLayout, MDGridLayout, ScrollBox)
-    from kivy.properties import ObjectProperty
+def run_gui():
+    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget, ApAsyncImage
     from kivy.core.window import Window
-    from kivy.metrics import dp
-    from kivymd.uix.button import MDIconButton, MDButton
-    from kivymd.uix.card import MDCard
-    from kivymd.uix.menu import MDDropdownMenu
-    from kivymd.uix.snackbar import MDSnackbar, MDSnackbarText
-    from kivymd.uix.textfield import MDTextField
+    from kivy.uix.relativelayout import RelativeLayout
 
-    from kivy.lang.builder import Builder
-
-    class LauncherCard(MDCard):
-        component: Component | None
-        image: str
-        context_button: MDIconButton = ObjectProperty(None)
-
-        def __init__(self, *args, component: Component | None = None, image_path: str = "", **kwargs):
-            self.component = component
-            self.image = image_path
-            super().__init__(args, kwargs)
-
-    class Launcher(ThemedApp):
+    class Launcher(App):
         base_title: str = "Archipelago Launcher"
-        top_screen: MDFloatLayout = ObjectProperty(None)
-        navigation: MDGridLayout = ObjectProperty(None)
-        grid: MDGridLayout = ObjectProperty(None)
-        button_layout: ScrollBox = ObjectProperty(None)
-        search_box: MDTextField = ObjectProperty(None)
-        cards: list[LauncherCard]
-        current_filter: Sequence[str | Type] | None
+        container: ContainerLayout
+        grid: GridLayout
+        _tool_layout: Optional[ScrollBox] = None
+        _client_layout: Optional[ScrollBox] = None
 
-        def __init__(self, ctx=None, path=None, args=None):
+        def __init__(self, ctx=None):
             self.title = self.base_title + " " + Utils.__version__
             self.ctx = ctx
             self.icon = r"data/icon.png"
-            self.favorites = []
-            self.launch_uri = path
-            self.launch_args = args
-            self.cards = []
-            self.current_filter = (Type.CLIENT, Type.TOOL, Type.ADJUSTER, Type.MISC)
-            persistent = Utils.persistent_load()
-            if "launcher" in persistent:
-                if "favorites" in persistent["launcher"]:
-                    self.favorites.extend(persistent["launcher"]["favorites"])
-                if "filter" in persistent["launcher"]:
-                    if persistent["launcher"]["filter"]:
-                        filters = []
-                        for filter in persistent["launcher"]["filter"].split(", "):
-                            if filter == "favorites":
-                                filters.append(filter)
-                            else:
-                                filters.append(Type[filter])
-                        self.current_filter = filters
             super().__init__()
 
-        def set_favorite(self, caller):
-            if caller.component.display_name in self.favorites:
-                self.favorites.remove(caller.component.display_name)
-                caller.icon = "star-outline"
-            else:
-                self.favorites.append(caller.component.display_name)
-                caller.icon = "star"
+        def _refresh_components(self) -> None:
 
-        def build_card(self, component: Component) -> LauncherCard:
-            """
-                Builds a card widget for a given component.
-
-                :param component: The component associated with the button.
-
-                :return: The created Card Widget.
+            def build_button(component: Component) -> Widget:
                 """
-            button_card = LauncherCard(component=component,
-                                       image_path=icon_paths[component.icon])
+                Builds a button widget for a given component.
 
-            def open_menu(caller):
-                caller.menu.open()
+                Args:
+                    component (Component): The component associated with the button.
 
-            menu_items = [
-                {
-                    "text": "Add shortcut on desktop",
-                    "leading_icon": "laptop",
-                    "on_release": lambda: create_shortcut(button_card.context_button, component)
-                }
-            ]
-            button_card.context_button.menu = MDDropdownMenu(caller=button_card.context_button, items=menu_items)
-            button_card.context_button.bind(on_release=open_menu)
+                Returns:
+                    None. The button is added to the parent grid layout.
 
-            return button_card
-
-        def _refresh_components(self, type_filter: Sequence[str | Type] | None = None) -> None:
-            if not type_filter:
-                type_filter = [Type.CLIENT, Type.ADJUSTER, Type.TOOL, Type.MISC]
-            favorites = "favorites" in type_filter
+                """
+                button = Button(text=component.display_name, size_hint_y=None, height=40)
+                button.component = component
+                button.bind(on_release=self.component_action)
+                if component.icon != "icon":
+                    image = ApAsyncImage(source=icon_paths[component.icon],
+                                         size=(38, 38), size_hint=(None, 1), pos=(5, 0))
+                    box_layout = RelativeLayout(size_hint_y=None, height=40)
+                    box_layout.add_widget(button)
+                    box_layout.add_widget(image)
+                    return box_layout
+                return button
 
             # clear before repopulating
-            assert self.button_layout, "must call `build` first"
-            tool_children = reversed(self.button_layout.layout.children)
+            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.button_layout.layout.remove_widget(child)
+                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)
 
-            cards = [card for card in self.cards if card.component.type in type_filter
-                     or favorites and card.component.display_name in self.favorites]
+            _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}
 
-            self.current_filter = type_filter
-
-            for card in cards:
-                self.button_layout.layout.add_widget(card)
-
-            top = self.button_layout.children[0].y + self.button_layout.children[0].height \
-                           - self.button_layout.height
-            scroll_percent = self.button_layout.convert_distance_to_scroll(0, top)
-            self.button_layout.scroll_y = max(0, min(1, scroll_percent[1]))
-
-        def filter_clients_by_type(self, caller: MDButton):
-            self._refresh_components(caller.type)
-            self.search_box.text = ""
-
-        def filter_clients_by_name(self, caller: MDTextField, name: str) -> None:
-            if len(name) == 0:
-                self._refresh_components(self.current_filter)
-                return
-
-            sub_matches = [
-                card for card in self.cards
-                if name.lower() in card.component.display_name.lower() and card.component.type != Type.HIDDEN
-            ]
-            self.button_layout.layout.clear_widgets()
-            for card in sub_matches:
-                self.button_layout.layout.add_widget(card)
+            for (tool, client) in itertools.zip_longest(itertools.chain(
+                _tools.items(), _miscs.items(), _adjusters.items()
+            ), _clients.items()):
+                # column 1
+                if tool:
+                    self._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.top_screen = Builder.load_file(Utils.local_path("data/launcher.kv"))
-            self.grid = self.top_screen.ids.grid
-            self.navigation = self.top_screen.ids.navigation
-            self.button_layout = self.top_screen.ids.button_layout
-            self.search_box = self.top_screen.ids.search_box
-            self.set_colors()
-            self.top_screen.md_bg_color = self.theme_cls.backgroundColor
+            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)
-            Window.bind(on_keyboard=self._on_keyboard)
 
-            for component in components:
-                self.cards.append(self.build_card(component))
-
-            self._refresh_components(self.current_filter)
-
-            # Uncomment to re-enable the Kivy console/live editor
-            # Ctrl-E to enable it, make sure numlock/capslock is disabled
-            # from kivy.modules.console import create_console
-            # create_console(Window, self.top_screen)
-
-            return self.top_screen
-
-        def on_start(self):
-            if self.launch_uri:
-                handle_uri(self.launch_uri, self.launch_args)
-                self.launch_uri = None
-                self.launch_args = None
+            return self.container
 
         @staticmethod
         def component_action(button):
-            MDSnackbar(MDSnackbarText(text="Opening in a new window..."), y=dp(24), pos_hint={"center_x": 0.5},
-                       size_hint_x=0.5).open()
             if button.component.func:
                 button.component.func()
             else:
@@ -412,28 +327,13 @@ def run_gui(path: str, args: Any) -> None:
             else:
                 logging.warning(f"unable to identify component for {file}")
 
-        def _on_keyboard(self, window: Window, key: int, scancode: int, codepoint: str, modifier: list[str]):
-            # Activate search as soon as we start typing, no matter if we are focused on the search box or not.
-            # Focus first, then capture the first character we type, otherwise it gets swallowed and lost.
-            # Limit text input to ASCII non-control characters (space bar to tilde).
-            if not self.search_box.focus:
-                self.search_box.focus = True
-                if key in range(32, 126):
-                    self.search_box.text += codepoint
-
         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.
             self.root_window.close()
             super()._stop(*largs)
 
-        def on_stop(self):
-            Utils.persistent_store("launcher", "favorites", self.favorites)
-            Utils.persistent_store("launcher", "filter", ", ".join(filter.name if isinstance(filter, Type) else filter
-                                                                   for filter in self.current_filter))
-            super().on_stop()
-
-    Launcher(path=path, args=args).run()
+    Launcher().run()
 
     # avoiding Launcher reference leak
     # and don't try to do something with widgets after window closed
@@ -452,7 +352,7 @@ def run_component(component: Component, *args):
         logging.warning(f"Component {component} does not appear to be executable.")
 
 
-def main(args: argparse.Namespace | dict | None = None):
+def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     if isinstance(args, argparse.Namespace):
         args = {k: v for k, v in args._get_kwargs()}
     elif not args:
@@ -460,14 +360,16 @@ def main(args: argparse.Namespace | dict | None = None):
 
     path = args.get("Patch|Game|Component|url", None)
     if path is not None:
-        if not path.startswith("archipelago://"):
-            file, component = identify(path)
-            if file:
-                args['file'] = file
-            if component:
-                args['component'] = component
-            if not component:
-                logging.warning(f"Could not identify Component responsible for {path}")
+        if path.startswith("archipelago://"):
+            handle_uri(path, args.get("args", ()))
+            return
+        file, component = identify(path)
+        if file:
+            args['file'] = file
+        if component:
+            args['component'] = component
+        if not component:
+            logging.warning(f"Could not identify Component responsible for {path}")
 
     if args["update_settings"]:
         update_settings()
@@ -476,7 +378,7 @@ def main(args: argparse.Namespace | dict | None = None):
     elif "component" in args:
         run_component(args["component"], *args["args"])
     elif not args["update_settings"]:
-        run_gui(path, args.get("args", ()))
+        run_gui()
 
 
 if __name__ == '__main__':
@@ -498,7 +400,6 @@ if __name__ == '__main__':
     main(parser.parse_args())
 
     from worlds.LauncherComponents import processes
-
     for process in processes:
         # we await all child processes to close before we tear down the process host
         # this makes it feel like each one is its own program, as the Launcher is closed now

LinksAwakeningClient.py

@@ -26,14 +26,12 @@ import typing
 from CommonClient import (CommonContext, get_base_parser, gui_enabled, logger,
                           server_loop)
 from NetUtils import ClientStatus
-from worlds.ladx import LinksAwakeningWorld
 from worlds.ladx.Common import BASE_ID as LABaseID
 from worlds.ladx.GpsTracker import GpsTracker
-from worlds.ladx.TrackerConsts import storage_key
 from worlds.ladx.ItemTracker import ItemTracker
 from worlds.ladx.LADXR.checkMetadata import checkMetadataTable
 from worlds.ladx.Locations import get_locations_to_id, meta_to_name
-from worlds.ladx.Tracker import LocationTracker, MagpieBridge, Check
+from worlds.ladx.Tracker import LocationTracker, MagpieBridge
 
 
 class GameboyException(Exception):
@@ -52,6 +50,22 @@ class BadRetroArchResponse(GameboyException):
     pass
 
 
+def magpie_logo():
+    from kivy.uix.image import CoreImage
+    binary_data = """
+iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAAAXN
+SR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA
+7DAcdvqGQAAADGSURBVDhPhVLBEcIwDHOYhjHCBuXHj2OTbAL8+
+MEGZIxOQ1CinOOk0Op0bmo7tlXXeR9FJMYDLOD9mwcLjQK7+hSZ
+wgcWMZJOAGeGKtChNHFL0j+FZD3jSCuo0w7l03wDrWdg00C4/aW
+eDEYNenuzPOfPspBnxf0kssE80vN0L8361j10P03DK4x6FHabuV
+ear8fHme+b17rwSjbAXeUMLb+EVTV2QHm46MWQanmnydA98KsVS
+XkV+qFpGQXrLhT/fqraQeQLuplpNH5g+WkAAAAASUVORK5CYII="""
+    binary_data = base64.b64decode(binary_data)
+    data = io.BytesIO(binary_data)
+    return CoreImage(data, ext="png").texture
+
+
 class LAClientConstants:
     # Connector version
     VERSION = 0x01
@@ -86,23 +100,19 @@ class LAClientConstants:
     WRamCheckSize = 0x4
     WRamSafetyValue = bytearray([0]*WRamCheckSize)
 
-    wRamStart = 0xC000
-    hRamStart = 0xFF80
-    hRamSize = 0x80
-
     MinGameplayValue = 0x06
     MaxGameplayValue = 0x1A
     VictoryGameplayAndSub = 0x0102
 
+
 class RAGameboy():
     cache = []
+    cache_start = 0
+    cache_size = 0
     last_cache_read = None
     socket = None
 
     def __init__(self, address, port) -> None:
-        self.cache_start = LAClientConstants.wRamStart
-        self.cache_size = LAClientConstants.hRamStart + LAClientConstants.hRamSize - LAClientConstants.wRamStart
-
         self.address = address
         self.port = port
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
@@ -121,14 +131,9 @@ class RAGameboy():
     async def get_retroarch_status(self):
         return await self.send_command("GET_STATUS")
 
-    def set_checks_range(self, checks_start, checks_size):
-        self.checks_start = checks_start
-        self.checks_size = checks_size
-
-    def set_location_range(self, location_start, location_size, critical_addresses):
-        self.location_start = location_start
-        self.location_size = location_size
-        self.critical_location_addresses = critical_addresses
+    def set_cache_limits(self, cache_start, cache_size):
+        self.cache_start = cache_start
+        self.cache_size = cache_size
 
     def send(self, b):
         if type(b) is str:
@@ -183,57 +188,21 @@ class RAGameboy():
         if not await self.check_safe_gameplay():
             return
 
-        attempts = 0
-        while True:
-            # RA doesn't let us do an atomic read of a large enough block of RAM
-            # Some bytes can't change in between reading location_block and hram_block
-            location_block = await self.read_memory_block(self.location_start, self.location_size)
-            hram_block = await self.read_memory_block(LAClientConstants.hRamStart, LAClientConstants.hRamSize)
-            verification_block = await self.read_memory_block(self.location_start, self.location_size)
-
-            valid = True
-            for address in self.critical_location_addresses:
-                if location_block[address - self.location_start] != verification_block[address - self.location_start]:
-                    valid = False
-
-            if valid:
-                break
-
-            attempts += 1
-
-            # Shouldn't really happen, but keep it from choking
-            if attempts > 5:
-                return
-
-        checks_block = await self.read_memory_block(self.checks_start, self.checks_size)
+        cache = []
+        remaining_size = self.cache_size
+        while remaining_size:
+            block = await self.async_read_memory(self.cache_start + len(cache), remaining_size)
+            remaining_size -= len(block)
+            cache += block
 
         if not await self.check_safe_gameplay():
             return
 
-        self.cache = bytearray(self.cache_size)
-
-        start = self.checks_start - self.cache_start
-        self.cache[start:start + len(checks_block)] = checks_block
-
-        start = self.location_start - self.cache_start
-        self.cache[start:start + len(location_block)] = location_block
-
-        start = LAClientConstants.hRamStart - self.cache_start
-        self.cache[start:start + len(hram_block)] = hram_block
-
+        self.cache = cache
         self.last_cache_read = time.time()
 
-    async def read_memory_block(self, address: int, size: int):
-        block = bytearray()
-        remaining_size = size
-        while remaining_size:
-            chunk = await self.async_read_memory(address + len(block), remaining_size)
-            remaining_size -= len(chunk)
-            block += chunk
-
-        return block
-
     async def read_memory_cache(self, addresses):
+        # TODO: can we just update once per frame?
         if not self.last_cache_read or self.last_cache_read + 0.1 < time.time():
             await self.update_cache()
         if not self.cache:
@@ -390,12 +359,11 @@ class LinksAwakeningClient():
         auth = binascii.hexlify(await self.gameboy.async_read_memory(0x0134, 12)).decode()
         self.auth = auth
 
-    async def wait_and_init_tracker(self, magpie: MagpieBridge):
+    async def wait_and_init_tracker(self):
         await self.wait_for_game_ready()
         self.tracker = LocationTracker(self.gameboy)
         self.item_tracker = ItemTracker(self.gameboy)
         self.gps_tracker = GpsTracker(self.gameboy)
-        magpie.gps_tracker = self.gps_tracker
 
     async def recved_item_from_ap(self, item_id, from_player, next_index):
         # Don't allow getting an item until you've got your first check
@@ -437,11 +405,9 @@ class LinksAwakeningClient():
         return (await self.gameboy.read_memory_cache([LAClientConstants.wGameplayType]))[LAClientConstants.wGameplayType] == 1
 
     async def main_tick(self, item_get_cb, win_cb, deathlink_cb):
-        await self.gameboy.update_cache()
         await self.tracker.readChecks(item_get_cb)
         await self.item_tracker.readItems()
         await self.gps_tracker.read_location()
-        await self.gps_tracker.read_entrances()
 
         current_health = (await self.gameboy.read_memory_cache([LAClientConstants.wLinkHealth]))[LAClientConstants.wLinkHealth]
         if self.deathlink_debounce and current_health != 0:
@@ -491,7 +457,7 @@ class LinksAwakeningContext(CommonContext):
     la_task = None
     client = None
     # TODO: does this need to re-read on reset?
-    found_checks = set()
+    found_checks = []
     last_resend = time.time()
 
     magpie_enabled = False
@@ -499,10 +465,6 @@ class LinksAwakeningContext(CommonContext):
     magpie_task = None
     won = False
 
-    @property
-    def slot_storage_key(self):
-        return f"{self.slot_info[self.slot].name}_{storage_key}"
-
     def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
         self.client = LinksAwakeningClient()
         self.slot_data = {}
@@ -514,9 +476,9 @@ class LinksAwakeningContext(CommonContext):
 
     def run_gui(self) -> None:
         import webbrowser
-        from kvui import GameManager
-        from kivy.metrics import dp
-        from kivymd.uix.button import MDButton, MDButtonText
+        import kvui
+        from kvui import Button, GameManager
+        from kivy.uix.image import Image
 
         class LADXManager(GameManager):
             logging_pairs = [
@@ -529,27 +491,23 @@ class LinksAwakeningContext(CommonContext):
                 b = super().build()
 
                 if self.ctx.magpie_enabled:
-                    button = MDButton(MDButtonText(text="Open Tracker"), style="filled", size=(dp(100), dp(70)), radius=5,
-                                      size_hint_x=None, size_hint_y=None, pos_hint={"center_y": 0.55},
-                                      on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
-                    button.height = self.server_connect_bar.height
-                    self.connect_layout.add_widget(button)
+                    button = Button(text="", size=(30, 30), size_hint_x=None,
+                                    on_press=lambda _: webbrowser.open('https://magpietracker.us/?enable_autotracker=1'))
+                    image = Image(size=(16, 16), texture=magpie_logo())
+                    button.add_widget(image)
 
+                    def set_center(_, center):
+                        image.center = center
+                    button.bind(center=set_center)
+
+                    self.connect_layout.add_widget(button)
                 return b
 
         self.ui = LADXManager(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
-    async def send_new_entrances(self, entrances: typing.Dict[str, str]):
-        # Store the entrances we find on the server for future sessions
-        message = [{
-            "cmd": "Set",
-            "key": self.slot_storage_key,
-            "default": {},
-            "want_reply": False,
-            "operations": [{"operation": "update", "value": entrances}],
-        }]
-
+    async def send_checks(self):
+        message = [{"cmd": 'LocationChecks', "locations": self.found_checks}]
         await self.send_msgs(message)
 
     had_invalid_slot_data = None
@@ -579,19 +537,13 @@ class LinksAwakeningContext(CommonContext):
             await self.send_msgs(message)
             self.won = True
 
-    async def request_found_entrances(self):
-        await self.send_msgs([{"cmd": "Get", "keys": [self.slot_storage_key]}])
-
-        # Ask for updates so that players can co-op entrances in a seed
-        await self.send_msgs([{"cmd": "SetNotify", "keys": [self.slot_storage_key]}])
-
     async def on_deathlink(self, data: typing.Dict[str, typing.Any]) -> None:
         if self.ENABLE_DEATHLINK:
             self.client.pending_deathlink = True
 
     def new_checks(self, item_ids, ladxr_ids):
-        self.found_checks.update(item_ids)
-        create_task_log_exception(self.check_locations(self.found_checks))
+        self.found_checks += item_ids
+        create_task_log_exception(self.send_checks())
         if self.magpie_enabled:
             create_task_log_exception(self.magpie.send_new_checks(ladxr_ids))
 
@@ -608,10 +560,6 @@ class LinksAwakeningContext(CommonContext):
 
         while self.client.auth == None:
             await asyncio.sleep(0.1)
-
-            # Just return if we're closing
-            if self.exit_event.is_set():
-                return
         self.auth = self.client.auth
         await self.send_connect()
 
@@ -619,40 +567,16 @@ class LinksAwakeningContext(CommonContext):
         if cmd == "Connected":
             self.game = self.slot_info[self.slot].game
             self.slot_data = args.get("slot_data", {})
-            # This is sent to magpie over local websocket to make its own connection
-            self.slot_data.update({
-                "server_address": self.server_address,
-                "slot_name": self.player_names[self.slot],
-                "password": self.password,
-            })
-
-            # We can process linked items on already-checked checks now that we have slot_data
-            if self.client.tracker:
-                checked_checks = set(self.client.tracker.all_checks) - set(self.client.tracker.remaining_checks)
-                self.add_linked_items(checked_checks)
-
+            
         # TODO - use watcher_event
         if cmd == "ReceivedItems":
             for index, item in enumerate(args["items"], start=args["index"]):
                 self.client.recvd_checks[index] = item
 
-        if cmd == "Retrieved" and self.magpie_enabled and self.slot_storage_key in args["keys"]:
-            self.client.gps_tracker.receive_found_entrances(args["keys"][self.slot_storage_key])
-
-        if cmd == "SetReply" and self.magpie_enabled and args["key"] == self.slot_storage_key:
-            self.client.gps_tracker.receive_found_entrances(args["value"])
-
     async def sync(self):
         sync_msg = [{'cmd': 'Sync'}]
         await self.send_msgs(sync_msg)
 
-    def add_linked_items(self, checks: typing.List[Check]):
-        for check in checks:
-            if check.value and check.linkedItem:
-                linkedItem = check.linkedItem
-                if 'condition' not in linkedItem or (self.slot_data and linkedItem['condition'](self.slot_data)):
-                    self.client.item_tracker.setExtraItem(check.linkedItem['item'], check.linkedItem['qty'])
-
     item_id_lookup = get_locations_to_id()
 
     async def run_game_loop(self):
@@ -661,8 +585,6 @@ class LinksAwakeningContext(CommonContext):
                 checkMetadataTable[check.id])] for check in ladxr_checks]
             self.new_checks(checks, [check.id for check in ladxr_checks])
 
-            self.add_linked_items(ladxr_checks)
-
         async def victory():
             await self.send_victory()
 
@@ -696,38 +618,21 @@ class LinksAwakeningContext(CommonContext):
                 if not self.client.recvd_checks:
                     await self.sync()
 
-                await self.client.wait_and_init_tracker(self.magpie)
+                await self.client.wait_and_init_tracker()
 
-                min_tick_duration = 0.1
-                last_tick = time.time()
                 while True:
                     await self.client.main_tick(on_item_get, victory, deathlink)
-
+                    await asyncio.sleep(0.1)
                     now = time.time()
-                    tick_duration = now - last_tick
-                    sleep_duration = max(min_tick_duration - tick_duration, 0)
-                    await asyncio.sleep(sleep_duration)
-
-                    last_tick = now
-
                     if self.last_resend + 5.0 < now:
                         self.last_resend = now
-                        await self.check_locations(self.found_checks)
+                        await self.send_checks()
                     if self.magpie_enabled:
                         try:
                             self.magpie.set_checks(self.client.tracker.all_checks)
                             await self.magpie.set_item_tracker(self.client.item_tracker)
-                            if self.slot_data and "slot_data" in self.magpie.features and not self.magpie.has_sent_slot_data:
-                                self.magpie.slot_data = self.slot_data
-                                await self.magpie.send_slot_data()
-
-                            if self.client.gps_tracker.needs_found_entrances:
-                                await self.request_found_entrances()
-                                self.client.gps_tracker.needs_found_entrances = False
-
-                            new_entrances = await self.magpie.send_gps(self.client.gps_tracker)
-                            if new_entrances:
-                                await self.send_new_entrances(new_entrances)
+                            await self.magpie.send_gps(self.client.gps_tracker)
+                            self.magpie.slot_data = self.slot_data
                         except Exception:
                             # Don't let magpie errors take out the client
                             pass
@@ -738,8 +643,8 @@ class LinksAwakeningContext(CommonContext):
                 await asyncio.sleep(1.0)
 
 def run_game(romfile: str) -> None:
-    auto_start = LinksAwakeningWorld.settings.rom_start
-
+    auto_start = typing.cast(typing.Union[bool, str],
+                            Utils.get_options()["ladx_options"].get("rom_start", True))
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)
@@ -796,6 +701,6 @@ async def main():
     await ctx.shutdown()
 
 if __name__ == '__main__':
-    colorama.just_fix_windows_console()
+    colorama.init()
     asyncio.run(main())
     colorama.deinit()

LttPAdjuster.py

@@ -33,15 +33,10 @@ WINDOW_MIN_HEIGHT = 525
 WINDOW_MIN_WIDTH = 425
 
 class AdjusterWorld(object):
-    class AdjusterSubWorld(object):
-        def __init__(self, random):
-            self.random = random
-
     def __init__(self, sprite_pool):
         import random
         self.sprite_pool = {1: sprite_pool}
         self.per_slot_randoms = {1: random}
-        self.worlds = {1: self.AdjusterSubWorld(random)}
 
 
 class ArgumentDefaultsHelpFormatter(argparse.RawTextHelpFormatter):

MMBN3Client.py

@@ -370,7 +370,7 @@ if __name__ == "__main__":
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

Main.py

@@ -7,13 +7,14 @@ import tempfile
 import time
 import zipfile
 import zlib
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
-from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld
-from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, flood_items, \
-    parse_planned_blocks, distribute_planned_blocks, resolve_early_locations_for_planned
+from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
+    flood_items
 from Options import StartInventoryPool
-from Utils import __version__, output_path, version_tuple
+from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
 from worlds import AutoWorld
 from worlds.generic.Rules import exclusion_rules, locality_rules
@@ -21,7 +22,7 @@ from worlds.generic.Rules import exclusion_rules, locality_rules
 __all__ = ["main"]
 
 
-def main(args, seed=None, baked_server_options: dict[str, object] | None = None):
+def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = None):
     if not baked_server_options:
         baked_server_options = get_settings().server_options.as_dict()
     assert isinstance(baked_server_options, dict)
@@ -36,6 +37,9 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger = logging.getLogger()
     multiworld.set_seed(seed, args.race, str(args.outputname) if args.outputname else None)
     multiworld.plando_options = args.plando_options
+    multiworld.plando_items = args.plando_items.copy()
+    multiworld.plando_texts = args.plando_texts.copy()
+    multiworld.plando_connections = args.plando_connections.copy()
     multiworld.game = args.game.copy()
     multiworld.player_name = args.name.copy()
     multiworld.sprite = args.sprite.copy()
@@ -52,18 +56,32 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f"Found {len(AutoWorld.AutoWorldRegister.world_types)} World Types:")
     longest_name = max(len(text) for text in AutoWorld.AutoWorldRegister.world_types)
 
+    max_item = 0
+    max_location = 0
+    for cls in AutoWorld.AutoWorldRegister.world_types.values():
+        if cls.item_id_to_name:
+            max_item = max(max_item, max(cls.item_id_to_name))
+            max_location = max(max_location, max(cls.location_id_to_name))
+
+    item_digits = len(str(max_item))
+    location_digits = len(str(max_location))
     item_count = len(str(max(len(cls.item_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
     location_count = len(str(max(len(cls.location_names) for cls in AutoWorld.AutoWorldRegister.world_types.values())))
+    del max_item, max_location
 
     for name, cls in AutoWorld.AutoWorldRegister.world_types.items():
         if not cls.hidden and len(cls.item_names) > 0:
-            logger.info(f" {name:{longest_name}}: Items: {len(cls.item_names):{item_count}} | "
-                        f"Locations: {len(cls.location_names):{location_count}}")
+            logger.info(f" {name:{longest_name}}: {len(cls.item_names):{item_count}} "
+                        f"Items (IDs: {min(cls.item_id_to_name):{item_digits}} - "
+                        f"{max(cls.item_id_to_name):{item_digits}}) | "
+                        f"{len(cls.location_names):{location_count}} "
+                        f"Locations (IDs: {min(cls.location_id_to_name):{location_digits}} - "
+                        f"{max(cls.location_id_to_name):{location_digits}})")
 
-    del item_count, location_count
+    del item_digits, location_digits, item_count, location_count
 
     # This assertion method should not be necessary to run if we are not outputting any multidata.
-    if not args.skip_output and not args.spoiler_only:
+    if not args.skip_output:
         AutoWorld.call_stage(multiworld, "assert_generate")
 
     AutoWorld.call_all(multiworld, "generate_early")
@@ -130,16 +148,13 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     else:
         multiworld.worlds[1].options.non_local_items.value = set()
         multiworld.worlds[1].options.local_items.value = set()
-
-    multiworld.plando_item_blocks = parse_planned_blocks(multiworld)
-
-    AutoWorld.call_all(multiworld, "connect_entrances")
+    
     AutoWorld.call_all(multiworld, "generate_basic")
 
     # remove starting inventory from pool items.
     # Because some worlds don't actually create items during create_items this has to be as late as possible.
     fallback_inventory = StartInventoryPool({})
-    depletion_pool: dict[int, dict[str, int]] = {
+    depletion_pool: Dict[int, Dict[str, int]] = {
         player: getattr(multiworld.worlds[player].options, "start_inventory_from_pool", fallback_inventory).value.copy()
         for player in multiworld.player_ids
     }
@@ -148,7 +163,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     }
 
     if target_per_player:
-        new_itempool: list[Item] = []
+        new_itempool: List[Item] = []
 
         # Make new itempool with start_inventory_from_pool items removed
         for item in multiworld.itempool:
@@ -166,7 +181,8 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                 logger.warning(f"{player_name} tried to remove items from their pool that don't exist: {unfound_items}")
 
             needed_items = target_per_player[player] - sum(unfound_items.values())
-            new_itempool += [multiworld.worlds[player].create_filler() for _ in range(needed_items)]
+            new_itempool += [multiworld.worlds[player].create_filler(AutoWorld.FillerReason.start_inventory_from_pool)
+                             for _ in range(needed_items)]
 
         assert len(multiworld.itempool) == len(new_itempool), "Item Pool amounts should not change."
         multiworld.itempool[:] = new_itempool
@@ -177,9 +193,8 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
         multiworld._all_state = None
 
     logger.info("Running Item Plando.")
-    resolve_early_locations_for_planned(multiworld)
-    distribute_planned_blocks(multiworld, [x for player in multiworld.plando_item_blocks
-                                           for x in multiworld.plando_item_blocks[player]])
+
+    distribute_planned(multiworld)
 
     logger.info('Running Pre Main Fill.')
 
@@ -209,15 +224,6 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
     logger.info(f'Beginning output...')
     outfilebase = 'AP_' + multiworld.seed_name
 
-    if args.spoiler_only:
-        if args.spoiler > 1:
-            logger.info('Calculating playthrough.')
-            multiworld.spoiler.create_playthrough(create_paths=args.spoiler > 2)
-
-        multiworld.spoiler.to_file(output_path('%s_Spoiler.txt' % outfilebase))
-        logger.info('Done. Skipped multidata modification. Total time: %s', time.perf_counter() - start)
-        return multiworld
-
     output = tempfile.TemporaryDirectory()
     with output as temp_dir:
         output_players = [player for player in multiworld.player_ids if AutoWorld.World.generate_output.__code__
@@ -232,7 +238,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     pool.submit(AutoWorld.call_single, multiworld, "generate_output", player, temp_dir))
 
             # collect ER hint info
-            er_hint_data: dict[int, dict[int, str]] = {}
+            er_hint_data: Dict[int, Dict[int, str]] = {}
             AutoWorld.call_all(multiworld, 'extend_hint_information', er_hint_data)
 
             def write_multidata():
@@ -273,7 +279,7 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                         for player in multiworld.groups[location.item.player]["players"]:
                             precollected_hints[player].add(hint)
 
-                locations_data: dict[int, dict[int, tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
+                locations_data: Dict[int, Dict[int, Tuple[int, int, int]]] = {player: {} for player in multiworld.player_ids}
                 for location in multiworld.get_filled_locations():
                     if type(location.address) == int:
                         assert location.item.code is not None, "item code None should be event, " \
@@ -300,14 +306,13 @@ def main(args, seed=None, baked_server_options: dict[str, object] | None = None)
                     game_world.game: worlds.network_data_package["games"][game_world.game]
                     for game_world in multiworld.worlds.values()
                 }
-                data_package["Archipelago"] = worlds.network_data_package["games"]["Archipelago"]
 
-                checks_in_area: dict[int, dict[str, int | list[int]]] = {}
+                checks_in_area: Dict[int, Dict[str, Union[int, List[int]]]] = {}
 
                 # get spheres -> filter address==None -> skip empty
-                spheres: list[dict[int, set[int]]] = []
+                spheres: List[Dict[int, Set[int]]] = []
                 for sphere in multiworld.get_sendable_spheres():
-                    current_sphere: dict[int, set[int]] = collections.defaultdict(set)
+                    current_sphere: Dict[int, Set[int]] = collections.defaultdict(set)
                     for sphere_location in sphere:
                         current_sphere[sphere_location.player].add(sphere_location.address)
 

MultiServer.py

@@ -28,11 +28,9 @@ ModuleUpdate.update()
 
 if typing.TYPE_CHECKING:
     import ssl
-    from NetUtils import ServerConnection
 
-import colorama
 import websockets
-from websockets.extensions.permessage_deflate import PerMessageDeflate
+import colorama
 try:
     # ponyorm is a requirement for webhost, not default server, so may not be importable
     from pony.orm.dbapiprovider import OperationalError
@@ -46,9 +44,8 @@ from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, Networ
     SlotType, LocationStore, Hint, HintStatus
 from BaseClasses import ItemClassification
 
-
-min_client_version = Version(0, 5, 0)
-colorama.just_fix_windows_console()
+min_client_version = Version(0, 1, 6)
+colorama.init()
 
 
 def remove_from_list(container, value):
@@ -67,13 +64,9 @@ def pop_from_container(container, value):
     return container
 
 
-def update_container_unique(container, entries):
-    if isinstance(container, list):
-        existing_container_as_set = set(container)
-        container.extend([entry for entry in entries if entry not in existing_container_as_set])
-    else:
-        container.update(entries)
-    return container
+def update_dict(dictionary, entries):
+    dictionary.update(entries)
+    return dictionary
 
 
 def queue_gc():
@@ -114,7 +107,7 @@ modify_functions = {
     # lists/dicts:
     "remove": remove_from_list,
     "pop": pop_from_container,
-    "update": update_container_unique,
+    "update": update_dict,
 }
 
 
@@ -126,14 +119,13 @@ def get_saving_second(seed_name: str, interval: int = 60) -> int:
 
 class Client(Endpoint):
     version = Version(0, 0, 0)
-    tags: typing.List[str]
+    tags: typing.List[str] = []
     remote_items: bool
     remote_start_inventory: bool
     no_items: bool
     no_locations: bool
-    no_text: bool
 
-    def __init__(self, socket: "ServerConnection", ctx: Context) -> None:
+    def __init__(self, socket: websockets.WebSocketServerProtocol, ctx: Context):
         super().__init__(socket)
         self.auth = False
         self.team = None
@@ -183,7 +175,6 @@ class Context:
                       "compatibility": int}
     # team -> slot id -> list of clients authenticated to slot.
     clients: typing.Dict[int, typing.Dict[int, typing.List[Client]]]
-    endpoints: list[Client]
     locations: LocationStore  # typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
     location_checks: typing.Dict[typing.Tuple[int, int], typing.Set[int]]
     hints_used: typing.Dict[typing.Tuple[int, int], int]
@@ -373,28 +364,18 @@ class Context:
             return True
 
     def broadcast_all(self, msgs: typing.List[dict]):
-        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
-        data = self.dumper(msgs)
-        endpoints = (
-            endpoint
-            for endpoint in self.endpoints
-            if endpoint.auth and not (msg_is_text and endpoint.no_text)
-        )
-        async_start(self.broadcast_send_encoded_msgs(endpoints, data))
+        msgs = self.dumper(msgs)
+        endpoints = (endpoint for endpoint in self.endpoints if endpoint.auth)
+        async_start(self.broadcast_send_encoded_msgs(endpoints, msgs))
 
     def broadcast_text_all(self, text: str, additional_arguments: dict = {}):
         self.logger.info("Notice (all): %s" % text)
         self.broadcast_all([{**{"cmd": "PrintJSON", "data": [{ "text": text }]}, **additional_arguments}])
 
     def broadcast_team(self, team: int, msgs: typing.List[dict]):
-        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
-        data = self.dumper(msgs)
-        endpoints = (
-            endpoint
-            for endpoint in itertools.chain.from_iterable(self.clients[team].values())
-            if not (msg_is_text and endpoint.no_text)
-        )
-        async_start(self.broadcast_send_encoded_msgs(endpoints, data))
+        msgs = self.dumper(msgs)
+        endpoints = (endpoint for endpoint in itertools.chain.from_iterable(self.clients[team].values()))
+        async_start(self.broadcast_send_encoded_msgs(endpoints, msgs))
 
     def broadcast(self, endpoints: typing.Iterable[Client], msgs: typing.List[dict]):
         msgs = self.dumper(msgs)
@@ -408,13 +389,13 @@ class Context:
         await on_client_disconnected(self, endpoint)
 
     def notify_client(self, client: Client, text: str, additional_arguments: dict = {}):
-        if not client.auth or client.no_text:
+        if not client.auth:
             return
         self.logger.info("Notice (Player %s in team %d): %s" % (client.name, client.team + 1, text))
         async_start(self.send_msgs(client, [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}]))
 
     def notify_client_multiple(self, client: Client, texts: typing.List[str], additional_arguments: dict = {}):
-        if not client.auth or client.no_text:
+        if not client.auth:
             return
         async_start(self.send_msgs(client,
                                    [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}
@@ -463,7 +444,7 @@ class Context:
 
         self.slot_info = decoded_obj["slot_info"]
         self.games = {slot: slot_info.game for slot, slot_info in self.slot_info.items()}
-        self.groups = {slot: set(slot_info.group_members) for slot, slot_info in self.slot_info.items()
+        self.groups = {slot: slot_info.group_members for slot, slot_info in self.slot_info.items()
                        if slot_info.type == SlotType.group}
 
         self.clients = {0: {}}
@@ -762,24 +743,23 @@ class Context:
                 concerns[player].append(data)
             if not hint.local and data not in concerns[hint.finding_player]:
                 concerns[hint.finding_player].append(data)
+            # remember hints in all cases
 
-            # only remember hints that were not already found at the time of creation
-            if not hint.found:
-                # since hints are bidirectional, finding player and receiving player,
-                # we can check once if hint already exists
-                if hint not in self.hints[team, hint.finding_player]:
-                    self.hints[team, hint.finding_player].add(hint)
-                    new_hint_events.add(hint.finding_player)
-                    for player in self.slot_set(hint.receiving_player):
-                        self.hints[team, player].add(hint)
-                        new_hint_events.add(player)
+            # since hints are bidirectional, finding player and receiving player,
+            # we can check once if hint already exists
+            if hint not in self.hints[team, hint.finding_player]:
+                self.hints[team, hint.finding_player].add(hint)
+                new_hint_events.add(hint.finding_player)
+                for player in self.slot_set(hint.receiving_player):
+                    self.hints[team, player].add(hint)
+                    new_hint_events.add(player)
 
             self.logger.info("Notice (Team #%d): %s" % (team + 1, format_hint(self, team, hint)))
         for slot in new_hint_events:
             self.on_new_hint(team, slot)
         for slot, hint_data in concerns.items():
             if recipients is None or slot in recipients:
-                clients = filter(lambda c: not c.no_text, self.clients[team].get(slot, []))
+                clients = self.clients[team].get(slot)
                 if not clients:
                     continue
                 client_hints = [datum[1] for datum in sorted(hint_data, key=lambda x: x[0].finding_player != slot)]
@@ -788,7 +768,7 @@ class Context:
 
     def get_hint(self, team: int, finding_player: int, seeked_location: int) -> typing.Optional[Hint]:
         for hint in self.hints[team, finding_player]:
-            if hint.location == seeked_location and hint.finding_player == finding_player:
+            if hint.location == seeked_location:
                 return hint
         return None
     
@@ -838,7 +818,7 @@ def update_aliases(ctx: Context, team: int):
             async_start(ctx.send_encoded_msgs(client, cmd))
 
 
-async def server(websocket: "ServerConnection", path: str = "/", ctx: Context = None) -> None:
+async def server(websocket, path: str = "/", ctx: Context = None):
     client = Client(websocket, ctx)
     ctx.endpoints.append(client)
 
@@ -929,10 +909,6 @@ async def on_client_joined(ctx: Context, client: Client):
                               "If your client supports it, "
                               "you may have additional local commands you can list with /help.",
                       {"type": "Tutorial"})
-    if not any(isinstance(extension, PerMessageDeflate) for extension in client.socket.extensions):
-        ctx.notify_client(client, "Warning: your client does not support compressed websocket connections! "
-                                  "It may stop working in the future. If you are a player, please report this to the "
-                                  "client's developer.")
     ctx.client_connection_timers[client.team, client.slot] = datetime.datetime.now(datetime.timezone.utc)
 
 
@@ -1083,37 +1059,21 @@ def send_items_to(ctx: Context, team: int, target_slot: int, *items: NetworkItem
 
 def register_location_checks(ctx: Context, team: int, slot: int, locations: typing.Iterable[int],
                              count_activity: bool = True):
-    slot_locations = ctx.locations[slot]
     new_locations = set(locations) - ctx.location_checks[team, slot]
-    new_locations.intersection_update(slot_locations)  # ignore location IDs unknown to this multidata
+    new_locations.intersection_update(ctx.locations[slot])  # ignore location IDs unknown to this multidata
     if new_locations:
         if count_activity:
             ctx.client_activity_timers[team, slot] = datetime.datetime.now(datetime.timezone.utc)
-
-        sortable: list[tuple[int, int, int, int]] = []
         for location in new_locations:
-            # extract all fields to avoid runtime overhead in LocationStore
-            item_id, target_player, flags = slot_locations[location]
-            # sort/group by receiver and item
-            sortable.append((target_player, item_id, location, flags))
-
-        info_texts: list[dict[str, typing.Any]] = []
-        for target_player, item_id, location, flags in sorted(sortable):
+            item_id, target_player, flags = ctx.locations[slot][location]
             new_item = NetworkItem(item_id, location, slot, flags)
             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]))
-            if len(info_texts) >= 140:
-                # split into chunks that are close to compression window of 64K but not too big on the wire
-                # (roughly 1300-2600 bytes after compression depending on repetitiveness)
-                ctx.broadcast_team(team, info_texts)
-                info_texts.clear()
-            info_texts.append(json_format_send_event(new_item, target_player))
-        ctx.broadcast_team(team, info_texts)
-        del info_texts
-        del sortable
+            info_text = json_format_send_event(new_item, target_player)
+            ctx.broadcast_team(team, [info_text])
 
         ctx.location_checks[team, slot] |= new_locations
         send_new_items(ctx)
@@ -1140,7 +1100,7 @@ def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, st
     seeked_item_id = item if isinstance(item, int) else ctx.item_names_for_game(ctx.games[slot])[item]
     for finding_player, location_id, item_id, receiving_player, item_flags \
             in ctx.locations.find_item(slots, seeked_item_id):
-        prev_hint = ctx.get_hint(team, finding_player, location_id)
+        prev_hint = ctx.get_hint(team, slot, location_id)
         if prev_hint:
             hints.append(prev_hint)
         else:
@@ -1826,9 +1786,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             ctx.clients[team][slot].append(client)
             client.version = args['version']
             client.tags = args['tags']
-            client.no_locations = bool(client.tags & _non_game_messages.keys())
-            # set NoText for old PopTracker clients that predate the tag to save traffic
-            client.no_text = "NoText" in client.tags or ("PopTracker" in client.tags and client.version < (0, 5, 1))
+            client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
             connected_packet = {
                 "cmd": "Connected",
                 "team": client.team, "slot": client.slot,
@@ -1900,10 +1858,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                 old_tags = client.tags
                 client.tags = args["tags"]
                 if set(old_tags) != set(client.tags):
-                    client.no_locations = bool(client.tags & _non_game_messages.keys())
-                    client.no_text = "NoText" in client.tags or (
-                        "PopTracker" in client.tags and client.version < (0, 5, 1)
-                    )
+                    client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
                     ctx.broadcast_text_all(
                         f"{ctx.get_aliased_name(client.team, client.slot)} (Team #{client.team + 1}) has changed tags "
                         f"from {old_tags} to {client.tags}.",
@@ -1932,8 +1887,7 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             for location in args["locations"]:
                 if type(location) is not int:
                     await ctx.send_msgs(client,
-                                        [{'cmd': 'InvalidPacket', "type": "arguments",
-                                          "text": 'Locations has to be a list of integers',
+                                        [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'LocationScouts',
                                           "original_cmd": cmd}])
                     return
 
@@ -1983,21 +1937,14 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             new_hint = new_hint.re_prioritize(ctx, status)
             if hint == new_hint:
                 return
-
-            concerning_slots = ctx.slot_set(hint.receiving_player) | {hint.finding_player}
-            for slot in concerning_slots:
-                ctx.replace_hint(client.team, slot, hint, new_hint)
+            ctx.replace_hint(client.team, hint.finding_player, hint, new_hint)
+            ctx.replace_hint(client.team, hint.receiving_player, hint, new_hint)
             ctx.save()
-            for slot in concerning_slots:
-                ctx.on_changed_hints(client.team, slot)
-
+            ctx.on_changed_hints(client.team, hint.finding_player)
+            ctx.on_changed_hints(client.team, hint.receiving_player)
+        
         elif cmd == 'StatusUpdate':
-            if client.no_locations and args["status"] == ClientStatus.CLIENT_GOAL:
-                await ctx.send_msgs(client, [{'cmd': 'InvalidPacket', "type": "cmd",
-                                              "text": "Trackers can't register Goal Complete",
-                                              "original_cmd": cmd}])
-            else:
-                update_client_status(ctx, client, args["status"])
+            update_client_status(ctx, client, args["status"])
 
         elif cmd == 'Say':
             if "text" not in args or type(args["text"]) is not str or not args["text"].isprintable():
@@ -2043,13 +1990,12 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
             args["cmd"] = "SetReply"
             value = ctx.stored_data.get(args["key"], args.get("default", 0))
             args["original_value"] = copy.copy(value)
-            args["slot"] = client.slot
             for operation in args["operations"]:
                 func = modify_functions[operation["operation"]]
                 value = func(value, operation["value"])
             ctx.stored_data[args["key"]] = args["value"] = value
             targets = set(ctx.stored_data_notification_clients[args["key"]])
-            if args.get("want_reply", False):
+            if args.get("want_reply", True):
                 targets.add(client)
             if targets:
                 ctx.broadcast(targets, [args])
@@ -2368,6 +2314,7 @@ class ServerCommandProcessor(CommonCommandProcessor):
             known_options = (f"{option}: {option_type}" for option, option_type in self.ctx.simple_options.items())
             self.output(f"Unrecognized option '{option_name}', known: {', '.join(known_options)}")
             return False
+
         if value_type == bool:
             def value_type(input_text: str):
                 return input_text.lower() not in {"off", "0", "false", "none", "null", "no"}
@@ -2401,75 +2348,6 @@ class ServerCommandProcessor(CommonCommandProcessor):
                         f"approximately totaling {Utils.format_SI_prefix(total, power=1024)}B")
         self.output("\n".join(texts))
 
-    def _cmd_discord_webhook(self, webhook_url: str):
-        """Needs to be supplied with a Discord WebHook url as parameter,
-        which will then relay the server log to a discord channel."""
-
-        import discord_webhook
-        initial_response = discord_webhook.DiscordWebhook(webhook_url, wait=True,
-                                                          content="Beginning Discord Logging").execute()
-        if initial_response.ok:
-            import queue
-            response_queue = queue.SimpleQueue()
-
-            class Emitter(threading.Thread):
-                def run(self):
-                    record: typing.Optional[logging.LogRecord] = None
-                    while True:
-                        time.sleep(1)
-                        # check for leftover record from last iteration
-                        message = record.msg if record else ""
-                        while 1:
-                            try:
-                                record = response_queue.get_nowait()
-                            except queue.Empty:
-                                break
-                            else:
-                                if record is None:
-                                    return  # shutdown
-                                if len(record.msg) > 1999:
-                                    continue  # content size limit
-                                if len(message) + len(record.msg) > 2000:
-                                    break  # reached content size limit in total
-                                else:
-                                    message += "\n" + record.msg
-                                    record = None
-                        if message:
-                            try:
-                                response = discord_webhook.DiscordWebhook(
-                                    webhook_url, rate_limit_retry=True, content=message.strip()).execute()
-                                if response.status_code not in (200, 204):
-                                    shutdown()
-                                    logging.info(f"Disabled Discord WebHook due to error code {response.status_code}.")
-                                    return
-                            # just in case to prevent an error-loop logging itself
-                            except Exception as e:
-                                shutdown()
-                                logging.error("Disabled Discord WebHook due to error.")
-                                logging.exception(e)
-                                return
-
-            emitter = Emitter()
-            emitter.daemon = True
-            emitter.start()
-
-            class DiscordLogger(logging.Handler):
-                """Logs to Discord WebHook"""
-                def emit(self, record: logging.LogRecord):
-                    response_queue.put(record)
-
-            handler = DiscordLogger()
-
-            def shutdown():
-                response_queue.put(None)
-                logging.getLogger().removeHandler(handler)
-
-            logging.getLogger().addHandler(handler)
-            self.output("Discord Link established.")
-
-        else:
-            self.output("Discord Link could not be established. Check your webhook url.")
-
 
 async def console(ctx: Context):
     import sys
@@ -2492,10 +2370,8 @@ async def console(ctx: Context):
 
 
 def parse_args() -> argparse.Namespace:
-    from settings import get_settings
-
     parser = argparse.ArgumentParser()
-    defaults = get_settings().server_options.as_dict()
+    defaults = Utils.get_settings()["server_options"].as_dict()
     parser.add_argument('multidata', nargs="?", default=defaults["multidata"])
     parser.add_argument('--host', default=defaults["host"])
     parser.add_argument('--port', default=defaults["port"], type=int)

NetUtils.py

@@ -5,18 +5,17 @@ import enum
 import warnings
 from json import JSONEncoder, JSONDecoder
 
-if typing.TYPE_CHECKING:
-    from websockets import WebSocketServerProtocol as ServerConnection
+import websockets
 
 from Utils import ByValue, Version
 
 
 class HintStatus(ByValue, enum.IntEnum):
-    HINT_UNSPECIFIED = 0
+    HINT_FOUND = 0
+    HINT_UNSPECIFIED = 1
     HINT_NO_PRIORITY = 10
     HINT_AVOID = 20
     HINT_PRIORITY = 30
-    HINT_FOUND = 40
 
 
 class JSONMessagePart(typing.TypedDict, total=False):
@@ -152,7 +151,7 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 
 
 class Endpoint:
-    socket: "ServerConnection"
+    socket: websockets.WebSocketServerProtocol
 
     def __init__(self, socket):
         self.socket = socket

OoTAdjuster.py

@@ -1,6 +1,7 @@
 import tkinter as tk
 import argparse
 import logging
+import random
 import os
 import zipfile
 from itertools import chain
@@ -196,6 +197,7 @@ def set_icon(window):
 def adjust(args):
     # Create a fake multiworld and OOTWorld to use as a base
     multiworld = MultiWorld(1)
+    multiworld.per_slot_randoms = {1: random}
     ootworld = OOTWorld(multiworld, 1)
     # Set options in the fake OOTWorld
     for name, option in chain(cosmetic_options.items(), sfx_options.items()):

OoTClient.py

@@ -346,7 +346,7 @@ if __name__ == '__main__':
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main())
     colorama.deinit()

Options.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import abc
-import collections
 import functools
 import logging
 import math
@@ -24,12 +23,6 @@ if typing.TYPE_CHECKING:
     import pathlib
 
 
-def roll_percentage(percentage: int | float) -> bool:
-    """Roll a percentage chance.
-    percentage is expected to be in range [0, 100]"""
-    return random.random() < (float(percentage) / 100)
-
-
 class OptionError(ValueError):
     pass
 
@@ -144,7 +137,7 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     If this is False, the docstring is instead interpreted as plain text, and
     displayed as-is on the WebHost with whitespace preserved.
 
-    If this is None, it inherits the value of `WebWorld.rich_text_options_doc`. For
+    If this is None, it inherits the value of `World.rich_text_options_doc`. For
     backwards compatibility, this defaults to False, but worlds are encouraged to
     set it to True and use reStructuredText for their Option documentation.
 
@@ -696,9 +689,9 @@ class Range(NumericOption):
     @classmethod
     def weighted_range(cls, text) -> Range:
         if text == "random-low":
-            return cls(cls.triangular(cls.range_start, cls.range_end, 0.0))
+            return cls(cls.triangular(cls.range_start, cls.range_end, cls.range_start))
         elif text == "random-high":
-            return cls(cls.triangular(cls.range_start, cls.range_end, 1.0))
+            return cls(cls.triangular(cls.range_start, cls.range_end, cls.range_end))
         elif text == "random-middle":
             return cls(cls.triangular(cls.range_start, cls.range_end))
         elif text.startswith("random-range-"):
@@ -724,11 +717,11 @@ class Range(NumericOption):
                 f"{random_range[0]}-{random_range[1]} is outside allowed range "
                 f"{cls.range_start}-{cls.range_end} for option {cls.__name__}")
         if text.startswith("random-range-low"):
-            return cls(cls.triangular(random_range[0], random_range[1], 0.0))
+            return cls(cls.triangular(random_range[0], random_range[1], random_range[0]))
         elif text.startswith("random-range-middle"):
             return cls(cls.triangular(random_range[0], random_range[1]))
         elif text.startswith("random-range-high"):
-            return cls(cls.triangular(random_range[0], random_range[1], 1.0))
+            return cls(cls.triangular(random_range[0], random_range[1], random_range[1]))
         else:
             return cls(random.randint(random_range[0], random_range[1]))
 
@@ -746,16 +739,8 @@ class Range(NumericOption):
         return str(self.value)
 
     @staticmethod
-    def triangular(lower: int, end: int, tri: float = 0.5) -> int:
-        """
-        Integer triangular distribution for `lower` inclusive to `end` inclusive.
-
-        Expects `lower <= end` and `0.0 <= tri <= 1.0`. The result of other inputs is undefined.
-        """
-        # Use the continuous range [lower, end + 1) to produce an integer result in [lower, end].
-        # random.triangular is actually [a, b] and not [a, b), so there is a very small chance of getting exactly b even
-        # when a != b, so ensure the result is never more than `end`.
-        return min(end, math.floor(random.triangular(0.0, 1.0, tri) * (end - lower + 1) + lower))
+    def triangular(lower: int, end: int, tri: typing.Optional[int] = None) -> int:
+        return int(round(random.triangular(lower, end, tri), 0))
 
 
 class NamedRange(Range):
@@ -873,49 +858,15 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
     def __len__(self) -> int:
         return self.value.__len__()
 
-    # __getitem__ fallback fails for Counters, so we define this explicitly
-    def __contains__(self, item) -> bool:
-        return item in self.value
 
-
-class OptionCounter(OptionDict):
-    min: int | None = None
-    max: int | None = None
-
-    def __init__(self, value: dict[str, int]) -> None:
-        super(OptionCounter, self).__init__(collections.Counter(value))
-
-    def verify(self, world: type[World], player_name: str, plando_options: PlandoOptions) -> None:
-        super(OptionCounter, self).verify(world, player_name, plando_options)
-
-        range_errors = []
-
-        if self.max is not None:
-            range_errors += [
-                f"\"{key}: {value}\" is higher than maximum allowed value {self.max}."
-                for key, value in self.value.items() if value > self.max
-            ]
-
-        if self.min is not None:
-            range_errors += [
-                f"\"{key}: {value}\" is lower than minimum allowed value {self.min}."
-                for key, value in self.value.items() if value < self.min
-            ]
-
-        if range_errors:
-            range_errors = [f"For option {getattr(self, 'display_name', self)}:"] + range_errors
-            raise OptionError("\n".join(range_errors))
-
-
-class ItemDict(OptionCounter):
+class ItemDict(OptionDict):
     verify_item_name = True
 
-    min = 0
-
-    def __init__(self, value: dict[str, int]) -> None:
-        # Backwards compatibility: Cull 0s to make "in" checks behave the same as when this wasn't a OptionCounter
-        value = {item_name: amount for item_name, amount in value.items() if amount != 0}
-
+    def __init__(self, value: typing.Dict[str, int]):
+        if any(item_count is None for item_count in value.values()):
+            raise Exception("Items must have counts associated with them. Please provide positive integer values in the format \"item\": count .")
+        if any(item_count < 1 for item_count in value.values()):
+            raise Exception("Cannot have non-positive item counts.")
         super(ItemDict, self).__init__(value)
 
 
@@ -1025,7 +976,7 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
         if isinstance(data, typing.Iterable):
             for text in data:
                 if isinstance(text, typing.Mapping):
-                    if roll_percentage(text.get("percentage", 100)):
+                    if random.random() < float(text.get("percentage", 100)/100):
                         at = text.get("at", None)
                         if at is not None:
                             if isinstance(at, dict):
@@ -1051,7 +1002,7 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                         else:
                             raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                 elif isinstance(text, PlandoText):
-                    if roll_percentage(text.percentage):
+                    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)}")
@@ -1175,7 +1126,7 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
         for connection in data:
             if isinstance(connection, typing.Mapping):
                 percentage = connection.get("percentage", 100)
-                if roll_percentage(percentage):
+                if random.random() < float(percentage / 100):
                     entrance = connection.get("entrance", None)
                     if is_iterable_except_str(entrance):
                         entrance = random.choice(sorted(entrance))
@@ -1193,7 +1144,7 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
                         percentage
                     ))
             elif isinstance(connection, PlandoConnection):
-                if roll_percentage(connection.percentage):
+                if random.random() < float(connection.percentage / 100):
                     value.append(connection)
             else:
                 raise Exception(f"Cannot create connection from non-Dict type, got {type(connection)}.")
@@ -1298,47 +1249,42 @@ class CommonOptions(metaclass=OptionsMetaProperty):
     progression_balancing: ProgressionBalancing
     accessibility: Accessibility
 
-    def as_dict(
-            self,
-            *option_names: str,
-            casing: typing.Literal["snake", "camel", "pascal", "kebab"] = "snake",
-            toggles_as_bools: bool = False,
-    ) -> dict[str, typing.Any]:
+    def as_dict(self,
+                *option_names: str,
+                casing: typing.Literal["snake", "camel", "pascal", "kebab"] = "snake",
+                toggles_as_bools: bool = False) -> typing.Dict[str, typing.Any]:
         """
         Returns a dictionary of [str, Option.value]
 
-        :param option_names: Names of the options to get the values of.
-        :param casing: Casing of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`.
-        :param toggles_as_bools: Whether toggle options should be returned as bools instead of ints.
-
-        :return: A dictionary of each option name to the value of its Option. If the option is an OptionSet, the value
-        will be returned as a sorted list.
+        :param option_names: names of the options to return
+        :param casing: case of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`
+        :param toggles_as_bools: whether toggle options should be output as bools instead of strings
         """
         assert option_names, "options.as_dict() was used without any option names."
         option_results = {}
         for option_name in option_names:
-            if option_name not in type(self).type_hints:
-                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
-
-            if casing == "snake":
-                display_name = option_name
-            elif casing == "camel":
-                split_name = [name.title() for name in option_name.split("_")]
-                split_name[0] = split_name[0].lower()
-                display_name = "".join(split_name)
-            elif casing == "pascal":
-                display_name = "".join([name.title() for name in option_name.split("_")])
-            elif casing == "kebab":
-                display_name = option_name.replace("_", "-")
+            if option_name in type(self).type_hints:
+                if casing == "snake":
+                    display_name = option_name
+                elif casing == "camel":
+                    split_name = [name.title() for name in option_name.split("_")]
+                    split_name[0] = split_name[0].lower()
+                    display_name = "".join(split_name)
+                elif casing == "pascal":
+                    display_name = "".join([name.title() for name in option_name.split("_")])
+                elif casing == "kebab":
+                    display_name = option_name.replace("_", "-")
+                else:
+                    raise ValueError(f"{casing} is invalid casing for as_dict. "
+                                     "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
+                value = getattr(self, option_name).value
+                if isinstance(value, set):
+                    value = sorted(value)
+                elif toggles_as_bools and issubclass(type(self).type_hints[option_name], Toggle):
+                    value = bool(value)
+                option_results[display_name] = value
             else:
-                raise ValueError(f"{casing} is invalid casing for as_dict. "
-                                 "Valid names are 'snake', 'camel', 'pascal', 'kebab'.")
-            value = getattr(self, option_name).value
-            if isinstance(value, set):
-                value = sorted(value)
-            elif toggles_as_bools and issubclass(type(self).type_hints[option_name], Toggle):
-                value = bool(value)
-            option_results[display_name] = value
+                raise ValueError(f"{option_name} not found in {tuple(type(self).type_hints)}")
         return option_results
 
 
@@ -1359,7 +1305,6 @@ class StartInventory(ItemDict):
     verify_item_name = True
     display_name = "Start Inventory"
     rich_text_doc = True
-    max = 10000
 
 
 class StartInventoryPool(StartInventory):
@@ -1475,131 +1420,6 @@ class ItemLinks(OptionList):
             link["item_pool"] = list(pool)
 
 
-@dataclass(frozen=True)
-class PlandoItem:
-    items: list[str] | dict[str, typing.Any]
-    locations: list[str]
-    world: int | str | bool | None | typing.Iterable[str] | set[int] = False
-    from_pool: bool = True
-    force: bool | typing.Literal["silent"] = "silent"
-    count: int | bool | dict[str, int] = False
-    percentage: int = 100
-
-
-class PlandoItems(Option[typing.List[PlandoItem]]):
-    """Generic items plando."""
-    default = ()
-    supports_weighting = False
-    display_name = "Plando Items"
-
-    def __init__(self, value: typing.Iterable[PlandoItem]) -> None:
-        self.value = list(deepcopy(value))
-        super().__init__()
-
-    @classmethod
-    def from_any(cls, data: typing.Any) -> Option[typing.List[PlandoItem]]:
-        if not isinstance(data, typing.Iterable):
-            raise OptionError(f"Cannot create plando items from non-Iterable type, got {type(data)}")
-
-        value: typing.List[PlandoItem] = []
-        for item in data:
-            if isinstance(item, typing.Mapping):
-                percentage = item.get("percentage", 100)
-                if not isinstance(percentage, int):
-                    raise OptionError(f"Plando `percentage` has to be int, not {type(percentage)}.")
-                if not (0 <= percentage <= 100):
-                    raise OptionError(f"Plando `percentage` has to be between 0 and 100 (inclusive) not {percentage}.")
-                if roll_percentage(percentage):
-                    count = item.get("count", False)
-                    items = item.get("items", [])
-                    if not items:
-                        items = item.get("item", None)  # explicitly throw an error here if not present
-                        if not items:
-                            raise OptionError("You must specify at least one item to place items with plando.")
-                        count = 1
-                    if isinstance(items, str):
-                        items = [items]
-                    elif not isinstance(items, (dict, list)):
-                        raise OptionError(f"Plando 'items' has to be string, list, or "
-                                          f"dictionary, not {type(items)}")
-                    locations = item.get("locations", [])
-                    if not locations:
-                        locations = item.get("location", ["Everywhere"])
-                        if locations:
-                            count = 1
-                        if isinstance(locations, str):
-                            locations = [locations]
-                        if not isinstance(locations, list):
-                            raise OptionError(f"Plando `location` has to be string or list, not {type(locations)}")
-                    world = item.get("world", False)
-                    from_pool = item.get("from_pool", True)
-                    force = item.get("force", "silent")
-                    if not isinstance(from_pool, bool):
-                        raise OptionError(f"Plando 'from_pool' has to be true or false, not {from_pool!r}.")
-                    if not (isinstance(force, bool) or force == "silent"):
-                        raise OptionError(f"Plando `force` has to be true or false or `silent`, not {force!r}.")
-                    value.append(PlandoItem(items, locations, world, from_pool, force, count, percentage))
-            elif isinstance(item, PlandoItem):
-                if roll_percentage(item.percentage):
-                    value.append(item)
-            else:
-                raise OptionError(f"Cannot create plando item from non-Dict type, got {type(item)}.")
-        return cls(value)
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        if not self.value:
-            return
-        from BaseClasses import PlandoOptions
-        if not (PlandoOptions.items & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando items module is turned off, "
-                            f"so items for {player_name} will be ignored.")
-        else:
-            # filter down item groups
-            for plando in self.value:
-                # confirm a valid count
-                if isinstance(plando.count, dict):
-                    if "min" in plando.count and "max" in plando.count:
-                        if plando.count["min"] > plando.count["max"]:
-                            raise OptionError("Plando cannot have count `min` greater than `max`.")
-                items_copy = plando.items.copy()
-                if isinstance(plando.items, dict):
-                    for item in items_copy:
-                        if item in world.item_name_groups:
-                            value = plando.items.pop(item)
-                            group = world.item_name_groups[item]
-                            filtered_items = sorted(group.difference(list(plando.items.keys())))
-                            if not filtered_items:
-                                raise OptionError(f"Plando `items` contains the group \"{item}\" "
-                                                  f"and every item in it. This is not allowed.")
-                            if value is True:
-                                for key in filtered_items:
-                                    plando.items[key] = True
-                            else:
-                                for key in random.choices(filtered_items, k=value):
-                                    plando.items[key] = plando.items.get(key, 0) + 1
-                else:
-                    assert isinstance(plando.items, list)  # pycharm can't figure out the hinting without the hint
-                    for item in items_copy:
-                        if item in world.item_name_groups:
-                            plando.items.remove(item)
-                            plando.items.extend(sorted(world.item_name_groups[item]))
-
-    @classmethod
-    def get_option_name(cls, value: list[PlandoItem]) -> str:
-        return ", ".join(["(%s: %s)" % (item.items, item.locations) for item in value])  #TODO: see what a better way to display would be
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoItem:
-        return self.value.__getitem__(index)
-
-    def __iter__(self) -> typing.Iterator[PlandoItem]:
-        yield from self.value
-
-    def __len__(self) -> int:
-        return len(self.value)
-
-        
 class Removed(FreeText):
     """This Option has been Removed."""
     rich_text_doc = True
@@ -1622,7 +1442,6 @@ class PerGameCommonOptions(CommonOptions):
     exclude_locations: ExcludeLocations
     priority_locations: PriorityLocations
     item_links: ItemLinks
-    plando_items: PlandoItems
 
 
 @dataclass
@@ -1752,11 +1571,10 @@ def dump_player_options(multiworld: MultiWorld) -> None:
             player_output = {
                 "Game": multiworld.game[player],
                 "Name": multiworld.get_player_name(player),
-                "ID": player,
             }
             output.append(player_output)
             for option_key, option in world.options_dataclass.type_hints.items():
-                if option.visibility == Visibility.none:
+                if issubclass(Removed, option):
                     continue
                 display_name = getattr(option, "display_name", option_key)
                 player_output[display_name] = getattr(world.options, option_key).current_option_name
@@ -1765,7 +1583,7 @@ def dump_player_options(multiworld: MultiWorld) -> None:
                     game_option_names.append(display_name)
 
     with open(output_path(f"generate_{multiworld.seed_name}.csv"), mode="w", newline="") as file:
-        fields = ["ID", "Game", "Name", *all_option_names]
+        fields = ["Game", "Name", *all_option_names]
         writer = DictWriter(file, fields)
         writer.writeheader()
         writer.writerows(output)

README.md

@@ -9,6 +9,7 @@ Currently, the following games are supported:
 * Factorio
 * Minecraft
 * Subnautica
+* Slay the Spire
 * Risk of Rain 2
 * The Legend of Zelda: Ocarina of Time
 * Timespinner
@@ -62,6 +63,7 @@ Currently, the following games are supported:
 * TUNIC
 * Kirby's Dream Land 3
 * Celeste 64
+* Zork Grand Inquisitor
 * Castlevania 64
 * A Short Hike
 * Yoshi's Island
@@ -78,8 +80,6 @@ Currently, the following games are supported:
 * Saving Princess
 * Castlevania: Circle of the Moon
 * Inscryption
-* Civilization VI
-* The Legend of Zelda: The Wind Waker
 
 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

SNIClient.py

@@ -735,6 +735,6 @@ async def main() -> None:
 
 
 if __name__ == '__main__':
-    colorama.just_fix_windows_console()
+    colorama.init()
     asyncio.run(main())
     colorama.deinit()

UndertaleClient.py

@@ -500,7 +500,7 @@ def main():
 
     import colorama
 
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(_main())
     colorama.deinit()

Utils.py

@@ -47,7 +47,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.6.2"
+__version__ = "0.6.0"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -114,8 +114,6 @@ def cache_self1(function: typing.Callable[[S, T], RetType]) -> typing.Callable[[
             cache[arg] = res
             return res
 
-    wrap.__defaults__ = function.__defaults__
-
     return wrap
 
 
@@ -139,11 +137,8 @@ def local_path(*path: str) -> str:
             local_path.cached_path = os.path.dirname(os.path.abspath(sys.argv[0]))
     else:
         import __main__
-        if globals().get("__file__") and os.path.isfile(__file__):
+        if hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
             # we are running in a normal Python environment
-            local_path.cached_path = os.path.dirname(os.path.abspath(__file__))
-        elif hasattr(__main__, "__file__") and os.path.isfile(__main__.__file__):
-            # we are running in a normal Python environment, but AP was imported weirdly
             local_path.cached_path = os.path.dirname(os.path.abspath(__main__.__file__))
         else:
             # pray
@@ -157,15 +152,8 @@ def home_path(*path: str) -> str:
     if hasattr(home_path, 'cached_path'):
         pass
     elif sys.platform.startswith('linux'):
-        xdg_data_home = os.getenv('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
-        home_path.cached_path = xdg_data_home + '/Archipelago'
-        if not os.path.isdir(home_path.cached_path):
-            legacy_home_path = os.path.expanduser('~/Archipelago')
-            if os.path.isdir(legacy_home_path):
-                os.renames(legacy_home_path, home_path.cached_path)
-                os.symlink(home_path.cached_path, legacy_home_path)
-            else:
-                os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
+        home_path.cached_path = os.path.expanduser('~/Archipelago')
+        os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
     else:
         # not implemented
         home_path.cached_path = local_path()  # this will generate the same exceptions we got previously
@@ -432,9 +420,6 @@ class RestrictedUnpickler(pickle.Unpickler):
     def find_class(self, module: str, name: str) -> type:
         if module == "builtins" and name in safe_builtins:
             return getattr(builtins, name)
-        # used by OptionCounter
-        if module == "collections" and name == "Counter":
-            return collections.Counter
         # used by MultiServer -> savegame/multidata
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint",
                                              "SlotType", "NetworkSlot", "HintStatus"}:
@@ -451,8 +436,7 @@ class RestrictedUnpickler(pickle.Unpickler):
             else:
                 mod = importlib.import_module(module)
             obj = getattr(mod, name)
-            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection,
-                                self.options_module.PlandoText)):
+            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection)):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
@@ -530,8 +514,8 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
         def filter(self, record: logging.LogRecord) -> bool:
             return self.condition(record)
 
-    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record, "NoFile", False)))
-    file_handler.addFilter(Filter("NoCarriageReturn", lambda record: '\r' not in record.getMessage()))
+    file_handler.addFilter(Filter("NoStream", lambda record: not getattr(record,  "NoFile", False)))
+    file_handler.addFilter(Filter("NoCarriageReturn", lambda record: '\r' not in record.msg))
     root_logger.addHandler(file_handler)
     if sys.stdout:
         formatter = logging.Formatter(fmt='[%(asctime)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
@@ -638,8 +622,6 @@ def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit:
     import jellyfish
 
     def get_fuzzy_ratio(word1: str, word2: str) -> float:
-        if word1 == word2:
-            return 1.01
         return (1 - jellyfish.damerau_levenshtein_distance(word1.lower(), word2.lower())
                 / max(len(word1), len(word2)))
 
@@ -660,10 +642,8 @@ def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bo
     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] == 101:
+        if picks[0][1] == 100:
             return picks[0][0], True, "Perfect Match"
-        elif picks[0][1] == 100:
-            return picks[0][0], True, "Case Insensitive 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)"
@@ -953,7 +933,7 @@ def freeze_support() -> None:
 
 def visualize_regions(root_region: Region, file_name: str, *,
                       show_entrance_names: bool = False, show_locations: bool = True, show_other_regions: bool = True,
-                      linetype_ortho: bool = True, regions_to_highlight: set[Region] | None = None) -> None:
+                      linetype_ortho: bool = True) -> None:
     """Visualize the layout of a world as a PlantUML diagram.
 
     :param root_region: The region from which to start the diagram from. (Usually the "Menu" region of your world.)
@@ -969,22 +949,16 @@ def visualize_regions(root_region: Region, file_name: str, *,
             Items without ID will be shown in italics.
     :param show_other_regions: (default True) If enabled, regions that can't be reached by traversing exits are shown.
     :param linetype_ortho: (default True) If enabled, orthogonal straight line parts will be used; otherwise polylines.
-    :param regions_to_highlight: Regions that will be highlighted in green if they are reachable.
 
     Example usage in World code:
     from Utils import visualize_regions
-    state = self.multiworld.get_all_state(False)
-    state.update_reachable_regions(self.player)
-    visualize_regions(self.get_region("Menu"), "my_world.puml", show_entrance_names=True,
-                      regions_to_highlight=state.reachable_regions[self.player])
+    visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
 
     Example usage in Main code:
     from Utils import visualize_regions
     for player in multiworld.player_ids:
         visualize_regions(multiworld.get_region("Menu", player), f"{multiworld.get_out_file_name_base(player)}.puml")
     """
-    if regions_to_highlight is None:
-        regions_to_highlight = set()
     assert root_region.multiworld, "The multiworld attribute of root_region has to be filled"
     from BaseClasses import Entrance, Item, Location, LocationProgressType, MultiWorld, Region
     from collections import deque
@@ -1037,7 +1011,7 @@ def visualize_regions(root_region: Region, file_name: str, *,
                 uml.append(f"\"{fmt(region)}\" : {{field}} {lock}{fmt(location)}")
 
     def visualize_region(region: Region) -> None:
-        uml.append(f"class \"{fmt(region)}\" {'#00FF00' if region in regions_to_highlight else ''}")
+        uml.append(f"class \"{fmt(region)}\"")
         if show_locations:
             visualize_locations(region)
         visualize_exits(region)

WargrooveClient.py

@@ -214,11 +214,17 @@ class WargrooveContext(CommonContext):
     def run_gui(self):
         """Import kivy UI system and start running it as self.ui_task."""
         from kvui import GameManager, HoverBehavior, ServerToolTip
-        from kivymd.uix.tab import MDTabsItem, MDTabsItemText
+        from kivy.uix.tabbedpanel import TabbedPanelItem
         from kivy.lang import Builder
+        from kivy.uix.button import Button
         from kivy.uix.togglebutton import ToggleButton
         from kivy.uix.boxlayout import BoxLayout
+        from kivy.uix.gridlayout import GridLayout
+        from kivy.uix.image import AsyncImage, Image
+        from kivy.uix.stacklayout import StackLayout
         from kivy.uix.label import Label
+        from kivy.properties import ColorProperty
+        from kivy.uix.image import Image
         import pkgutil
 
         class TrackerLayout(BoxLayout):
@@ -440,6 +446,6 @@ if __name__ == '__main__':
     parser = get_base_parser(description="Wargroove Client, for text interfacing.")
 
     args, rest = parser.parse_known_args()
-    colorama.just_fix_windows_console()
+    colorama.init()
     asyncio.run(main(args))
     colorama.deinit()

WebHostLib/api/__init__.py

@@ -3,13 +3,13 @@ from typing import List, Tuple
 
 from flask import Blueprint
 
-from ..models import Seed, Slot
+from ..models import Seed
 
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
 
 
 def get_players(seed: Seed) -> List[Tuple[str, str]]:
-    return [(slot.player_name, slot.game) for slot in seed.slots.order_by(Slot.player_id)]
+    return [(slot.player_name, slot.game) for slot in seed.slots]
 
 
 from . import datapackage, generate, room, user  # trigger registration

WebHostLib/api/user.py

@@ -28,6 +28,6 @@ def get_seeds():
         response.append({
             "seed_id": seed.id,
             "creation_time": seed.creation_time,
-            "players": get_players(seed),
+            "players": get_players(seed.slots),
         })
-    return jsonify(response)
+    return jsonify(response)

WebHostLib/autolauncher.py

@@ -9,7 +9,7 @@ from threading import Event, Thread
 from typing import Any
 from uuid import UUID
 
-from pony.orm import db_session, select, commit, PrimaryKey
+from pony.orm import db_session, select, commit
 
 from Utils import restricted_loads
 from .locker import Locker, AlreadyRunningException
@@ -36,21 +36,12 @@ def handle_generation_failure(result: BaseException):
         logging.exception(e)
 
 
-def _mp_gen_game(gen_options: dict, meta: dict[str, Any] | None = None, owner=None, sid=None) -> PrimaryKey | None:
-    from setproctitle import setproctitle
-
-    setproctitle(f"Generator ({sid})")
-    res = gen_game(gen_options, meta=meta, owner=owner, sid=sid)
-    setproctitle(f"Generator (idle)")
-    return res
-
-
 def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
     try:
         meta = json.loads(generation.meta)
         options = restricted_loads(generation.options)
         logging.info(f"Generating {generation.id} for {len(options)} players")
-        pool.apply_async(_mp_gen_game, (options,),
+        pool.apply_async(gen_game, (options,),
                          {"meta": meta,
                           "sid": generation.id,
                           "owner": generation.owner},
@@ -64,10 +55,6 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
 
 
 def init_generator(config: dict[str, Any]) -> None:
-    from setproctitle import setproctitle
-
-    setproctitle("Generator (idle)")
-
     try:
         import resource
     except ModuleNotFoundError:

WebHostLib/customserver.py

@@ -117,7 +117,6 @@ class WebHostContext(Context):
         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", {})}
-        missing_checksum = False
 
         for game in list(multidata.get("datapackage", {})):
             game_data = multidata["datapackage"][game]
@@ -133,13 +132,11 @@ class WebHostContext(Context):
                         continue
                     else:
                         self.logger.warning(f"Did not find game_data_package for {game}: {game_data['checksum']}")
-            else:
-                missing_checksum = True  # Game rolled on old AP and will load data package from multidata
             self.gamespackage[game] = static_gamespackage.get(game, {})
             self.item_name_groups[game] = static_item_name_groups.get(game, {})
             self.location_name_groups[game] = static_location_name_groups.get(game, {})
 
-        if not game_data_packages and not missing_checksum:
+        if not game_data_packages:
             # all static -> use the static dicts directly
             self.gamespackage = static_gamespackage
             self.item_name_groups = static_item_name_groups
@@ -227,9 +224,6 @@ def set_up_logging(room_id) -> logging.Logger:
 def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                        cert_file: typing.Optional[str], cert_key_file: typing.Optional[str],
                        host: str, rooms_to_run: multiprocessing.Queue, rooms_shutting_down: multiprocessing.Queue):
-    from setproctitle import setproctitle
-
-    setproctitle(name)
     Utils.init_logging(name)
     try:
         import resource
@@ -250,23 +244,8 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
         raise Exception("Worlds system should not be loaded in the custom server.")
 
     import gc
-
-    if not cert_file:
-        def get_ssl_context():
-            return None
-    else:
-        load_date = None
-        ssl_context = load_server_cert(cert_file, cert_key_file)
-
-        def get_ssl_context():
-            nonlocal load_date, ssl_context
-            today = datetime.date.today()
-            if load_date != today:
-                ssl_context = load_server_cert(cert_file, cert_key_file)
-                load_date = today
-            return ssl_context
-
-    del ponyconfig
+    ssl_context = load_server_cert(cert_file, cert_key_file) if cert_file else None
+    del cert_file, cert_key_file, ponyconfig
     gc.collect()  # free intermediate objects used during setup
 
     loop = asyncio.get_event_loop()
@@ -281,12 +260,12 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                 assert ctx.server is None
                 try:
                     ctx.server = websockets.serve(
-                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=get_ssl_context())
+                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
 
                     await ctx.server
                 except OSError:  # likely port in use
                     ctx.server = websockets.serve(
-                        functools.partial(server, ctx=ctx), ctx.host, 0, ssl=get_ssl_context())
+                        functools.partial(server, ctx=ctx), ctx.host, 0, ssl=ssl_context)
 
                     await ctx.server
                 port = 0

WebHostLib/generate.py

@@ -135,7 +135,6 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
                                                                        {"bosses", "items", "connections", "texts"}))
         erargs.skip_prog_balancing = False
         erargs.skip_output = False
-        erargs.spoiler_only = False
         erargs.csv_output = False
 
         name_counter = Counter()

WebHostLib/misc.py

@@ -35,12 +35,6 @@ def start_playing():
 @app.route('/games/<string:game>/info/<string:lang>')
 @cache.cached()
 def game_info(game, lang):
-    try:
-        world = AutoWorldRegister.world_types[game]
-        if lang not in world.web.game_info_languages:
-            raise KeyError("Sorry, this game's info page is not available in that language yet.")
-    except KeyError:
-        return abort(404)
     return render_template('gameInfo.html', game=game, lang=lang, theme=get_world_theme(game))
 
 
@@ -58,12 +52,6 @@ def games():
 @app.route('/tutorial/<string:game>/<string:file>/<string:lang>')
 @cache.cached()
 def tutorial(game, file, lang):
-    try:
-        world = AutoWorldRegister.world_types[game]
-        if lang not in [tut.link.split("/")[1] for tut in world.web.tutorials]:
-            raise KeyError("Sorry, the tutorial is not available in that language yet.")
-    except KeyError:
-        return abort(404)
     return render_template("tutorial.html", game=game, file=file, lang=lang, theme=get_world_theme(game))
 
 

WebHostLib/options.py

@@ -6,7 +6,7 @@ from typing import Dict, Union
 from docutils.core import publish_parts
 
 import yaml
-from flask import redirect, render_template, request, Response, abort
+from flask import redirect, render_template, request, Response
 
 import Options
 from Utils import local_path
@@ -108,7 +108,7 @@ def option_presets(game: str) -> Response:
                     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.OptionCounter)):
+            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
@@ -142,10 +142,7 @@ def weighted_options_old():
 @app.route("/games/<string:game>/weighted-options")
 @cache.cached()
 def weighted_options(game: str):
-    try:
-        return render_options_page("weightedOptions/weightedOptions.html", game, is_complex=True)
-    except KeyError:
-        return abort(404)
+    return render_options_page("weightedOptions/weightedOptions.html", game, is_complex=True)
 
 
 @app.route("/games/<string:game>/generate-weighted-yaml", methods=["POST"])
@@ -200,10 +197,7 @@ def generate_weighted_yaml(game: str):
 @app.route("/games/<string:game>/player-options")
 @cache.cached()
 def player_options(game: str):
-    try:
-        return render_options_page("playerOptions/playerOptions.html", game, is_complex=False)
-    except KeyError:
-        return abort(404)
+    return render_options_page("playerOptions/playerOptions.html", game, is_complex=False)
 
 
 # YAML generator for player-options
@@ -222,7 +216,7 @@ def generate_yaml(game: str):
 
         for key, val in options.copy().items():
             key_parts = key.rsplit("||", 2)
-            # Detect and build OptionCounter options from their name pattern
+            # 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]] = {}

WebHostLib/requirements.txt

@@ -1,12 +1,11 @@
-flask>=3.1.0
-werkzeug>=3.1.3
+flask>=3.0.3
+werkzeug>=3.0.6
 pony>=0.7.19
-waitress>=3.0.2
+waitress>=3.0.0
 Flask-Caching>=2.3.0
-Flask-Compress>=1.17
-Flask-Limiter>=3.12
-bokeh>=3.6.3
-markupsafe>=3.0.2
+Flask-Compress>=1.15
+Flask-Limiter>=3.8.0
+bokeh>=3.5.2
+markupsafe>=2.1.5
 Markdown>=3.7
 mdx-breakless-lists>=1.0.1
-setproctitle>=1.3.5

WebHostLib/static/assets/faq/en.md

@@ -22,7 +22,7 @@ players to rely upon each other to complete their game.
 
 While a multiworld game traditionally requires all players to be playing the same game, a multi-game multiworld allows
 players to randomize any of the supported games, and send items between them. This allows players of different
-games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworlds.
+games to interact with one another in a single multiplayer environment.  Archipelago supports multi-game multiworld.
 Here is a list of our [Supported Games](https://archipelago.gg/games).
 
 ## Can I generate a single-player game with Archipelago?

WebHostLib/static/assets/gameInfo.js

@@ -23,6 +23,7 @@ window.addEventListener('load', () => {
         showdown.setOption('strikethrough', true);
         showdown.setOption('literalMidWordUnderscores', true);
         gameInfo.innerHTML += (new showdown.Converter()).makeHtml(results);
+        adjustHeaderWidth();
 
         // Reset the id of all header divs to something nicer
         for (const header of document.querySelectorAll('h1, h2, h3, h4, h5, h6')) {
@@ -41,5 +42,10 @@ window.addEventListener('load', () => {
                 scrollTarget?.scrollIntoView();
             }
         });
+    }).catch((error) => {
+        console.error(error);
+        gameInfo.innerHTML =
+            `<h2>This page is out of logic!</h2>
+            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
     });
 });

WebHostLib/static/assets/hostGame.js

@@ -6,4 +6,6 @@ window.addEventListener('load', () => {
     document.getElementById('file-input').addEventListener('change', () => {
         document.getElementById('host-game-form').submit();
     });
+
+    adjustFooterHeight();
 });

WebHostLib/static/assets/styleController.js

@@ -0,0 +1,47 @@
+const adjustFooterHeight = () => {
+  // If there is no footer on this page, do nothing
+  const footer = document.getElementById('island-footer');
+  if (!footer) { return; }
+
+  // If the body is taller than the window, also do nothing
+  if (document.body.offsetHeight > window.innerHeight) {
+    footer.style.marginTop = '0';
+    return;
+  }
+
+  // Add a margin-top to the footer to position it at the bottom of the screen
+  const sibling = footer.previousElementSibling;
+  const margin = (window.innerHeight - sibling.offsetTop - sibling.offsetHeight - footer.offsetHeight);
+  if (margin < 1) {
+    footer.style.marginTop = '0';
+    return;
+  }
+  footer.style.marginTop = `${margin}px`;
+};
+
+const adjustHeaderWidth = () => {
+  // If there is no header, do nothing
+  const header = document.getElementById('base-header');
+  if (!header) { return; }
+
+  const tempDiv = document.createElement('div');
+  tempDiv.style.width = '100px';
+  tempDiv.style.height = '100px';
+  tempDiv.style.overflow = 'scroll';
+  tempDiv.style.position = 'absolute';
+  tempDiv.style.top = '-500px';
+  document.body.appendChild(tempDiv);
+  const scrollbarWidth = tempDiv.offsetWidth - tempDiv.clientWidth;
+  document.body.removeChild(tempDiv);
+
+  const documentRoot = document.compatMode === 'BackCompat' ? document.body : document.documentElement;
+  const margin = (documentRoot.scrollHeight > documentRoot.clientHeight) ? 0-scrollbarWidth : 0;
+  document.getElementById('base-header-right').style.marginRight = `${margin}px`;
+};
+
+window.addEventListener('load', () => {
+  window.addEventListener('resize', adjustFooterHeight);
+  window.addEventListener('resize', adjustHeaderWidth);
+  adjustFooterHeight();
+  adjustHeaderWidth();
+});

WebHostLib/static/assets/tutorial.js

@@ -25,6 +25,7 @@ window.addEventListener('load', () => {
         showdown.setOption('literalMidWordUnderscores', true);
         showdown.setOption('disableForced4SpacesIndentedSublists', true);
         tutorialWrapper.innerHTML += (new showdown.Converter()).makeHtml(results);
+        adjustHeaderWidth();
 
         const title = document.querySelector('h1')
         if (title) {
@@ -48,5 +49,10 @@ window.addEventListener('load', () => {
                 scrollTarget?.scrollIntoView();
             }
         });
+    }).catch((error) => {
+        console.error(error);
+        tutorialWrapper.innerHTML =
+            `<h2>This page is out of logic!</h2>
+            <h3>Click <a href="${window.location.origin}/tutorial">here</a> to return to safety.</h3>`;
     });
 });

WebHostLib/static/styles/globalStyles.css

@@ -36,13 +36,6 @@ html{
 
 body{
     margin: 0;
-    display: flex;
-    flex-direction: column;
-    min-height: calc(100vh - 110px);
-}
-
-main {
-    flex-grow: 1;
 }
 
 a{

WebHostLib/static/styles/timespinnerTracker.css

@@ -75,27 +75,6 @@
 #inventory-table img.acquired.green{ /*32CD32*/
     filter: hue-rotate(84deg) saturate(10) brightness(0.7);
 }
-#inventory-table img.acquired.hotpink{ /*FF69B4*/
-    filter: sepia(100%) hue-rotate(300deg) saturate(10);
-}
-#inventory-table img.acquired.lightsalmon{ /*FFA07A*/
-    filter: sepia(100%) hue-rotate(347deg) saturate(10);
-}
-#inventory-table img.acquired.crimson{ /*DB143B*/
-    filter: sepia(100%) hue-rotate(318deg) saturate(10) brightness(0.86);
-}
-
-#inventory-table span{
-    color: #B4B4A0;
-    font-size: 40px;
-    max-width: 40px;
-    max-height: 40px;
-    filter: grayscale(100%) contrast(75%) brightness(30%);
-}
-
-#inventory-table span.acquired{
-    filter: none;
-}
 
 #inventory-table div.image-stack{
     display: grid;

WebHostLib/templates/404.html

@@ -1,6 +1,5 @@
 {% extends 'pageWrapper.html' %}
 {% import "macros.html" as macros %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Page Not Found (404)</title>
@@ -14,4 +13,5 @@
         The page you're looking for doesn&apos;t exist.<br />
         <a href="/">Click here to return to safety.</a>
     </div>
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/hostGame.html

@@ -1,5 +1,4 @@
 {% extends 'pageWrapper.html' %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Upload Multidata</title>
@@ -17,9 +16,7 @@
                 This page allows you to host a game which was not generated by the website. For example, if you have
                 generated a game on your own computer, you may upload the zip file created by the generator to
                 host the game here. This will also provide a tracker, and the ability for your players to download
-                their patch files if the game is core-verified. For Custom Games, you can find the patch files in
-                the output .zip file you are uploading here. You need to manually distribute those patch files to
-                your players.
+                their patch files.
             </p>
             <p>In addition to the zip file created by the generator, you may upload a multidata file here as well.</p>
             <div id="host-game-form-wrapper">
@@ -30,4 +27,6 @@
             </div>
         </div>
     </div>
+
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/landing.html

@@ -1,5 +1,4 @@
 {% extends 'pageWrapper.html' %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Archipelago</title>
@@ -58,4 +57,5 @@
             </div>
         </div>
     </div>
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/pageWrapper.html

@@ -5,29 +5,26 @@
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/tooltip.css") }}" />
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/cookieNotice.css") }}" />
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/globalStyles.css") }}" />
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/styleController.js") }}"></script>
     <script type="application/ecmascript" src="{{ url_for('static', filename="assets/cookieNotice.js") }}"></script>
     {% block head %}
         <title>Archipelago</title>
     {% endblock %}
 </head>
 <body>
-    <main>
-        {% with messages = get_flashed_messages() %}
-            {% if messages %}
-                <div>
-                    {% for message in messages | unique %}
-                        <div class="user-message">{{ message }}</div>
-                    {% endfor %}
-                </div>
-            {% endif %}
-        {% endwith %}
 
-        {% block body %}
-        {% endblock %}
-    </main>
-
-    {% if show_footer %}
-        {% include "islandFooter.html" %}
+{% with messages = get_flashed_messages() %}
+    {% if messages %}
+        <div>
+            {% for message in messages | unique %}
+                <div class="user-message">{{ message }}</div>
+            {% endfor %}
+        </div>
     {% endif %}
+{% endwith %}
+
+{% block body %}
+{% endblock %}
+
 </body>
 </html>

WebHostLib/templates/playerOptions/macros.html

@@ -111,19 +111,10 @@
     </div>
 {% endmacro %}
 
-{% macro OptionCounter(option_name, option) %}
-    {% set relevant_keys = option.valid_keys %}
-    {% if not relevant_keys %}
-        {% if option.verify_item_name %}
-            {% set relevant_keys = world.item_names %}
-        {% elif option.verify_location_name %}
-            {% set relevant_keys = world.location_names %}
-        {% endif %}
-    {% endif %}
-
+{% macro ItemDict(option_name, option) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
-        {% for item_name in (relevant_keys if relevant_keys is ordered else relevant_keys|sort) %}
+        {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
             <div class="option-entry">
                 <label for="{{ option_name }}-{{ item_name }}-qty">{{ item_name }}</label>
                 <input type="number" id="{{ option_name }}-{{ item_name }}-qty" name="{{ option_name }}||{{ item_name }}||qty" value="{{ option.default[item_name]|default("0") }}" data-option-name="{{ option_name }}" data-item-name="{{ item_name }}" />
@@ -222,7 +213,7 @@
 {% endmacro %}
 
 {% macro RandomizeButton(option_name, option) %}
-    <div class="randomize-button" data-tooltip="Pick a random value for this option.">
+    <div class="randomize-button" data-tooltip="Toggle randomization for this option!">
         <label for="random-{{ option_name }}">
             <input type="checkbox" id="random-{{ option_name }}" name="random-{{ option_name }}" class="randomize-checkbox" data-option-name="{{ option_name }}" {{ "checked" if option.default == "random" }} />
             🎲

WebHostLib/templates/playerOptions/playerOptions.html

@@ -93,10 +93,8 @@
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.OptionCounter) and (
-                                            option.valid_keys or option.verify_item_name or option.verify_location_name
-                                        ) %}
-                                            {{ inputs.OptionCounter(option_name, option) }}
+                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                            {{ inputs.ItemDict(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}
@@ -135,10 +133,8 @@
                                         {% elif issubclass(option, Options.FreeText) %}
                                             {{ inputs.FreeText(option_name, option) }}
 
-                                        {% elif issubclass(option, Options.OptionCounter) and (
-                                            option.valid_keys or option.verify_item_name or option.verify_location_name
-                                        ) %}
-                                            {{ inputs.OptionCounter(option_name, option) }}
+                                        {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                            {{ inputs.ItemDict(option_name, option) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}

WebHostLib/templates/seedError.html

@@ -1,6 +1,5 @@
 {% extends 'pageWrapper.html' %}
 {% import "macros.html" as macros %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Generation failed, please retry.</title>
@@ -16,4 +15,5 @@
             {{ seed_error }}
         </div>
     </div>
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/startPlaying.html

@@ -1,5 +1,4 @@
 {% extends 'pageWrapper.html' %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Start Playing</title>
@@ -27,4 +26,6 @@
             </p>
         </div>
     </div>
+
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/tracker__Timespinner.html

@@ -99,52 +99,6 @@
                 {% endif %}
                 </div>
             </div>
-            {% if 'PrismBreak' in options or 'LockKeyAmadeus' in options or 'GateKeep' in options %}
-            <div class="table-row">
-                {% if 'PrismBreak' in options %}
-                <div class="C1">
-                    <div class="image-stack">
-                        <div class="stack-front">
-                            <div class="stack-top-left">
-                                <img src="{{ icons['Laser Access'] }}" class="hotpink {{ 'acquired' if 'Laser Access A' in acquired_items }}" title="Laser Access A" />
-                            </div>
-                            <div class="stack-top-right">
-                                <img src="{{ icons['Laser Access'] }}" class="lightsalmon {{ 'acquired' if 'Laser Access I' in acquired_items }}" title="Laser Access I" />
-                            </div>
-                            <div class="stack-bottum-left">
-                                <img src="{{ icons['Laser Access'] }}" class="crimson {{ 'acquired' if 'Laser Access M' in acquired_items }}" title="Laser Access M" />
-                            </div>
-                        </div>
-                    </div>
-		</div>
-                {% endif %}
-                {% if 'LockKeyAmadeus' in options %}
-                <div class="C2">
-                    <div class="image-stack">
-                        <div class="stack-front">
-                            <div class="stack-top-left">
-                                <img src="{{ icons['Lab Glasses'] }}" class="{{ 'acquired' if 'Lab Access Genza' in acquired_items }}" title="Lab Access Genza" />
-                            </div>
-                            <div class="stack-top-right">
-                                <img src="{{ icons['Eye Orb'] }}" class="{{ 'acquired' if 'Lab Access Dynamo' in acquired_items }}" title="Lab Access Dynamo" />
-                            </div>
-                            <div class="stack-bottum-left">
-                                <img src="{{ icons['Lab Coat'] }}" class="{{ 'acquired' if 'Lab Access Research' in acquired_items }}" title="Lab Access Research" />
-                            </div>
-                            <div class="stack-bottum-right">
-                                <img src="{{ icons['Demon'] }}" class="{{ 'acquired' if 'Lab Access Experiment' in acquired_items }}" title="Lab Access Experiment" />
-                            </div>
-                        </div>
-                    </div>
-		</div>
-                {% endif %}
-                {% if 'GateKeep' in options %}
-                <div class="C3">
-                    <span class="{{ 'acquired' if 'Drawbridge Key' in acquired_items }}" title="Drawbridge Key">&#10070;</span>
-		</div>
-                {% endif %}
-	    </div>
-            {% endif %}
         </div>
 
         <table id="location-table">

WebHostLib/templates/userContent.html

@@ -29,8 +29,7 @@
     <div id="user-content-wrapper" class="markdown">
         <div id="user-content" class="grass-island">
             <h1>User Content</h1>
-            Below is a list of all the content you have generated on this site. Rooms and seeds are listed separately.<br/>
-            Sessions can be saved or synced across devices using the <a href="{{url_for('show_session')}}">Sessions Page.</a>
+            Below is a list of all the content you have generated on this site. Rooms and seeds are listed separately.
 
             <h2>Your Rooms</h2>
             {% if rooms %}

WebHostLib/templates/viewSeed.html

@@ -1,6 +1,5 @@
 {% extends 'pageWrapper.html' %}
 {% import "macros.html" as macros %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>View Seed {{ seed.id|suuid }}</title>
@@ -51,4 +50,5 @@
             </table>
         </div>
     </div>
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/waitSeed.html

@@ -1,12 +1,9 @@
 {% extends 'pageWrapper.html' %}
 {% import "macros.html" as macros %}
-{% set show_footer = True %}
 
 {% block head %}
     <title>Generation in Progress</title>
-    <noscript>
-        <meta http-equiv="refresh" content="1">
-    </noscript>
+    <meta http-equiv="refresh" content="1">
     <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/waitSeed.css") }}"/>
 {% endblock %}
 
@@ -18,34 +15,5 @@
             Waiting for game to generate, this page auto-refreshes to check.
         </div>
     </div>
-    <script>
-        const waitSeedDiv = document.getElementById("wait-seed");
-        async function checkStatus() {
-            try {
-                const response = await fetch("{{ url_for('api.wait_seed_api', seed=seed_id) }}");
-                if (response.status !== 202) {
-                    // Seed is ready; reload page to load seed page.
-                    location.reload();
-                    return;
-                }
-
-                const data = await response.json();
-                waitSeedDiv.innerHTML = `
-                    <h1>Generation in Progress</h1>
-                    <p>${data.text}</p>
-                `;
-
-                setTimeout(checkStatus, 1000); // Continue polling.
-            } catch (error) {
-                waitSeedDiv.innerHTML = `
-                    <h1>Progress Unknown</h1>
-                    <p>${error.message}<br />(Last checked: ${new Date().toLocaleTimeString()})</p>
-                `;
-
-                setTimeout(checkStatus, 1000);
-            }
-        }
-
-        setTimeout(checkStatus, 1000);
-    </script>
+    {% include 'islandFooter.html' %}
 {% endblock %}

WebHostLib/templates/weightedOptions/macros.html

@@ -113,18 +113,9 @@
     {{ TextChoice(option_name, option) }}
 {% endmacro %}
 
-{% macro OptionCounter(option_name, option, world) %}
-    {% set relevant_keys = option.valid_keys %}
-    {% if not relevant_keys %}
-        {% if option.verify_item_name %}
-            {% set relevant_keys = world.item_names %}
-        {% elif option.verify_location_name %}
-            {% set relevant_keys = world.location_names %}
-        {% endif %}
-    {% endif %}
-
+{% macro ItemDict(option_name, option, world) %}
     <div class="dict-container">
-        {% for item_name in (relevant_keys if relevant_keys is ordered else relevant_keys|sort) %}
+        {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
             <div class="dict-entry">
                 <label for="{{ option_name }}-{{ item_name }}-qty">{{ item_name }}</label>
                 <input

WebHostLib/templates/weightedOptions/weightedOptions.html

@@ -83,10 +83,8 @@
                                 {% elif issubclass(option, Options.FreeText) %}
                                     {{ inputs.FreeText(option_name, option) }}
 
-                                {% elif issubclass(option, Options.OptionCounter) and (
-                                    option.valid_keys or option.verify_item_name or option.verify_location_name
-                                ) %}
-                                    {{ inputs.OptionCounter(option_name, option, world) }}
+                                {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
+                                    {{ inputs.ItemDict(option_name, option, world) }}
 
                                 {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                     {{ inputs.OptionList(option_name, option) }}
@@ -102,7 +100,7 @@
 
                                 {% else %}
                                     <div class="unsupported-option">
-                                        This option cannot be modified here. Please edit your .yaml file manually.
+                                        This option is not supported. Please edit your .yaml file manually.
                                     </div>
 
                                 {% endif %}

WebHostLib/tracker.py

@@ -1071,11 +1071,6 @@ if "Timespinner" in network_data_package["games"]:
             "Plasma Orb":          "https://timespinnerwiki.com/mediawiki/images/4/44/Plasma_Orb.png",
             "Kobo":                "https://timespinnerwiki.com/mediawiki/images/c/c6/Familiar_Kobo.png",
             "Merchant Crow":       "https://timespinnerwiki.com/mediawiki/images/4/4e/Familiar_Crow.png",
-            "Laser Access":        "https://timespinnerwiki.com/mediawiki/images/9/99/Historical_Documents.png",
-            "Lab Glasses":         "https://timespinnerwiki.com/mediawiki/images/4/4a/Lab_Glasses.png",
-            "Eye Orb":             "https://timespinnerwiki.com/mediawiki/images/a/a4/Eye_Orb.png",
-            "Lab Coat":            "https://timespinnerwiki.com/mediawiki/images/5/51/Lab_Coat.png", 
-            "Demon":               "https://timespinnerwiki.com/mediawiki/images/f/f8/Familiar_Demon.png", 
         }
 
         timespinner_location_ids = {
@@ -1123,9 +1118,6 @@ if "Timespinner" in network_data_package["games"]:
             timespinner_location_ids["Ancient Pyramid"] += [
                 1337237, 1337238, 1337239,
                 1337240, 1337241, 1337242, 1337243, 1337244, 1337245]
-        if (slot_data["PyramidStart"]):
-            timespinner_location_ids["Ancient Pyramid"] += [
-                1337233, 1337234, 1337235]
 
         display_data = {}
 

Zelda1Client.py

@@ -386,7 +386,7 @@ if __name__ == '__main__':
     parser.add_argument('diff_file', default="", type=str, nargs="?",
                         help='Path to a Archipelago Binary Patch file')
     args = parser.parse_args()
-    colorama.just_fix_windows_console()
+    colorama.init()
 
     asyncio.run(main(args))
     colorama.deinit()

data/client.kv

@@ -14,60 +14,23 @@
     salmon: "FA8072"  # typically trap item
     white: "FFFFFF"  # not used, if you want to change the generic text color change color in Label
     orange: "FF7700"  # Used for command echo
-    # KivyMD theming parameters
-    theme_style: "Dark" # Light/Dark
-    primary_palette: "Lightsteelblue" # Many options
-    dynamic_scheme_name: "VIBRANT"
-    dynamic_scheme_contrast: 0.0
-<MDLabel>:
-    color: self.theme_cls.primaryColor
-<BaseButton>:
-    ripple_color: app.theme_cls.primaryColor
-    ripple_duration_in_fast: 0.2
-<MDTabsItemBase>:
-    ripple_color: app.theme_cls.primaryColor
-    ripple_duration_in_fast: 0.2
+<Label>:
+    color: "FFFFFF"
+<TabbedPanel>:
+    tab_width: root.width / app.tab_count
 <TooltipLabel>:
-    adaptive_height: True
-    theme_font_size: "Custom"
-    font_size: "20dp"
+    text_size: self.width, None
+    size_hint_y: None
+    height: self.texture_size[1]
+    font_size: dp(20)
     markup: True
-    halign: "left"
 <SelectableLabel>:
-    size_hint: 1, None
-    theme_text_color: "Custom"
-    text_color: 1, 1, 1, 1
     canvas.before:
         Color:
-            rgba: (self.theme_cls.primaryColor[0], self.theme_cls.primaryColor[1], self.theme_cls.primaryColor[2], .3) if self.selected else self.theme_cls.surfaceContainerLowestColor
+            rgba: (.0, 0.9, .1, .3) if self.selected else (0.2, 0.2, 0.2, 1)
         Rectangle:
             size: self.size
             pos: self.pos
-<MarkupDropdownItem>
-    orientation: "vertical"
-
-    MDLabel:
-        text: root.text
-        valign: "center"
-        padding_x: "12dp"
-        shorten: True
-        shorten_from: "right"
-        theme_text_color: "Custom"
-        markup: True
-        text_color:
-            app.theme_cls.onSurfaceVariantColor \
-            if not root.text_color else \
-            root.text_color
-
-    MDDivider:
-        md_bg_color:
-            ( \
-            app.theme_cls.outlineVariantColor \
-            if not root.divider_color \
-            else root.divider_color \
-            ) \
-            if root.divider else \
-            (0, 0, 0, 0)
 <UILog>:
     messages: 1000 # amount of messages stored in client logs.
     cols: 1
@@ -86,7 +49,7 @@
 <HintLabel>:
     canvas.before:
         Color:
-            rgba: (.0, 0.9, .1, .3) if self.selected else self.theme_cls.surfaceContainerHighColor if self.striped else self.theme_cls.surfaceContainerLowColor
+            rgba: (.0, 0.9, .1, .3) if self.selected else (0.2, 0.2, 0.2, 1) if self.striped else (0.18, 0.18, 0.18, 1)
         Rectangle:
             size: self.size
             pos: self.pos
@@ -163,12 +126,9 @@
 <ToolTip>:
     size: self.texture_size
     size_hint: None, None
-    theme_font_size: "Custom"
     font_size: dp(18)
     pos_hint: {'center_y': 0.5, 'center_x': 0.5}
     halign: "left"
-    theme_text_color: "Custom"
-    text_color: (1, 1, 1, 1)
     canvas.before:
         Color:
             rgba: 0.2, 0.2, 0.2, 1
@@ -187,38 +147,3 @@
             rectangle: self.x-2, self.y-2, self.width+4, self.height+4
 <ServerToolTip>:
     pos_hint: {'center_y': 0.5, 'center_x': 0.5}
-<AutocompleteHintInput>:
-    size_hint_y: None
-    height: "30dp"
-    multiline: False
-    write_tab: False
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<ConnectBarTextInput>:
-    height: "30dp"
-    multiline: False
-    write_tab: False
-    role: "medium"
-    size_hint_y: None
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<CommandPromptTextInput>:
-    size_hint_y: None
-    height: "30dp"
-    multiline: False
-    write_tab: False
-    pos_hint: {"center_x": 0.5, "center_y": 0.5}
-<MessageBoxLabel>:
-    theme_text_color: "Custom"
-    text_color: 1, 1, 1, 1
-<ScrollBox>:
-    layout: layout
-    bar_width: "12dp"
-    scroll_wheel_distance: 40
-    do_scroll_x: False
-    scroll_type: ['bars', 'content']
-
-    MDBoxLayout:
-        id: layout
-        orientation: "vertical"
-        spacing: 10
-        size_hint_y: None
-        height: self.minimum_height

data/launcher.kv

@@ -1,161 +0,0 @@
-<LauncherCard>:
-    id: main
-    style: "filled"
-    padding: "4dp"
-    size_hint: 1, None
-    height: "75dp"
-    context_button: context
-    focus_behavior: False
-
-    MDRelativeLayout:
-        ApAsyncImage:
-            source: main.image
-            size: (48, 48)
-            size_hint: None, None
-            pos_hint: {"center_x": 0.1, "center_y": 0.5}
-
-        MDLabel:
-            text: main.component.display_name
-            pos_hint:{"center_x": 0.5, "center_y": 0.75 if main.component.description else 0.65}
-            halign: "center"
-            font_style: "Title"
-            role: "medium"
-            theme_text_color: "Custom"
-            text_color: app.theme_cls.primaryColor
-
-        MDLabel:
-            text: main.component.description
-            pos_hint: {"center_x": 0.5, "center_y": 0.35}
-            halign: "center"
-            role: "small"
-            theme_text_color: "Custom"
-            text_color: app.theme_cls.primaryColor
-
-        MDIconButton:
-            component: main.component
-            icon: "star" if self.component.display_name in app.favorites else "star-outline"
-            style: "standard"
-            pos_hint:{"center_x": 0.85, "center_y": 0.8}
-            theme_text_color: "Custom"
-            text_color: app.theme_cls.primaryColor
-            detect_visible: False
-            on_release: app.set_favorite(self)
-
-        MDIconButton:
-            id: context
-            icon: "menu"
-            style: "standard"
-            pos_hint:{"center_x": 0.95, "center_y": 0.8}
-            theme_text_color: "Custom"
-            text_color: app.theme_cls.primaryColor
-            detect_visible: False
-
-        MDButton:
-            pos_hint:{"center_x": 0.9, "center_y": 0.25}
-            size_hint_y: None
-            height: "25dp"
-            component: main.component
-            on_release: app.component_action(self)
-            detect_visible: False
-            MDButtonText:
-                text: "Open"
-
-
-#:import Type worlds.LauncherComponents.Type
-MDFloatLayout:
-    id: top_screen
-
-    MDGridLayout:
-        id: grid
-        cols: 2
-        spacing: "5dp"
-        padding: "10dp"
-
-        MDGridLayout:
-            id: navigation
-            cols: 1
-            size_hint_x: 0.25
-
-            MDButton:
-                id: all
-                style: "text"
-                type: (Type.CLIENT, Type.TOOL, Type.ADJUSTER, Type.MISC)
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "asterisk"
-                MDButtonText:
-                    text: "All"
-            MDButton:
-                id: client
-                style: "text"
-                type: (Type.CLIENT, )
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "controller"
-                MDButtonText:
-                    text: "Client"
-            MDButton:
-                id: Tool
-                style: "text"
-                type: (Type.TOOL, )
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "desktop-classic"
-                MDButtonText:
-                    text: "Tool"
-            MDButton:
-                id: adjuster
-                style: "text"
-                type: (Type.ADJUSTER, )
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "wrench"
-                MDButtonText:
-                    text: "Adjuster"
-            MDButton:
-                id: misc
-                style: "text"
-                type: (Type.MISC, )
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "dots-horizontal-circle-outline"
-                MDButtonText:
-                    text: "Misc"
-
-            MDButton:
-                id: favorites
-                style: "text"
-                type: ("favorites", )
-                on_release: app.filter_clients_by_type(self)
-
-                MDButtonIcon:
-                    icon: "star"
-                MDButtonText:
-                    text: "Favorites"
-
-            MDNavigationDrawerDivider:
-
-
-        MDGridLayout:
-            id: main_layout
-            cols: 1
-            spacing: "10dp"
-
-            MDTextField:
-                id: search_box
-                mode: "outlined"
-                set_text: app.filter_clients_by_name
-
-                MDTextFieldLeadingIcon:
-                    icon: "magnify"
-
-                MDTextFieldHintText:
-                    text: "Search"
-
-            ScrollBox:
-                id: button_layout

data/lua/connector_bizhawk_generic.lua

@@ -121,14 +121,6 @@ Response:
 
     Expected Response Type: `HASH_RESPONSE`
 
-- `MEMORY_SIZE`  
-    Returns the size in bytes of the specified memory domain.
-
-    Expected Response Type: `MEMORY_SIZE_RESPONSE`
-
-    Additional Fields:
-    - `domain` (`string`): The name of the memory domain to check
-
 - `GUARD`  
     Checks a section of memory against `expected_data`. If the bytes starting
     at `address` do not match `expected_data`, the response will have `value`
@@ -224,12 +216,6 @@ Response:
     Additional Fields:
     - `value` (`string`): The returned hash
 
-- `MEMORY_SIZE_RESPONSE`  
-    Contains the size in bytes of the specified memory domain.
-
-    Additional Fields:
-    - `value` (`number`): The size of the domain in bytes
-
 - `GUARD_RESPONSE`  
     The result of an attempted `GUARD` request.
 
@@ -390,15 +376,6 @@ request_handlers = {
         return res
     end,
 
-    ["MEMORY_SIZE"] = function (req)
-        local res = {}
-
-        res["type"] = "MEMORY_SIZE_RESPONSE"
-        res["value"] = memory.getmemorydomainsize(req["domain"])
-
-        return res
-    end,
-
     ["GUARD"] = function (req)
         local res = {}
         local expected_data = base64.decode(req["expected_data"])
@@ -636,11 +613,9 @@ end)
 
 if bizhawk_major < 2 or (bizhawk_major == 2 and bizhawk_minor < 7) then
     print("Must use BizHawk 2.7.0 or newer")
+elseif bizhawk_major > 2 or (bizhawk_major == 2 and bizhawk_minor > 9) then
+    print("Warning: This version of BizHawk is newer than this script. If it doesn't work, consider downgrading to 2.9.")
 else
-    if bizhawk_major > 2 or (bizhawk_major == 2 and bizhawk_minor > 10) then
-        print("Warning: This version of BizHawk is newer than this script. If it doesn't work, consider downgrading to 2.10.")
-    end
-
     if emu.getsystemid() == "NULL" then
         print("No ROM is loaded. Please load a ROM.")
         while emu.getsystemid() == "NULL" do

data/lua/connector_oot.lua

@@ -1816,7 +1816,7 @@ end
 
 -- Main control handling: main loop and socket receive
 
-function APreceive()
+function receive()
     l, e = ootSocket:receive()
     -- Handle incoming message
     if e == 'closed' then
@@ -1874,7 +1874,7 @@ function main()
         end
         if (curstate == STATE_OK) or (curstate == STATE_INITIAL_CONNECTION_MADE) or (curstate == STATE_TENTATIVELY_CONNECTED) then
             if (frame % 30 == 0) then
-                APreceive()
+                receive()
             end
         elseif (curstate == STATE_UNINITIALIZED) then
             if  (frame % 60 == 0) then

docs/CODEOWNERS

@@ -45,9 +45,6 @@
 # ChecksFinder
 /worlds/checksfinder/ @SunCatMC
 
-# Civilization VI
-/worlds/civ6/ @hesto2
-
 # Clique
 /worlds/clique/ @ThePhar
 
@@ -102,9 +99,6 @@
 # Lingo
 /worlds/lingo/ @hatkirby
 
-# Links Awakening DX
-/worlds/ladx/ @threeandthreee
-
 # Lufia II Ancient Cave
 /worlds/lufia2ac/ @el-u
 /worlds/lufia2ac/docs/ @wordfcuk @el-u
@@ -184,6 +178,9 @@
 # Secret of Evermore
 /worlds/soe/ @black-sliver
 
+# Slay the Spire
+/worlds/spire/ @KonoTyran
+
 # Stardew Valley
 /worlds/stardew_valley/ @agilbert1412
 
@@ -211,9 +208,6 @@
 # Wargroove
 /worlds/wargroove/ @FlySniper
 
-# The Wind Waker
-/worlds/tww/ @tanjo3
-
 # The Witness
 /worlds/witness/ @NewSoupVi @blastron
 
@@ -229,6 +223,10 @@
 # Zillion
 /worlds/zillion/ @beauxq
 
+# 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
@@ -238,6 +236,9 @@
 # Final Fantasy (1)
 # /worlds/ff1/
 
+# Links Awakening DX
+# /worlds/ladx/
+
 # Ocarina of Time
 # /worlds/oot/
 

docs/adding games.md

@@ -1,8 +1,5 @@
 # Adding Games
 
-Like all contributions to Archipelago, New Game implementations should follow the [Contributing](/docs/contributing.md)
-guide.
-
 Adding a new game to Archipelago has two major parts:
 
 * Game Modification to communicate with Archipelago server (hereafter referred to as "client")
@@ -16,51 +13,30 @@ it will not be detailed here.
 
 The client is an intermediary program between the game and the Archipelago server. This can either be a direct
 modification to the game, an external program, or both. This can be implemented in nearly any modern language, but it
-must fulfill a few requirements in order to function as expected. Libraries for most modern languages and the spec for 
-various packets can be found in the [network protocol](/docs/network%20protocol.md) API reference document.
-
-### Hard Requirements
-
-In order for the game client to behave as expected, it must be able to perform these functions:
+must fulfill a few requirements in order to function as expected. The specific requirements the game client must follow
+to behave as expected are:
 
 * Handle both secure and unsecure websocket connections
-* Reconnect if the connection is unstable and lost while playing
+* Detect and react when a location has been "checked" by the player by sending a network packet to the server
+* Receive and parse network packets when the player receives an item from the server, and reward it to the player on
+demand
+  * **Any** of your items can be received any number of times, up to and far surpassing those that the game might
+normally expect from features such as starting inventory, item link replacement, or item cheating
+  * Players and the admin can cheat items to the player at any time with a server command, and these items may not have
+a player or location attributed to them
 * Be able to change the port for saved connection info
   * Rooms hosted on the website attempt to reserve their port, but since there are a limited number of ports, this
-    privilege can be lost, requiring the room to be moved to a new port
+privilege can be lost, requiring the room to be moved to a new port
+* Reconnect if the connection is unstable and lost while playing
+* Keep an index for items received in order to resync. The ItemsReceived Packets are a single list with guaranteed 
+order.
+* Receive items that were sent to the player while they were not connected to the server
+  * The player being able to complete checks while offline and sending them when reconnecting is a good bonus, but not 
+strictly required
 * Send a status update packet alerting the server that the player has completed their goal
 
-Regarding items and locations, the game client must be able to handle these tasks:
-
-#### Location Handling
-
-Send a network packet to the server when it detects a location has been "checked" by the player in-game.
-
-* If actions were taken in game that would usually trigger a location check, and those actions can only ever be taken 
-  once, but the client was not connected when they happened: The client must send those location checks on connection 
-  so that they are not permanently lost, e.g. by reading flags in the game state or save file.
-
-#### Item Handling
-
-Receive and parse network packets from the server when the player receives an item.
-
-* It must reward items to the player on demand, as items can come from other players at any time.
-* It must be able to reward copies of an item, up to and beyond the number the game normally expects. This may happen
-  due to features such as starting inventory, item link replacement, admin commands, or item cheating. **Any** of 
-  your items can be received **any** number of times.
-* Admins and players may use server commands to create items without a player or location attributed to them. The
-  client must be able to handle these items.
-* It must keep an index for items received in order to resync. The ItemsReceived Packets are a single list with a
-  guaranteed order.
-* It must be able to receive items that were sent to the player while they were not connected to the server.
-
-### Encouraged Features
-
-These are "nice to have" features for a client, but they are not strictly required. It is encouraged to add them 
-if possible.
-
-* If your client appears in the Archipelago Launcher, you may define an icon for it that differentiates it from
-  other clients. The icon size is 48x48 pixels, but smaller or larger images will scale to that size.
+Libraries for most modern languages and the spec for various packets can be found in the
+[network protocol](/docs/network%20protocol.md) API reference document.
 
 ## World
 
@@ -68,94 +44,35 @@ The world is your game integration for the Archipelago generator, webhost, and m
 information necessary for creating the items and locations to be randomized, the logic for item placement, the 
 datapackage information so other game clients can recognize your game data, and documentation. Your world must be
 written as a Python package to be loaded by Archipelago. This is currently done by creating a fork of the Archipelago
-repository and creating a new world package in `/worlds/`. 
+repository and creating a new world package in `/worlds/`. A bare minimum world implementation must satisfy the 
+following requirements:
 
-The base World class can be found in [AutoWorld](/worlds/AutoWorld.py). Methods available for your world to call 
-during generation can be found in [BaseClasses](/BaseClasses.py) and [Fill](/Fill.py). Some examples and documentation 
-regarding the API can be found in the [world api doc](/docs/world%20api.md). Before publishing, make sure to also 
-check out [world maintainer.md](/docs/world%20maintainer.md).
-
-### Hard Requirements
-
-A bare minimum world implementation must satisfy the following requirements:
-
-* It has a folder with the name of your game (or an abbreviation) under `/worlds/` 
-* The `/worlds/{game}` folder contains an `__init__.py`
-* Any subfolders within `/worlds/{game}` that contain `*.py` files also contain an `__init__.py` for frozen build 
-  packaging
-* The game folder has at least one game_info doc named with follow the format `{language_code}_{game_name}.md`
-* The game folder has at least one setup doc
-* There must be a `World` subclass in your game folder (typically in `/worlds/{game}/__init__.py`) where you create 
-  your world and define all of its rules and features
-
-Within the `World` subclass you should also have:
-
-* A [unique game name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L260)
-* An [instance](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L295) of a `WebWorld` 
-subclass for webhost documentation and behaviors
-  * In your `WebWorld`, if you wrote a game_info doc in more than one language, override the list of 
-    [game info languages](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L210) with the 
-    ones you include.
-  * In your `WebWorld`, override the list of 
-    [tutorials](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L213) with each tutorial
-    or setup doc you included in the game folder.
+* A folder within `/worlds/` that contains an `__init__.py`
+* A `World` subclass where you create your world and define all of its rules
+* A unique game name
+* For webhost documentation and behaviors, a `WebWorld` subclass that must be instantiated in the `World` class 
+definition
+  * The game_info doc must follow the format `{language_code}_{game_name}.md`
 * A mapping for items and locations defining their names and ids for clients to be able to identify them. These are 
-  `item_name_to_id` and `location_name_to_id`, respectively.
-* An implementation of `create_item` that can create an item when called by either your code or by another process 
-  within Archipelago
-* At least one `Region` for your player to start from (i.e. the Origin Region)
-  * The default name of this region is "Menu" but you may configure a different name with 
-    [origin_region_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L298-L299)
-* A non-zero number of locations, added to your regions
-* A non-zero number of items **equal** to the number of locations, added to the multiworld itempool
-  * In rare cases, there may be 0-location-0-item games, but this is extremely atypical.
-* A set 
-  [completion condition](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#L77) (aka "goal") for
-  the player.
-  * Use your player as the index (`multiworld.completion_condition[player]`) for your world's completion goal.
-
-### Encouraged Features
-
-These are "nice to have" features for a world, but they are not strictly required. It is encouraged to add them 
-if possible.
-
-* An implementation of
-  [get_filler_item_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L473)
-  * By default, this function chooses any item name from `item_name_to_id`, so you want to limit it to only the true
-    filler items.
+`item_name_to_id` and `location_name_to_id`, respectively.
+* Create an item when `create_item` is called both by your code and externally
 * An `options_dataclass` defining the options players have available to them
-  * This should be accompanied by a type hint for `options` with the same class name
-* A [bug report page](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L220)
-* A list of [option groups](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L226) 
-  for better organization on the webhost
-* A dictionary of [options presets](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L223)
-  for player convenience
-* A dictionary of [item name groups](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L273)
-  for player convenience
-* A dictionary of 
-  [location name groups](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L276)
-  for player convenience
-  * Other games may also benefit from your name group dictionaries for hints, features, etc.
+* A `Region` for your player with the name "Menu" to start from
+* Create a non-zero number of locations and add them to your regions
+* Create a non-zero number of items **equal** to the number of locations and add them to the multiworld itempool
+* All items submitted to the multiworld itempool must not be manually placed by the World. If you need to place specific 
+items, there are multiple ways to do so, but they should not be added to the multiworld itempool.
 
-### Discouraged or Prohibited Behavior
-
-These are behaviors or implementations that are known to cause various issues. Some of these points have notable
-workarounds or preferred methods which should be used instead:
-
-* All items submitted to the multiworld itempool must not be manually placed by the World. 
-  * If you need to place specific items, there are multiple ways to do so, but they should not be added to the 
-    multiworld itempool.
-* It is not allowed to use `eval` for most reasons, chiefly due to security concerns. 
-* It is discouraged to use PyYAML (i.e. `yaml.load`) directly due to security concerns.
-  * When possible, use `Utils.parse_yaml` instead, as this defaults to the safe loader and the faster C parser.
-* When submitting regions or items to the multiworld (`multiworld.regions` and `multiworld.itempool` respectively), 
-  do **not** use `=` as this will overwrite all elements for all games in the seed.
-  * Instead, use `append`, `extend`, or `+=`.
-
-### Notable Caveats
-
-* The Origin Region will always be considered the "start" for the player
-* The Origin Region is *always* considered accessible; i.e. the player is expected to always be able to return to the
+Notable caveats:
+* The "Menu" region will always be considered the "start" for the player
+* The "Menu" region is *always* considered accessible; i.e. the player is expected to always be able to return to the
 start of the game from anywhere
+* When submitting regions or items to the multiworld (multiworld.regions and multiworld.itempool respectively), use 
+`append`, `extend`, or `+=`. **Do not use `=`**
 * Regions are simply containers for locations that share similar access rules. They do not have to map to 
 concrete, physical areas within your game and can be more abstract like tech trees or a questline.
+
+The base World class can be found in [AutoWorld](/worlds/AutoWorld.py). Methods available for your world to call during
+generation can be found in [BaseClasses](/BaseClasses.py) and [Fill](/Fill.py). Some examples and documentation 
+regarding the API can be found in the [world api doc](/docs/world%20api.md).
+Before publishing, make sure to also check out [world maintainer.md](/docs/world%20maintainer.md).

docs/apworld_dev_faq.md

@@ -8,11 +8,7 @@ including [Contributing](contributing.md), [Adding Games](<adding games.md>), an
 
 ### My game has a restrictive start that leads to fill errors
 
-A "restrictive start" here means having a combination of very few sphere 1 locations and potentially requiring more
-than one item to get a player to sphere 2.
-
-One way to fix this is to hint to the Generator that an item needs to be in sphere one with local_early_items. 
-Here, `1` represents the number of "Sword" items the Generator will attempt to place in sphere one.
+Hint to the Generator that an item needs to be in sphere one with local_early_items. Here, `1` represents the number of "Sword" items to attempt to place in sphere one.
 ```py
 early_item_name = "Sword"
 self.multiworld.local_early_items[self.player][early_item_name] = 1
@@ -22,19 +18,15 @@ Some alternative ways to try to fix this problem are:
 * Add more locations to sphere one of your world, potentially only when there would be a restrictive start
 * Pre-place items yourself, such as during `create_items`
 * Put items into the player's starting inventory using `push_precollected`
-* Raise an exception, such as an `OptionError` during `generate_early`, to disallow options that would lead to a
-  restrictive start
+* Raise an exception, such as an `OptionError` during `generate_early`, to disallow options that would lead to a restrictive start
 
 ---
 
-### I have multiple options that change the item/location pool counts and need to make sure I am not submitting more/fewer items than locations
+### I have multiple settings that change the item/location pool counts and need to balance them out
 
-In an ideal situation your system for producing locations and items wouldn't leave any opportunity for them to be
-unbalanced. But in real, complex situations, that might be unfeasible.
+In an ideal situation your system for producing locations and items wouldn't leave any opportunity for them to be unbalanced. But in real, complex situations, that might be unfeasible.
 
-If that's the case, you can create extra filler based on the difference between your unfilled locations and your
-itempool by comparing [get_unfilled_locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#:~:text=get_unfilled_locations)
-to your list of items to submit
+If that's the case, you can create extra filler based on the difference between your unfilled locations and your itempool by comparing [get_unfilled_locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#:~:text=get_unfilled_locations) to your list of items to submit
 
 Note: to use self.create_filler(), self.get_filler_item_name() should be defined to only return valid filler item names
 ```py
@@ -47,8 +39,7 @@ for _ in range(total_locations - len(item_pool)):
 self.multiworld.itempool += item_pool
 ```
 
-A faster alternative to the `for` loop would be to use a
-[list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):
+A faster alternative to the `for` loop would be to use a [list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):
 ```py
 item_pool += [self.create_filler() for _ in range(total_locations - len(item_pool))]
 ```
@@ -57,86 +48,21 @@ item_pool += [self.create_filler() for _ in range(total_locations - len(item_poo
 
 ### I learned about indirect conditions in the world API document, but I want to know more. What are they and why are they necessary?
 
-The world API document mentions how to use `multiworld.register_indirect_condition` to register indirect conditions and
-**when** you should use them, but not *how* they work and *why* they are necessary. This is because the explanation is
-quite complicated.
+The world API document mentions how to use `multiworld.register_indirect_condition` to register indirect conditions and **when** you should use them, but not *how* they work and *why* they are necessary. This is because the explanation is quite complicated.
 
-Region sweep (the algorithm that determines which regions are reachable) is a Breadth-First Search of the region graph.
-It starts from the origin region, checks entrances one by one, and adds newly reached regions and their entrances to
-the queue until there is nothing more to check.
+Region sweep (the algorithm that determines which regions are reachable) is a Breadth-First Search of the region graph. It starts from the origin region, checks entrances one by one, and adds newly reached regions and their entrances to the queue until there is nothing more to check.
 
-For performance reasons, AP only checks every entrance once. However, if an entrance's access_rule depends on region
-access, then the following may happen:
-1. The entrance is checked and determined to be nontraversable because the region in its access_rule hasn't been
-   reached yet during the graph search.
+For performance reasons, AP only checks every entrance once. However, if an entrance's access_rule depends on region access, then the following may happen:
+1. The entrance is checked and determined to be nontraversable because the region in its access_rule hasn't been reached yet during the graph search.
 2. Then, the region in its access_rule is determined to be reachable.
 
 This entrance *would* be in logic if it were rechecked, but it won't be rechecked this cycle.
-To account for this case, AP would have to recheck all entrances every time a new region is reached until no new
-regions are reached.
+To account for this case, AP would have to recheck all entrances every time a new region is reached until no new regions are reached.
 
-An indirect condition is how you can manually define that a specific entrance needs to be rechecked during region sweep
-if a specific region is reached during it.
-This keeps most of the performance upsides. Even in a game making heavy use of indirect conditions (ex: The Witness),
-using them is significantly faster than just "rechecking each entrance until nothing new is found".
-The reason entrance access rules using `location.can_reach` and `entrance.can_reach` are also affected is because they
-call `region.can_reach` on their respective parent/source region.
+An indirect condition is how you can manually define that a specific entrance needs to be rechecked during region sweep if a specific region is reached during it.
+This keeps most of the performance upsides. Even in a game making heavy use of indirect conditions (ex: The Witness), using them is significantly faster than just "rechecking each entrance until nothing new is found".
+The reason entrance access rules using `location.can_reach` and `entrance.can_reach` are also affected is because they call `region.can_reach` on their respective parent/source region.
 
-We recognize it can feel like a trap since it will not alert you when you are missing an indirect condition,
-and that some games have very complex access rules.
-As of [PR #3682 (Core: Region handling customization)](https://github.com/ArchipelagoMW/Archipelago/pull/3682)
-being merged, it is possible for a world to opt out of indirect conditions entirely, instead using the system of
-checking each entrance whenever a region has been reached, although this does come with a performance cost.
-Opting out of using indirect conditions should only be used by games that *really* need it. For most games, it should
-be reasonable to know all entrance &rarr; region dependencies, making indirect conditions preferred because they are
-much faster.
-
----
-
-### I uploaded the generated output of my world to the webhost and webhost is erroring on corrupted multidata
-
-The error `Could not load multidata. File may be corrupted or incompatible.` occurs when uploading a locally generated
-file where there is an issue with the multidata contained within it. It may come with a description like
-`(No module named 'worlds.myworld')` or `(global 'worlds.myworld.names.ItemNames' is forbidden)`
-
-Pickling is a way to compress python objects such that they can be decompressed and be used to rebuild the
-python objects. This means that if one of your custom class instances ends up in the multidata, the server would not
-be able to load that custom class to decompress the data, which can fail either because the custom class is unknown
-(because it cannot load your world module) or the class it's attempting to import to decompress is deemed unsafe.
-
-Common situations where this can happen include:
-* Using Option instances directly in slot_data. Ex: using `options.option_name` instead of `options.option_name.value`.
-  Also, consider using the `options.as_dict("option_name", "option_two")` helper.
-* Using enums as Location/Item names in the datapackage. When building out `location_name_to_id` and `item_name_to_id`,
-  make sure that you are not using your enum class for either the names or ids in these mappings.
-
----
-
-### Some locations are technically possible to check with few or no items, but they'd be very tedious or frustrating. How do worlds deal with this?
-
-Sometimes the game can be modded to skip these locations or make them less tedious. But when this issue is due to a fundamental aspect of the game, then the general answer is "soft logic" (and its subtypes like "combat logic", "money logic", etc.). For example: you can logically require that a player have several helpful items before fighting the final boss, even if a skilled player technically needs no items to beat it. Randomizer logic should describe what's *fun* rather than what's technically possible.
-
-Concrete examples of soft logic include:
-- Defeating a boss might logically require health upgrades, damage upgrades, certain weapons, etc. that aren't strictly necessary.
-- Entering a high-level area might logically require access to enough other parts of the game that checking other locations should naturally get the player to the soft-required level.
-- Buying expensive shop items might logically require access to a place where you can quickly farm money, or logically require access to enough parts of the game that checking other locations should naturally generate enough money without grinding.
-
-Remember that all items referenced by logic (however hard or soft) must be `progression`. Since you typically don't want to turn a ton of `filler` items into `progression` just for this, it's common to e.g. write money logic using only the rare "$100" item, so the dozens of "$1" and "$10" items in your world can remain `filler`.
-
----
-
-### What if my game has "missable" or "one-time-only" locations or region connections?
-
-Archipelago logic assumes that once a region or location becomes reachable, it stays reachable forever, no matter what 
-the player does in-game. Slightly more formally: Receiving an AP item must never cause a region connection or location 
-to "go out of logic" (become unreachable when it was previously reachable), and receiving AP items is the only kind of 
-state change that AP logic acknowledges. No other actions or events can change reachability.
-
-So when the game itself does not follow this assumption, the options are:
-- Modify the game to make that location/connection repeatable
-- If there are both missable and repeatable ways to check the location/traverse the connection, then write logic for 
-  only the repeatable ways
-- Don't generate the missable location/connection at all
-  - For connections, any logical regions will still need to be reachable through other, *repeatable* connections
-  - For locations, this may require game changes to remove the vanilla item if it affects logic
-- Decide that resetting the save file is part of the game's logic, and warn players about that
+We recognize it can feel like a trap since it will not alert you when you are missing an indirect condition, and that some games have very complex access rules.
+As of [PR #3682 (Core: Region handling customization)](https://github.com/ArchipelagoMW/Archipelago/pull/3682) being merged, it is possible for a world to opt out of indirect conditions entirely, instead using the system of checking each entrance whenever a region has been reached, although this does come with a performance cost.
+Opting out of using indirect conditions should only be used by games that *really* need it. For most games, it should be reasonable to know all entrance &rarr; region dependencies, making indirect conditions preferred because they are much faster.

docs/entrance randomization.md

@@ -370,13 +370,19 @@ target_group_lookup = bake_target_group_lookup(world, get_target_groups)
 
 #### When to call `randomize_entrances`
 
-The correct step for this is `World.connect_entrances`.
+The short answer is that you will almost always want to do ER in `pre_fill`. For more information why, continue reading.
 
-Currently, you could theoretically do it as early as `World.create_regions` or as late as `pre_fill`.
-However, there are upcoming changes to Item Plando and Generic Entrance Randomizer to make the two features work better
-together.
-These changes necessitate that entrance randomization is done exactly in `World.connect_entrances`.
-It is fine for your Entrances to be connected differently or not at all before this step.
+ER begins by collecting the entire item pool and then uses your access rules to try and prevent some kinds of failures. 
+This means 2 things about when you can call ER:
+1. You must supply your item pool before calling ER, or call ER before setting any rules which require items.
+2. If you have rules dependent on anything other than items (e.g. `Entrance`s or events), you must set your rules
+   and create your events before you call ER if you want to guarantee a correct output.
+
+If the conditions above are met, you could theoretically do ER as early as `create_regions`. However, plando is also 
+a consideration. Since item plando happens between `set_rules` and `pre_fill` and modifies the item pool, doing ER 
+in `pre_fill` is the only way to account for placements made by item plando, otherwise you risk impossible seeds or 
+generation failures. Obviously, if your world implements entrance plando, you will likely want to do that before ER as
+well.
 
 #### Informing your client about randomized entrances
 

docs/network diagram/network diagram.md

@@ -117,6 +117,8 @@ flowchart LR
     %% Java Based Games
     subgraph Java
         JM[Mod with Archipelago.MultiClient.Java]
+        STS[Slay the Spire]
+        JM <-- Mod the Spire --> STS
         subgraph Minecraft
             MCS[Minecraft Forge Server]
             JMC[Any Java Minecraft Clients]

docs/network protocol.md

@@ -47,9 +47,6 @@ Packets are simple JSON lists in which any number of ordered network commands ca
 
 An object can contain the "class" key, which will tell the content data type, such as "Version" in the following example.
 
-Websocket connections should support per-message compression. Uncompressed connections are deprecated and may stop
-working in the future.
-
 Example:
 ```javascript
 [{"cmd": "RoomInfo", "version": {"major": 0, "minor": 1, "build": 3, "class": "Version"}, "tags": ["WebHost"], ... }]
@@ -264,7 +261,6 @@ Sent to clients in response to a [Set](#Set) package if want_reply was set to tr
 | key            | str  | The key that was updated.                                                                  |
 | value          | any  | The new value for the key.                                                                 |
 | original_value | any  | The value the key had before it was updated. Not present on "_read" prefixed special keys. |
-| slot           | int  | The slot that originally sent the Set package causing this change.                         |
 
 Additional arguments added to the [Set](#Set) package that triggered this [SetReply](#SetReply) will also be passed along.
 
@@ -363,11 +359,11 @@ An enumeration containing the possible hint states.
 ```python
 import enum
 class HintStatus(enum.IntEnum):
-    HINT_UNSPECIFIED = 0  # The receiving player has not specified any status
+    HINT_FOUND = 0        # The location has been collected. Status cannot be changed once found.
+    HINT_UNSPECIFIED = 1  # The receiving player has not specified any status
     HINT_NO_PRIORITY = 10 # The receiving player has specified that the item is unneeded
     HINT_AVOID = 20       # The receiving player has specified that the item is detrimental
     HINT_PRIORITY = 30    # The receiving player has specified that the item is needed
-    HINT_FOUND = 40       # The location has been collected. Status cannot be changed once found.
 ```
 - Hints for items with `ItemClassification.trap` default to `HINT_AVOID`.
 - Hints created with `LocationScouts`, `!hint_location`, or similar (hinting a location) default to `HINT_UNSPECIFIED`.
@@ -470,7 +466,7 @@ The following operations can be applied to a datastorage key
 | right_shift | Applies a bitwise right-shift to the current value of the key by `value`. |
 | remove | List only: removes the first instance of `value` found in the list. |
 | pop | List or Dict: for lists it will remove the index of the `value` given. for dicts it removes the element with the specified key of `value`. |
-| update | List or Dict: Adds the elements of `value` to the container if they weren't already present. In the case of a Dict, already present keys will have their corresponding values updated. |
+| update | Dict only: Updates the dictionary with the specified elements given in `value` creating new keys, or updating old ones if they previously existed. |
 
 ### SetNotify
 Used to register your current session for receiving all [SetReply](#SetReply) packages of certain keys to allow your client to keep track of changes.
@@ -533,9 +529,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> + 1, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
+`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.
 
-`location` is the location id of the item inside the world. Location ids are only supported in the range of [-2<sup>53</sup> + 1, 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 only supported in the range of [-2<sup>53</sup>, 2<sup>53</sup> - 1], with anything ≤ 0 reserved for Archipelago use.
 
 `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
 
@@ -748,7 +744,6 @@ Tags are represented as a list of strings, the common client tags follow:
 | HintGame  | Indicates the client is a hint game, made to send hints instead of locations. Special join/leave message,¹ `game` is optional.²      |
 | Tracker   | Indicates the client is a tracker, made to track instead of sending locations. Special join/leave message,¹ `game` is optional.²     |
 | TextOnly  | Indicates the client is a basic client, made to chat instead of sending locations. Special join/leave message,¹ `game` is optional.² |
-| NoText    | Indicates the client does not want to receive text messages, improving performance if not needed.                                    |
 
 ¹: When connecting or disconnecting, the chat message shows e.g. "tracking".\
 ²: Allows `game` to be empty or null in [Connect](#connect). Game and version validation will then be skipped.
@@ -756,8 +751,8 @@ Tags are represented as a list of strings, the common client tags follow:
 ### DeathLink
 A special kind of Bounce packet that can be supported by any AP game. It targets the tag "DeathLink" and carries the following data:
 
-| Name   | Type  | Notes                                                                                                                                                                            |
-|--------|-------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| time   | float | Unix Time Stamp of time of death.                                                                                                                                                |
-| cause  | str   | Optional. Text to explain the cause of death. When provided, or checked, if the string is non-empty, it should contain the player name, ex. "Berserker was run over by a train." |
-| source | str   | Name of the player who first died. Can be a slot name, but can also be a name from within a multiplayer game.                                                                    |
+| Name   | Type  | Notes                                                                                                                                                  |
+|--------|-------|--------------------------------------------------------------------------------------------------------------------------------------------------------|
+| time   | float | Unix Time Stamp of time of death.                                                                                                                      |
+| cause  | str   | Optional. Text to explain the cause of death. When provided, or checked, this should contain the player name, ex. "Berserker was run over by a train." |
+| source | str   | Name of the player who first died. Can be a slot name, but can also be a name from within a multiplayer game.                                          |

docs/options api.md

@@ -95,7 +95,7 @@ user hovers over the yellow "(?)" icon, and included in the YAML templates gener
 The WebHost can display Option documentation either as plain text with all whitespace preserved (other than the base
 indentation), or as HTML generated from the standard Python [reStructuredText] format. Although plain text is the
 default for backwards compatibility, world authors are encouraged to write their Option documentation as
-reStructuredText and enable rich text rendering by setting `WebWorld.rich_text_options_doc = True`.
+reStructuredText and enable rich text rendering by setting `World.rich_text_options_doc = True`.
 
 [reStructuredText]: https://docutils.sourceforge.io/rst.html
 
@@ -352,15 +352,8 @@ template. If you set a [Schema](https://pypi.org/project/schema/) on the class w
 options system will automatically validate the user supplied data against the schema to ensure it's in the correct
 format.
 
-### OptionCounter
-This is a special case of OptionDict where the dictionary values can only be integers.  
-It returns a [collections.Counter](https://docs.python.org/3/library/collections.html#collections.Counter).
-This means that if you access a key that isn't present, its value will be 0.  
-The upside of using an OptionCounter (instead of an OptionDict with integer values) is that an OptionCounter can be
-displayed on the Options page on WebHost.
-
 ### ItemDict
-An OptionCounter that will verify that every key in the dictionary is a valid name for an item for your world.
+Like OptionDict, except this will verify that every key in the dictionary is a valid name for an item for your world.
 
 ### OptionList
 This option defines a List, where the user can add any number of strings to said list, allowing duplicate values. You

docs/tests.md

@@ -11,13 +11,8 @@ found in the [general test directory](/test/general).
 ## Defining World Tests
 
 In order to run tests from your world, you will need to create a `test` package within your world package. This can be
-done by creating a `test` directory inside your world with an (empty) `__init__.py` inside it. By convention, a base
-for your world tests can be created in `bases.py` or any file that does not start with `test`, that you can then import
-into other modules. All tests should be defined in files named `test_*.py` (all lower case) and be member functions
-(named `test_*`) of classes (named `Test*` or `*Test`) that inherit from `unittest.TestCase` or a test base.
-
-Defining anything inside `test/__init__.py` is deprecated. Defining TestBase there was previously the norm; however,
-it complicates test discovery because some worlds also put actual tests into `__init__.py`.
+done by creating a `test` directory with a file named `__init__.py` inside it inside your world. By convention, a base
+for your world tests can be created in this file that you can then import into other modules.
 
 ### WorldTestBase
 
@@ -26,7 +21,7 @@ interactions in the world interact as expected, you will want to use the [WorldT
 comes with the basics for test setup as well as a few preloaded tests that most worlds might want to check on varying
 options combinations.
 
-Example `/worlds/<my_game>/test/bases.py`:
+Example `/worlds/<my_game>/test/__init__.py`:
 
 ```python
 from test.bases import WorldTestBase
@@ -54,7 +49,7 @@ with `test_`.
 Example `/worlds/<my_game>/test/test_chest_access.py`:
 
 ```python
-from .bases import MyGameTestBase
+from . import MyGameTestBase
 
 
 class TestChestAccess(MyGameTestBase):
@@ -78,58 +73,22 @@ When tests are run, this class will create a multiworld with a single player hav
 generic tests, as well as the new custom test. Each test method definition will create its own separate solo multiworld
 that will be cleaned up after. If you don't want to run the generic tests on a base, `run_default_tests` can be
 overridden. For more information on what methods are available to your class, check the
-[WorldTestBase definition](/test/bases.py#L106).
+[WorldTestBase definition](/test/bases.py#L104).
 
 #### Alternatives to WorldTestBase
 
-Unit tests can also be created using [TestBase](/test/bases.py#L16) or
+Unit tests can also be created using [TestBase](/test/bases.py#L14) or
 [unittest.TestCase](https://docs.python.org/3/library/unittest.html#unittest.TestCase) depending on your use case. These
 may be useful for generating a multiworld under very specific constraints without using the generic world setup, or for
 testing portions of your code that can be tested without relying on a multiworld to be created first.
 
-#### Parametrization
-
-When defining a test that needs to cover a range of inputs it is useful to parameterize (to run the same test
-for multiple inputs) the base test. Some important things to consider when attempting to parametrize your test are:
-
-* [Subtests](https://docs.python.org/3/library/unittest.html#distinguishing-test-iterations-using-subtests)
-  can be used to have parametrized assertions that show up similar to individual tests but without the overhead
-  of needing to instantiate multiple tests; however, subtests can not be multithreaded and do not have individual
-  timing data, so they are not suitable for slow tests.
-
-* Archipelago's tests are test-runner-agnostic. That means tests are not allowed to use e.g. `@pytest.mark.parametrize`.
-  Instead, we define our own parametrization helpers in [test.param](/test/param.py).
-
-* Classes inheriting from `WorldTestBase`, including those created by the helpers in `test.param`, will run all
-  base tests by default, make sure the produced tests actually do what you aim for and do not waste a lot of
-  extra CPU time. Consider using `TestBase` or `unittest.TestCase` directly
-  or setting `WorldTestBase.run_default_tests` to False.
-
-#### Performance Considerations
-
-Archipelago is big enough that the runtime of unittests can have an impact on productivity.
-
-Individual tests should take less than a second, so they can be properly multithreaded.
-
-Ideally, thorough tests are directed at actual code/functionality. Do not just create and/or fill a ton of individual
-Multiworlds that spend most of the test time outside what you actually want to test.
-
-Consider generating/validating "random" games as part of your APWorld release workflow rather than having that be part
-of continuous integration, and add minimal reproducers to the "normal" tests for problems that were found.
-You can use [@unittest.skipIf](https://docs.python.org/3/library/unittest.html#unittest.skipIf) with an environment
-variable to keep all the benefits of the test framework while not running the marked tests by default.
-
 ## Running Tests
 
 #### Using Pycharm
 
 In PyCharm, running all tests can be done by right-clicking the root test directory and selecting Run 'Archipelago Unittests'. 
-If you have never previously run ModuleUpdate.py, then you will need to do this once before the tests will run. 
-You can run ModuleUpdate.py by right-clicking ModuleUpdate.py and selecting `Run 'ModuleUpdate'`. 
-After running ModuleUpdate.py you may still get a `ModuleNotFoundError: No module named 'flask'` for the webhost tests. 
-If this happens, run WebHost.py by right-clicking it and selecting `Run 'WebHost'`. Make sure to press enter when prompted. 
-Unless you configured PyCharm to use pytest as a test runner, you may get import failures. To solve this, 
-edit the run configuration, and set the working directory to the Archipelago directory which contains all the project files. 
+Unless you configured PyCharm to use pytest as a test runner, you may get import failures. To solve this, edit the run configuration, 
+and set the working directory to the Archipelago directory which contains all the project files. 
 
 If you only want to run your world's defined tests, repeat the steps for the test directory within your world.
 Your working directory should be the directory of your world in the worlds directory and the script should be the 
@@ -141,11 +100,3 @@ next to the run and debug buttons.
 #### Running Tests without Pycharm
 
 Run `pip install pytest pytest-subtests`, then use your IDE to run tests or run `pytest` from the source folder.
-
-#### Running Tests Multithreaded
-
-pytest can run multiple test runners in parallel with the pytest-xdist extension.
-
-Install with `pip install pytest-xdist`.
-
-Run with `pytest -n12` to spawn 12 process that each run 1/12th of the tests.

docs/world api.md

@@ -222,8 +222,8 @@ could also be progress in a research tree, or even something more abstract like
 
 Each location has a `name` and an `address` (hereafter referred to as an `id`), is placed in a Region, has access rules,
 and has a classification. The name needs to be unique within each game and must not be numeric (must contain least 1
-letter or symbol). The ID needs to be unique across all locations within the game. 
-Locations and items can share IDs, and locations can share IDs with other games' locations.
+letter or symbol). The ID needs to be unique across all games, and is best kept in the same range as the item IDs.
+Locations and items can share IDs, so typically a game's locations and items start at the same ID.
 
 World-specific IDs must be in the range 1 to 2<sup>53</sup>-1; IDs ≤ 0 are global and reserved.
 
@@ -243,9 +243,7 @@ progression. Progression items will be assigned to locations with higher priorit
 and satisfy progression balancing.
 
 The name needs to be unique within each game, meaning if you need to create multiple items with the same name, they
-will all have the same ID. Name must not be numeric (must contain at least 1 letter or symbol). 
-The ID thus also needs to be unique across all items with different names within the game. 
-Items and locations can share IDs, and items can share IDs with other games' items.
+will all have the same ID. Name must not be numeric (must contain at least 1 letter or symbol).
 
 Other classifications include:
 
@@ -291,7 +289,7 @@ like entrance randomization in logic.
 
 Regions have a list called `exits`, containing `Entrance` objects representing transitions to other regions.
 
-There must be one special region (Called "Menu" by default, but configurable using [origin_region_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L298-L299)),
+There must be one special region (Called "Menu" by default, but configurable using [origin_region_name](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L295-L296)),
 from which the logic unfolds. AP assumes that a player will always be able to return to this starting region by resetting the game ("Save and quit").
 
 ### Entrances
@@ -331,7 +329,7 @@ Even doing `state.can_reach_location` or `state.can_reach_entrance` is problemat
 You can use `multiworld.register_indirect_condition(region, entrance)` to explicitly tell the generator that, when a given region becomes accessible, it is necessary to re-check a specific entrance.
 You **must** use `multiworld.register_indirect_condition` if you perform this kind of `can_reach` from an entrance access rule, unless you have a **very** good technical understanding of the relevant code and can reason why it will never lead to problems in your case.
 
-Alternatively, you can set [world.explicit_indirect_conditions = False](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L301-L304),
+Alternatively, you can set [world.explicit_indirect_conditions = False](https://github.com/ArchipelagoMW/Archipelago/blob/main/worlds/AutoWorld.py#L298-L301),
 avoiding the need for indirect conditions at the expense of performance.
 
 ### Item Rules
@@ -492,9 +490,6 @@ In addition, the following methods can be implemented and are called in this ord
   after this step. Locations cannot be moved to different regions after this step.
 * `set_rules(self)`
   called to set access and item rules on locations and entrances.
-* `connect_entrances(self)`
-  by the end of this step, all entrances must exist and be connected to their source and target regions.
-  Entrance randomization should be done here.
 * `generate_basic(self)`
   player-specific randomization that does not affect logic can be done here.
 * `pre_fill(self)`, `fill_hook(self)` and `post_fill(self)`
@@ -561,14 +556,18 @@ from .items import is_progression  # this is just a dummy
 
 
 def create_item(self, item: str) -> MyGameItem:
-    # this is called when AP wants to create an item by name (for plando, start inventory, item links) or when you call it from your own code
-    classification = ItemClassification.progression if is_progression(item) else ItemClassification.filler
-    return MyGameItem(item, classification, self.item_name_to_id[item], self.player)
+    # this is called when AP wants to create an item by name (for plando) or when you call it from your own code
+    classification = ItemClassification.progression if is_progression(item) else
+    ItemClassification.filler
+
+
+return MyGameItem(item, classification, self.item_name_to_id[item],
+                  self.player)
 
 
 def create_event(self, event: str) -> MyGameItem:
     # while we are at it, we can also add a helper to create events
-    return MyGameItem(event, ItemClassification.progression, None, self.player)
+    return MyGameItem(event, True, None, self.player)
 ```
 
 #### create_items
@@ -606,8 +605,8 @@ from .items import get_item_type
 
 def set_rules(self) -> None:
     # For some worlds this step can be omitted if either a Logic mixin 
-    # (see below) is used or it's easier to apply the rules from data during
-    # location generation
+    # (see below) is used, it's easier to apply the rules from data during
+    # location generation or everything is in generate_basic
 
     # set a simple rule for an region
     set_rule(self.multiworld.get_entrance("Boss Door", self.player),
@@ -836,16 +835,14 @@ def generate_output(self, output_directory: str) -> None:
 
 ### Slot Data
 
-If a client or tracker needs to know information about the generated seed, a preferred method of transferring the data 
-is through the slot data. This is filled with the `fill_slot_data` method of your world by returning a `dict` with 
-`str` keys that can be serialized with json. However, to not waste resources, it should be limited to data that is 
-absolutely necessary. Slot data is sent to your client once it has successfully 
-[connected](network%20protocol.md#connected).
-
+If the game client needs to know information about the generated seed, a preferred method of transferring the data
+is through the slot data. This is filled with the `fill_slot_data` method of your world by returning
+a `dict` with `str` keys that can be serialized with json.
+But, to not waste resources, it should be limited to data that is absolutely necessary. Slot data is sent to your client
+once it has successfully [connected](network%20protocol.md#connected).
 If you need to know information about locations in your world, instead of propagating the slot data, it is preferable
-to use [LocationScouts](network%20protocol.md#locationscouts), since that data already exists on the server. Adding 
-item/location pairs is unnecessary since the AP server already retains and freely gives that information to clients 
-that request it. The most common usage of slot data is sending option results that the client needs to be aware of.
+to use [LocationScouts](network%20protocol.md#locationscouts), since that data already exists on the server. The most
+common usage of slot data is sending option results that the client needs to be aware of.
 
 ```python
 def fill_slot_data(self) -> Dict[str, Any]:

entrance_rando.py

@@ -50,15 +50,13 @@ class EntranceLookup:
     _random: random.Random
     _expands_graph_cache: dict[Entrance, bool]
     _coupled: bool
-    _usable_exits: set[Entrance]
 
-    def __init__(self, rng: random.Random, coupled: bool, usable_exits: set[Entrance]):
+    def __init__(self, rng: random.Random, coupled: bool):
         self.dead_ends = EntranceLookup.GroupLookup()
         self.others = EntranceLookup.GroupLookup()
         self._random = rng
         self._expands_graph_cache = {}
         self._coupled = coupled
-        self._usable_exits = usable_exits
 
     def _can_expand_graph(self, entrance: Entrance) -> bool:
         """
@@ -97,8 +95,7 @@ class EntranceLookup:
                 # randomizable exits which are not reverse of the incoming entrance.
                 # uncoupled mode is an exception because in this case going back in the door you just came in could
                 # actually lead somewhere new
-                if (not exit_.connected_region and (not self._coupled or exit_.name != entrance.name)
-                        and exit_ in self._usable_exits):
+                if not exit_.connected_region and (not self._coupled or exit_.name != entrance.name):
                     self._expands_graph_cache[entrance] = True
                     return True
                 elif exit_.connected_region and exit_.connected_region not in visited:
@@ -160,16 +157,17 @@ class ERPlacementState:
     def placed_regions(self) -> set[Region]:
         return self.collection_state.reachable_regions[self.world.player]
 
-    def find_placeable_exits(self, check_validity: bool, usable_exits: list[Entrance]) -> list[Entrance]:
+    def find_placeable_exits(self, check_validity: bool) -> list[Entrance]:
         if check_validity:
             blocked_connections = self.collection_state.blocked_connections[self.world.player]
-            placeable_randomized_exits = [ex for ex in usable_exits
-                                          if not ex.connected_region
-                                          and ex in blocked_connections
-                                          and ex.is_valid_source_transition(self)]
+            blocked_connections = sorted(blocked_connections, key=lambda x: x.name)
+            placeable_randomized_exits = [connection for connection in blocked_connections
+                                          if not connection.connected_region
+                                          and connection.is_valid_source_transition(self)]
         else:
             # this is on a beaten minimal attempt, so any exit anywhere is fair game
-            placeable_randomized_exits = [ex for ex in usable_exits if not ex.connected_region]
+            placeable_randomized_exits = [ex for region in self.world.multiworld.get_regions(self.world.player)
+                                          for ex in region.exits if not ex.connected_region]
         self.world.random.shuffle(placeable_randomized_exits)
         return placeable_randomized_exits
 
@@ -183,8 +181,7 @@ class ERPlacementState:
         self.placements.append(source_exit)
         self.pairings.append((source_exit.name, target_entrance.name))
 
-    def test_speculative_connection(self, source_exit: Entrance, target_entrance: Entrance,
-                                    usable_exits: set[Entrance]) -> bool:
+    def test_speculative_connection(self, source_exit: Entrance, target_entrance: Entrance) -> bool:
         copied_state = self.collection_state.copy()
         # simulated connection. A real connection is unsafe because the region graph is shallow-copied and would
         # propagate back to the real multiworld.
@@ -201,9 +198,6 @@ class ERPlacementState:
             # ignore the source exit, and, if coupled, the reverse exit. They're not actually new
             if _exit.name == source_exit.name or (self.coupled and _exit.name == target_entrance.name):
                 continue
-            # make sure we are only paying attention to usable exits
-            if _exit not in usable_exits:
-                continue
             # technically this should be is_valid_source_transition, but that may rely on side effects from
             # on_connect, which have not happened here (because we didn't do a real connection, and if we did, we would
             # not want them to persist). can_reach is a close enough approximation most of the time.
@@ -268,19 +262,14 @@ def bake_target_group_lookup(world: World, get_target_groups: Callable[[int], li
     return { group: get_target_groups(group) for group in unique_groups }
 
 
-def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int | None = None,
-                                          one_way_target_name: str | None = None) -> None:
+def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int | None = None) -> None:
     """
     Given an entrance in a "vanilla" region graph, splits that entrance to prepare it for randomization
-    in randomize_entrances. This should be done after setting the type and group of the entrance. Because it attempts
-    to meet strict entrance naming requirements for coupled mode, this function may produce unintuitive results when
-    called only on a single entrance; it produces eventually-correct outputs only after calling it on all entrances.
+    in randomize_entrances. This should be done after setting the type and group of the entrance.
 
     :param entrance: The entrance which will be disconnected in preparation for randomization.
     :param target_group: The group to assign to the created ER target. If not specified, the group from
                          the original entrance will be copied.
-    :param one_way_target_name: The name of the created ER target if `entrance` is one-way. This argument
-                                is required for one-way entrances and is ignored otherwise.
     """
     child_region = entrance.connected_region
     parent_region = entrance.parent_region
@@ -295,11 +284,8 @@ def disconnect_entrance_for_randomization(entrance: Entrance, target_group: int
         # targets in the child region will be created when the other direction edge is disconnected
         target = parent_region.create_er_target(entrance.name)
     else:
-        # for 1-ways, the child region needs a target. naming is not a concern for coupling so we
-        # allow it to be user provided (and require it, to prevent an unhelpful assumed name in pairings)
-        if not one_way_target_name:
-            raise ValueError("Cannot disconnect a one-way entrance without a target name specified")
-        target = child_region.create_er_target(one_way_target_name)
+        # for 1-ways, the child region needs a target and coupling/naming is not a concern
+        target = child_region.create_er_target(child_region.name)
     target.randomization_type = entrance.randomization_type
     target.randomization_group = target_group or entrance.randomization_group
 
@@ -336,28 +322,10 @@ def randomize_entrances(
 
     start_time = time.perf_counter()
     er_state = ERPlacementState(world, coupled)
+    entrance_lookup = EntranceLookup(world.random, coupled)
     # similar to fill, skip validity checks on entrances if the game is beatable on minimal accessibility
     perform_validity_check = True
 
-    if not er_targets:
-        er_targets = sorted([entrance for region in world.multiworld.get_regions(world.player)
-                             for entrance in region.entrances if not entrance.parent_region], key=lambda x: x.name)
-    if not exits:
-        exits = sorted([ex for region in world.multiworld.get_regions(world.player)
-                        for ex in region.exits if not ex.connected_region], key=lambda x: x.name)
-    if len(er_targets) != len(exits):
-        raise EntranceRandomizationError(f"Unable to randomize entrances due to a mismatched count of "
-                                         f"entrances ({len(er_targets)}) and exits ({len(exits)}.")
-
-    # used when membership checks are needed on the exit list, e.g. speculative sweep
-    exits_set = set(exits)
-    entrance_lookup = EntranceLookup(world.random, coupled, exits_set)
-    for entrance in er_targets:
-        entrance_lookup.add(entrance)
-
-    # place the menu region and connected start region(s)
-    er_state.collection_state.update_reachable_regions(world.player)
-
     def do_placement(source_exit: Entrance, target_entrance: Entrance) -> None:
         placed_exits, removed_entrances = er_state.connect(source_exit, target_entrance)
         # remove the placed targets from consideration
@@ -369,37 +337,9 @@ def randomize_entrances(
         if on_connect:
             on_connect(er_state, placed_exits)
 
-    def needs_speculative_sweep(dead_end: bool, require_new_exits: bool, placeable_exits: list[Entrance]) -> bool:
-        # speculative sweep is expensive. We currently only do it as a last resort, if we might cap off the graph
-        # entirely
-        if len(placeable_exits) > 1:
-            return False
-
-        # in certain stages of randomization we either expect or don't care if the search space shrinks.
-        # we should never speculative sweep here.
-        if dead_end or not require_new_exits or not perform_validity_check:
-            return False
-
-        # edge case - if all dead ends have pre-placed progression or indirect connections, they are pulled forward
-        # into the non dead end stage. In this case, and only this case, it's possible that the last connection may
-        # actually be placeable in stage 1. We need to skip speculative sweep in this case because we expect the graph
-        # to get capped off.
-
-        # check to see if we are proposing the last placement
-        if not coupled:
-            # in uncoupled, this check is easy as there will only be one target.
-            is_last_placement = len(entrance_lookup) == 1
-        else:
-            # a bit harder, there may be 1 or 2 targets depending on if the exit to place is one way or two way.
-            # if it is two way, we can safely assume that one of the targets is the logical pair of the exit.
-            desired_target_count = 2 if placeable_exits[0].randomization_type == EntranceType.TWO_WAY else 1
-            is_last_placement = len(entrance_lookup) == desired_target_count
-        # if it's not the last placement, we need a sweep
-        return not is_last_placement
-
     def find_pairing(dead_end: bool, require_new_exits: bool) -> bool:
         nonlocal perform_validity_check
-        placeable_exits = er_state.find_placeable_exits(perform_validity_check, exits)
+        placeable_exits = er_state.find_placeable_exits(perform_validity_check)
         for source_exit in placeable_exits:
             target_groups = target_group_lookup[source_exit.randomization_group]
             for target_entrance in entrance_lookup.get_targets(target_groups, dead_end, preserve_group_order):
@@ -410,10 +350,12 @@ def randomize_entrances(
                 # very last exit and check whatever exits we open up are functionally accessible.
                 # this requirement can be ignored on a beaten minimal, islands are no issue there.
                 exit_requirement_satisfied = (not perform_validity_check or not require_new_exits
-                                              or target_entrance.connected_region not in er_state.placed_regions)
+                                                or target_entrance.connected_region not in er_state.placed_regions)
+                needs_speculative_sweep = (not dead_end and require_new_exits and perform_validity_check
+                                           and len(placeable_exits) == 1)
                 if exit_requirement_satisfied and source_exit.can_connect_to(target_entrance, dead_end, er_state):
-                    if (needs_speculative_sweep(dead_end, require_new_exits, placeable_exits)
-                            and not er_state.test_speculative_connection(source_exit, target_entrance, exits_set)):
+                    if (needs_speculative_sweep
+                            and not er_state.test_speculative_connection(source_exit, target_entrance)):
                         continue
                     do_placement(source_exit, target_entrance)
                     return True
@@ -436,14 +378,13 @@ def randomize_entrances(
                     and world.multiworld.has_beaten_game(er_state.collection_state, world.player):
                 # ensure that we have enough locations to place our progression
                 accessible_location_count = 0
-                prog_item_count = len([item for item in world.multiworld.itempool if item.advancement and item.player == world.player])
+                prog_item_count = sum(er_state.collection_state.prog_items[world.player].values())
                 # short-circuit location checking in this case
                 if prog_item_count == 0:
                     return True
                 for region in er_state.placed_regions:
                     for loc in region.locations:
-                        if not loc.item and loc.can_reach(er_state.collection_state):
-                            # don't count locations with preplaced items
+                        if loc.can_reach(er_state.collection_state):
                             accessible_location_count += 1
                             if accessible_location_count >= prog_item_count:
                                 perform_validity_check = False
@@ -465,6 +406,21 @@ def randomize_entrances(
                 f"All unplaced entrances: {unplaced_entrances}\n"
                 f"All unplaced exits: {unplaced_exits}")
 
+    if not er_targets:
+        er_targets = sorted([entrance for region in world.multiworld.get_regions(world.player)
+                             for entrance in region.entrances if not entrance.parent_region], key=lambda x: x.name)
+    if not exits:
+        exits = sorted([ex for region in world.multiworld.get_regions(world.player)
+                        for ex in region.exits if not ex.connected_region], key=lambda x: x.name)
+    if len(er_targets) != len(exits):
+        raise EntranceRandomizationError(f"Unable to randomize entrances due to a mismatched count of "
+                                         f"entrances ({len(er_targets)}) and exits ({len(exits)}.")
+    for entrance in er_targets:
+        entrance_lookup.add(entrance)
+
+    # place the menu region and connected start region(s)
+    er_state.collection_state.update_reachable_regions(world.player)
+
     # stage 1 - try to place all the non-dead-end entrances
     while entrance_lookup.others:
         if not find_pairing(dead_end=False, require_new_exits=True):

inno_setup.iss

@@ -45,8 +45,7 @@ MinVersion={#min_windows}
 Name: "english"; MessagesFile: "compiler:Default.isl"
 
 [Tasks]
-Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}";
-Name: "deletelib"; Description: "Clean existing /lib folder and subfolders including /worlds (leave checked if unsure)"; Check: ShouldShowDeleteLibTask
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}";
 
 [Types]
 Name: "full"; Description: "Full installation"
@@ -84,8 +83,18 @@ Filename: "{app}\ArchipelagoLauncher"; Description: "{cm:LaunchProgram,{#StringC
 Type: dirifempty; Name: "{app}"
 
 [InstallDelete]
-Type: files; Name: "{app}\*.exe"
+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: files; Name: "{app}\lib\worlds\sc2wol.apworld"
+Type: filesandordirs; Name: "{app}\lib\worlds\sc2wol"
+Type: dirifempty; Name: "{app}\lib\worlds\sc2wol"
+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}\SNI\lua*"
 Type: filesandordirs; Name: "{app}\EnemizerCLI*"
 #include "installdelete.iss"
@@ -212,11 +221,6 @@ Root: HKCR; Subkey: "{#MyAppName}ygo06patch";                     ValueData: "Ar
 Root: HKCR; Subkey: "{#MyAppName}ygo06patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                           ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ygo06patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                  ValueType: string;  ValueName: "";
 
-Root: HKCR; Subkey: ".apcivvi";                                   ValueData: "{#MyAppName}apcivvipatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}apcivvipatch";                     ValueData: "Archipelago Civilization 6 Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLauncher.exe,0";                           ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}apcivvipatch\shell\open\command";  ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";                  ValueType: string;  ValueName: "";
-
 Root: HKCR; Subkey: ".archipelago";                              ValueData: "{#MyAppName}multidata";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata";                     ValueData: "Archipelago Server Data";      Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}multidata\DefaultIcon";         ValueData: "{app}\ArchipelagoServer.exe,0";                         ValueType: string;  ValueName: "";
@@ -252,17 +256,3 @@ begin
     Result := True;
   end;
 end;
-
-function ShouldShowDeleteLibTask: Boolean;
-begin
-  Result := DirExists(ExpandConstant('{app}\lib'));
-end;
-
-procedure CurStepChanged(CurStep: TSetupStep);
-begin
-  if CurStep = ssInstall then
-  begin
-    if WizardIsTaskSelected('deletelib') then
-      DelTree(ExpandConstant('{app}\lib'), True, True, True);
-  end;
-end;

kvui.py

@@ -26,16 +26,13 @@ import Utils
 if Utils.is_frozen():
     os.environ["KIVY_DATA_DIR"] = Utils.local_path("data")
 
-import platformdirs
-os.environ["KIVY_HOME"] = os.path.join(platformdirs.user_config_dir("Archipelago", False), "kivy")
-os.makedirs(os.environ["KIVY_HOME"], exist_ok=True)
-
 from kivy.config import Config
 
 Config.set("input", "mouse", "mouse,disable_multitouch")
 Config.set("kivy", "exit_on_escape", "0")
 Config.set("graphics", "multisamples", "0")  # multisamples crash old intel drivers
-from kivymd.uix.divider import MDDivider
+
+from kivy.app import App
 from kivy.core.window import Window
 from kivy.core.clipboard import Clipboard
 from kivy.core.text.markup import MarkupLabel
@@ -43,34 +40,31 @@ from kivy.core.image import ImageLoader, ImageLoaderBase, ImageData
 from kivy.base import ExceptionHandler, ExceptionManager
 from kivy.clock import Clock
 from kivy.factory import Factory
-from kivy.properties import BooleanProperty, ObjectProperty, NumericProperty, StringProperty
-from kivy.metrics import dp, sp
+from kivy.properties import BooleanProperty, ObjectProperty
+from kivy.metrics import dp
+from kivy.effects.scroll import ScrollEffect
 from kivy.uix.widget import Widget
+from kivy.uix.button import Button
+from kivy.uix.gridlayout import GridLayout
 from kivy.uix.layout import Layout
+from kivy.uix.textinput import TextInput
+from kivy.uix.scrollview import ScrollView
+from kivy.uix.recycleview import RecycleView
+from kivy.uix.tabbedpanel import TabbedPanel, TabbedPanelItem
+from kivy.uix.boxlayout import BoxLayout
+from kivy.uix.floatlayout import FloatLayout
+from kivy.uix.label import Label
+from kivy.uix.progressbar import ProgressBar
+from kivy.uix.dropdown import DropDown
 from kivy.utils import escape_markup
 from kivy.lang import Builder
 from kivy.uix.recycleview.views import RecycleDataViewBehavior
-from kivy.uix.behaviors import FocusBehavior, ToggleButtonBehavior
+from kivy.uix.behaviors import FocusBehavior
 from kivy.uix.recycleboxlayout import RecycleBoxLayout
 from kivy.uix.recycleview.layout import LayoutSelectionBehavior
 from kivy.animation import Animation
 from kivy.uix.popup import Popup
 from kivy.uix.image import AsyncImage
-from kivymd.app import MDApp
-from kivymd.uix.gridlayout import MDGridLayout
-from kivymd.uix.floatlayout import MDFloatLayout
-from kivymd.uix.boxlayout import MDBoxLayout
-from kivymd.uix.tab.tab import MDTabsSecondary, MDTabsItem, MDTabsItemText, MDTabsCarousel
-from kivymd.uix.menu import MDDropdownMenu
-from kivymd.uix.menu.menu import MDDropdownTextItem
-from kivymd.uix.dropdownitem import MDDropDownItem, MDDropDownItemText
-from kivymd.uix.button import MDButton, MDButtonText, MDButtonIcon, MDIconButton
-from kivymd.uix.label import MDLabel, MDIcon
-from kivymd.uix.recycleview import MDRecycleView
-from kivymd.uix.textfield.textfield import MDTextField
-from kivymd.uix.progressindicator import MDLinearProgressIndicator
-from kivymd.uix.scrollview import MDScrollView
-from kivymd.uix.tooltip import MDTooltip, MDTooltipPlain
 
 fade_in_animation = Animation(opacity=0, duration=0) + Animation(opacity=1, duration=0.25)
 
@@ -87,113 +81,6 @@ else:
 remove_between_brackets = re.compile(r"\[.*?]")
 
 
-class ThemedApp(MDApp):
-    def set_colors(self):
-        text_colors = KivyJSONtoTextParser.TextColors()
-        self.theme_cls.theme_style = text_colors.theme_style
-        self.theme_cls.primary_palette = text_colors.primary_palette
-        self.theme_cls.dynamic_scheme_name = text_colors.dynamic_scheme_name
-        self.theme_cls.dynamic_scheme_contrast = text_colors.dynamic_scheme_contrast
-
-
-class ImageIcon(MDButtonIcon, AsyncImage):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.image = ApAsyncImage(**kwargs)
-        self.add_widget(self.image)
-
-    def add_widget(self, widget, index=0, canvas=None):
-        return super(MDIcon, self).add_widget(widget)
-
-
-class ImageButton(MDIconButton):
-    def __init__(self, **kwargs):
-        image_args = dict()
-        for kwarg in ("fit_mode", "image_size", "color", "source", "texture"):
-            val = kwargs.pop(kwarg, "None")
-            if val != "None":
-                image_args[kwarg.replace("image_", "")] = val
-        super().__init__()
-        self.image = ApAsyncImage(**image_args)
-
-        def set_center(button, center):
-            self.image.center_x = self.center_x
-            self.image.center_y = self.center_y
-
-        self.bind(center=set_center)
-        self.add_widget(self.image)
-
-    def add_widget(self, widget, index=0, canvas=None):
-        return super(MDIcon, self).add_widget(widget)
-
-
-class ScrollBox(MDScrollView):
-    layout: MDBoxLayout = ObjectProperty(None)
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-
-# thanks kivymd
-class ToggleButton(MDButton, ToggleButtonBehavior):
-    def __init__(self, *args, **kwargs):
-        super(ToggleButton, self).__init__(*args, **kwargs)
-        self.bind(state=self._update_bg)
-
-    def _update_bg(self, _, state: str):
-        if self.disabled:
-            return
-        if self.theme_bg_color == "Primary":
-            self.theme_bg_color = "Custom"
-
-        if state == "down":
-            self.md_bg_color = self.theme_cls.primaryColor
-            for child in self.children:
-                if child.theme_text_color == "Primary":
-                    child.theme_text_color = "Custom"
-                if child.theme_icon_color == "Primary":
-                    child.theme_icon_color = "Custom"
-                child.text_color = self.theme_cls.onPrimaryColor
-                child.icon_color = self.theme_cls.onPrimaryColor
-        else:
-            self.md_bg_color = self.theme_cls.surfaceContainerLowestColor
-            for child in self.children:
-                if child.theme_text_color == "Primary":
-                    child.theme_text_color = "Custom"
-                if child.theme_icon_color == "Primary":
-                    child.theme_icon_color = "Custom"
-                child.text_color = self.theme_cls.primaryColor
-                child.icon_color = self.theme_cls.primaryColor
-
-
-# thanks kivymd
-class ResizableTextField(MDTextField):
-    """
-    Resizable MDTextField that manually overrides the builtin sizing.
-
-    Note that in order to use this, the sizing must be specified from within a .kv rule.
-    """
-    def __init__(self, *args, **kwargs):
-        # cursed rules override
-        rules = Builder.match(self)
-        textfield = next((rule for rule in rules if rule.name == f"<MDTextField>"), None)
-        if textfield:
-            subclasses = rules[rules.index(textfield) + 1:]
-            for subclass in subclasses:
-                height_rule = subclass.properties.get("height", None)
-                if height_rule:
-                    height_rule.ignore_prev = True
-        super().__init__(*args, **kwargs)
-
-
-def on_release(self: MDButton, *args):
-    super(MDButton, self).on_release(args)
-    self.on_leave()
-
-
-MDButton.on_release = on_release
-
-
 # I was surprised to find this didn't already exist in kivy :(
 class HoverBehavior(object):
     """originally from https://stackoverflow.com/a/605348110"""
@@ -233,7 +120,7 @@ class HoverBehavior(object):
 Factory.register("HoverBehavior", HoverBehavior)
 
 
-class ToolTip(MDTooltipPlain):
+class ToolTip(Label):
     pass
 
 
@@ -241,30 +128,49 @@ class ServerToolTip(ToolTip):
     pass
 
 
-class HovererableLabel(HoverBehavior, MDLabel):
+class ScrollBox(ScrollView):
+    layout: BoxLayout
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.layout = BoxLayout(size_hint_y=None)
+        self.layout.bind(minimum_height=self.layout.setter("height"))
+        self.add_widget(self.layout)
+        self.effect_cls = ScrollEffect
+        self.bar_width = dp(12)
+        self.scroll_type = ["content", "bars"]
+
+
+class HovererableLabel(HoverBehavior, Label):
     pass
 
 
-class TooltipLabel(HovererableLabel, MDTooltip):
-    tooltip_display_delay = 0.1
+class TooltipLabel(HovererableLabel):
+    tooltip = None
 
     def create_tooltip(self, text, x, y):
         text = text.replace("<br>", "\n").replace("&amp;", "&").replace("&bl;", "[").replace("&br;", "]")
-        # position float layout
-        center_x, center_y = self.to_window(self.center_x, self.center_y)
-        self.shift_y = y - center_y
-        shift_x = center_x - x
-        if shift_x > 0:
-            self.shift_left = shift_x
-        else:
-            self.shift_right = shift_x
-
-        if self._tooltip:
+        if self.tooltip:
             # update
-            self._tooltip.text = text
+            self.tooltip.children[0].text = text
         else:
-            self._tooltip = ToolTip(text=text, pos_hint={})
-            self.display_tooltip()
+            self.tooltip = FloatLayout()
+            tooltip_label = ToolTip(text=text)
+            self.tooltip.add_widget(tooltip_label)
+            fade_in_animation.start(self.tooltip)
+            App.get_running_app().root.add_widget(self.tooltip)
+
+        # handle left-side boundary to not render off-screen
+        x = max(x, 3 + self.tooltip.children[0].texture_size[0] / 2)
+
+        # position float layout
+        self.tooltip.x = x - self.tooltip.width / 2
+        self.tooltip.y = y - self.tooltip.height / 2 + 48
+
+    def remove_tooltip(self):
+        if self.tooltip:
+            App.get_running_app().root.remove_widget(self.tooltip)
+            self.tooltip = None
 
     def on_mouse_pos(self, window, pos):
         if not self.get_root_window():
@@ -291,30 +197,26 @@ class TooltipLabel(HovererableLabel, MDTooltip):
 
     def on_leave(self):
         self.remove_tooltip()
-        self._tooltip = None
 
 
-class ServerLabel(HoverBehavior, MDTooltip, MDBoxLayout):
-    tooltip_display_delay = 0.1
-    text: str = StringProperty("Server:")
-
+class ServerLabel(HovererableLabel):
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.add_widget(MDIcon(icon="information", font_size=sp(15)))
-        self.add_widget(TooltipLabel(text=self.text, pos_hint={"center_x": 0.5, "center_y": 0.5},
-                                     font_size=sp(15)))
-        self._tooltip = ServerToolTip(text="Test")
+        super(HovererableLabel, self).__init__(*args, **kwargs)
+        self.layout = FloatLayout()
+        self.popuplabel = ServerToolTip(text="Test")
+        self.layout.add_widget(self.popuplabel)
 
     def on_enter(self):
-        self._tooltip.text = self.get_text()
-        self.display_tooltip()
+        self.popuplabel.text = self.get_text()
+        App.get_running_app().root.add_widget(self.layout)
+        fade_in_animation.start(self.layout)
 
     def on_leave(self):
-        self.animation_tooltip_dismiss()
+        App.get_running_app().root.remove_widget(self.layout)
 
     @property
     def ctx(self) -> context_type:
-        return MDApp.get_running_app().ctx
+        return App.get_running_app().ctx
 
     def get_text(self):
         if self.ctx.server:
@@ -355,11 +257,11 @@ class ServerLabel(HoverBehavior, MDTooltip, MDBoxLayout):
             return "No current server connection. \nPlease connect to an Archipelago server."
 
 
-class MainLayout(MDGridLayout):
+class MainLayout(GridLayout):
     pass
 
 
-class ContainerLayout(MDFloatLayout):
+class ContainerLayout(FloatLayout):
     pass
 
 
@@ -379,11 +281,6 @@ class SelectableLabel(RecycleDataViewBehavior, TooltipLabel):
         return super(SelectableLabel, self).refresh_view_attrs(
             rv, index, data)
 
-    def on_size(self, instance_label, size: list) -> None:
-        super().on_size(instance_label, size)
-        if self.parent:
-            self.width = self.parent.width
-
     def on_touch_down(self, touch):
         """ Add selection on touch down """
         if super(SelectableLabel, self).on_touch_down(touch):
@@ -394,10 +291,10 @@ class SelectableLabel(RecycleDataViewBehavior, TooltipLabel):
             else:
                 # Not a fan of the following few lines, but they work.
                 temp = MarkupLabel(text=self.text).markup
-                text = "".join(part for part in temp if not part.startswith("["))
-                cmdinput = MDApp.get_running_app().textinput
+                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, MDApp.get_running_app().last_autofillable_command)
+                    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
 
@@ -408,150 +305,11 @@ class SelectableLabel(RecycleDataViewBehavior, TooltipLabel):
         """ Respond to the selection of items in the view. """
         self.selected = is_selected
 
-
-class MarkupDropdownTextItem(MDDropdownTextItem):
-    def __init__(self):
-        super().__init__()
-        for child in self.children:
-            if child.__class__ == MDLabel:
-                child.markup = True
-    # Currently, this only lets us do markup on text that does not have any icons
-    # Create new TextItems as needed
-
-
-class MarkupDropdown(MDDropdownMenu):
-    def on_items(self, instance, value: list) -> None:
-        """
-        The method sets the class that will be used to create the menu item.
-        """
-
-        items = []
-        viewclass = "MarkupDropdownTextItem"
-
-        for data in value:
-            if "viewclass" not in data:
-                if (
-                    "leading_icon" not in data
-                    and "trailing_icon" not in data
-                    and "trailing_text" not in data
-                ):
-                    viewclass = "MarkupDropdownTextItem"
-                elif (
-                    "leading_icon" in data
-                    and "trailing_icon" not in data
-                    and "trailing_text" not in data
-                ):
-                    viewclass = "MDDropdownLeadingIconItem"
-                elif (
-                    "leading_icon" not in data
-                    and "trailing_icon" in data
-                    and "trailing_text" not in data
-                ):
-                    viewclass = "MDDropdownTrailingIconItem"
-                elif (
-                    "leading_icon" not in data
-                    and "trailing_icon" in data
-                    and "trailing_text" in data
-                ):
-                    viewclass = "MDDropdownTrailingIconTextItem"
-                elif (
-                    "leading_icon" in data
-                    and "trailing_icon" in data
-                    and "trailing_text" in data
-                ):
-                    viewclass = "MDDropdownLeadingTrailingIconTextItem"
-                elif (
-                    "leading_icon" in data
-                    and "trailing_icon" in data
-                    and "trailing_text" not in data
-                ):
-                    viewclass = "MDDropdownLeadingTrailingIconItem"
-                elif (
-                    "leading_icon" not in data
-                    and "trailing_icon" not in data
-                    and "trailing_text" in data
-                ):
-                    viewclass = "MDDropdownTrailingTextItem"
-                elif (
-                    "leading_icon" in data
-                    and "trailing_icon" not in data
-                    and "trailing_text" in data
-                ):
-                    viewclass = "MDDropdownLeadingIconTrailingTextItem"
-
-                data["viewclass"] = viewclass
-
-            if "height" not in data:
-                data["height"] = dp(48)
-
-            items.append(data)
-
-        self._items = items
-        # Update items in view
-        if hasattr(self, "menu"):
-            self.menu.data = self._items
-
-
-class AutocompleteHintInput(ResizableTextField):
-    min_chars = NumericProperty(3)
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-        self.dropdown = MarkupDropdown(caller=self, position="bottom", border_margin=dp(2), width=self.width)
-        self.bind(on_text_validate=self.on_message)
-        self.bind(width=lambda instance, x: setattr(self.dropdown, "width", x))
-
-    def on_message(self, instance):
-        MDApp.get_running_app().commandprocessor("!hint "+instance.text)
-
-    def on_text(self, instance, value):
-        if len(value) >= self.min_chars:
-            self.dropdown.items.clear()
-            ctx: context_type = MDApp.get_running_app().ctx
-            if not ctx.game:
-                return
-            item_names = ctx.item_names._game_store[ctx.game].values()
-
-            def on_press(text):
-                split_text = MarkupLabel(text=text).markup
-                self.set_text(self, "".join(text_frag for text_frag in split_text
-                                            if not text_frag.startswith("[")))
-                self.dropdown.dismiss()
-                self.focus = True
-
-            lowered = value.lower()
-            for item_name in item_names:
-                try:
-                    index = item_name.lower().index(lowered)
-                except ValueError:
-                    pass  # substring not found
-                else:
-                    text = escape_markup(item_name)
-                    text = text[:index] + "[b]" + text[index:index+len(value)]+"[/b]"+text[index+len(value):]
-                    self.dropdown.items.append({
-                        "text": text,
-                        "on_release": lambda txt=text: on_press(txt),
-                        "markup": True
-                    })
-            if not self.dropdown.parent:
-                self.dropdown.open()
-        else:
-            self.dropdown.dismiss()
-
-
-status_icons = {
-    HintStatus.HINT_NO_PRIORITY: "information",
-    HintStatus.HINT_PRIORITY: "exclamation-thick",
-    HintStatus.HINT_AVOID: "alert"
-}
-
-
-class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
+class HintLabel(RecycleDataViewBehavior, BoxLayout):
     selected = BooleanProperty(False)
     striped = BooleanProperty(False)
     index = None
-    dropdown: MDDropdownMenu
+    dropdown: DropDown
 
     def __init__(self):
         super(HintLabel, self).__init__()
@@ -562,28 +320,29 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
         self.entrance_text = ""
         self.status_text = ""
         self.hint = {}
+        for child in self.children:
+            child.bind(texture_size=self.set_height)
 
-        ctx = MDApp.get_running_app().ctx
-        menu_items = []
 
-        for status in (HintStatus.HINT_NO_PRIORITY, HintStatus.HINT_PRIORITY, HintStatus.HINT_AVOID):
-            name = status_names[status]
-            status_button = MDDropDownItem(MDDropDownItemText(text=name), size_hint_y=None, height=dp(50))
-            status_button.status = status
-            menu_items.append({
-                "text": name,
-                "leading_icon": status_icons[status],
-                "on_release": lambda x=status: select(self, x)
-            })
+        ctx = App.get_running_app().ctx
+        self.dropdown = DropDown()
 
-        self.dropdown = MDDropdownMenu(caller=self.ids["status"], items=menu_items)
+        def set_value(button):
+            self.dropdown.select(button.status)
 
         def select(instance, data):
             ctx.update_hint(self.hint["location"],
                             self.hint["finding_player"],
                             data)
 
-        self.dropdown.bind(on_release=self.dropdown.dismiss)
+        for status in (HintStatus.HINT_NO_PRIORITY, HintStatus.HINT_PRIORITY, HintStatus.HINT_AVOID):
+            name = status_names[status]
+            status_button = Button(text=name, size_hint_y=None, height=dp(50))
+            status_button.status = status
+            status_button.bind(on_release=set_value)
+            self.dropdown.add_widget(status_button)
+
+        self.dropdown.bind(on_select=select)
 
     def set_height(self, instance, value):
         self.height = max([child.texture_size[1] for child in self.children])
@@ -598,6 +357,7 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
         self.entrance_text = data["entrance"]["text"]
         self.status_text = data["status"]["text"]
         self.hint = data["status"]["hint"]
+        self.height = self.minimum_height
         return super(HintLabel, self).refresh_view_attrs(rv, index, data)
 
     def on_touch_down(self, touch):
@@ -610,10 +370,10 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
                 if status_label.collide_point(*touch.pos):
                     if self.hint["status"] == HintStatus.HINT_FOUND:
                         return
-                    ctx = MDApp.get_running_app().ctx
+                    ctx = App.get_running_app().ctx
                     if ctx.slot_concerns_self(self.hint["receiving_player"]):  # If this player owns this hint
                         # open a dropdown
-                        self.dropdown.open()
+                        self.dropdown.open(self.ids["status"])
                 elif self.selected:
                     self.parent.clear_selection()
                 else:
@@ -622,7 +382,8 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
                                     if self.entrance_text != "Vanilla"
                                     else "", ". (", self.status_text.lower(), ")"))
                     temp = MarkupLabel(text).markup
-                    text = "".join(part for part in temp if not part.startswith("["))
+                    text = "".join(
+                        part for part in temp if not part.startswith(("[color", "[/color]", "[ref=", "[/ref]")))
                     Clipboard.copy(escape_markup(text).replace("&amp;", "&").replace("&bl;", "[").replace("&br;", "]"))
                     return self.parent.select_with_touch(self.index, touch)
         else:
@@ -634,18 +395,15 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
                 if child.collide_point(*touch.pos):
                     key = child.sort_key
                     if key == "status":
-                        parent.hint_sorter = lambda element: status_sort_weights[element["status"]["hint"]["status"]]
-                    else:
-                        parent.hint_sorter = lambda element: (
-                            remove_between_brackets.sub("", element[key]["text"]).lower()
-                        )
+                        parent.hint_sorter = lambda element: element["status"]["hint"]["status"]
+                    else: parent.hint_sorter = lambda element: remove_between_brackets.sub("", element[key]["text"]).lower()
                     if key == parent.sort_key:
                         # second click reverses order
                         parent.reversed = not parent.reversed
                     else:
                         parent.sort_key = key
                         parent.reversed = False
-                    MDApp.get_running_app().update_hints()
+                    App.get_running_app().update_hints()
 
     def apply_selection(self, rv, index, is_selected):
         """ Respond to the selection of items in the view. """
@@ -653,7 +411,7 @@ class HintLabel(RecycleDataViewBehavior, MDBoxLayout):
             self.selected = is_selected
 
 
-class ConnectBarTextInput(ResizableTextField):
+class ConnectBarTextInput(TextInput):
     def insert_text(self, substring, from_undo=False):
         s = substring.replace("\n", "").replace("\r", "")
         return super(ConnectBarTextInput, self).insert_text(s, from_undo=from_undo)
@@ -663,14 +421,14 @@ def is_command_input(string: str) -> bool:
     return len(string) > 0 and string[0] in "/!"
 
 
-class CommandPromptTextInput(ResizableTextField):
+class CommandPromptTextInput(TextInput):
     MAXIMUM_HISTORY_MESSAGES = 50
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._command_history_index = -1
         self._command_history: typing.Deque[str] = deque(maxlen=CommandPromptTextInput.MAXIMUM_HISTORY_MESSAGES)
-
+    
     def update_history(self, new_entry: str) -> None:
         self._command_history_index = -1
         if is_command_input(new_entry):
@@ -697,7 +455,7 @@ class CommandPromptTextInput(ResizableTextField):
             self._change_to_history_text_if_available(self._command_history_index - 1)
             return True
         return super().keyboard_on_key_down(window, keycode, text, modifiers)
-
+    
     def _change_to_history_text_if_available(self, new_index: int) -> None:
         if new_index < -1:
             return
@@ -711,96 +469,32 @@ class CommandPromptTextInput(ResizableTextField):
 
 
 class MessageBox(Popup):
-    class MessageBoxLabel(MDLabel):
+    class MessageBoxLabel(Label):
         def __init__(self, **kwargs):
             super().__init__(**kwargs)
             self._label.refresh()
+            self.size = self._label.texture.size
+            if self.width + 50 > Window.width:
+                self.text_size[0] = Window.width - 50
+                self._label.refresh()
+                self.size = self._label.texture.size
 
     def __init__(self, title, text, error=False, **kwargs):
         label = MessageBox.MessageBoxLabel(text=text)
         separator_color = [217 / 255, 129 / 255, 122 / 255, 1.] if error else [47 / 255., 167 / 255., 212 / 255, 1.]
-        super().__init__(title=title, content=label, size_hint=(0.5, None), width=max(100, int(label.width) + 40),
+        super().__init__(title=title, content=label, size_hint=(None, None), width=max(100, int(label.width) + 40),
                          separator_color=separator_color, **kwargs)
         self.height += max(0, label.height - 18)
 
 
-class ClientTabs(MDTabsSecondary):
-    carousel: MDTabsCarousel
-    lock_swiping = True
-
-    def __init__(self, *args, **kwargs):
-        self.carousel = MDTabsCarousel(lock_swiping=True, anim_move_duration=0.2)
-        super().__init__(*args, MDDivider(size_hint_y=None, height=dp(1)), self.carousel, **kwargs)
-        self.size_hint_y = 1
-
-    def _check_panel_height(self, *args):
-        self.ids.tab_scroll.height = dp(38)
-
-    def update_indicator(
-        self, x: float = 0.0, w: float = 0.0, instance: MDTabsItem = None
-    ) -> None:
-        def update_indicator(*args):
-            indicator_pos = (0, 0)
-            indicator_size = (0, 0)
-
-            item_text_object = self._get_tab_item_text_icon_object()
-
-            if item_text_object:
-                indicator_pos = (
-                    instance.x + dp(12),
-                    self.indicator.pos[1]
-                    if not self._tabs_carousel
-                    else self._tabs_carousel.height,
-                )
-                indicator_size = (
-                    instance.width - dp(24),
-                    self.indicator_height,
-                )
-
-            Animation(
-                pos=indicator_pos,
-                size=indicator_size,
-                d=0 if not self.indicator_anim else self.indicator_duration,
-                t=self.indicator_transition,
-            ).start(self.indicator)
-
-        if not instance:
-            self.indicator.pos = (x, self.indicator.pos[1])
-            self.indicator.size = (w, self.indicator_height)
-        else:
-            Clock.schedule_once(update_indicator)
-
-    def remove_tab(self, tab, content=None):
-        if content is None:
-            content = tab.content
-        self.ids.container.remove_widget(tab)
-        self.carousel.remove_widget(content)
-        self.on_size(self, self.size)
-
-
-class CommandButton(MDButton, MDTooltip):
-    def __init__(self, *args, manager: "GameManager", **kwargs):
-        super().__init__(*args, **kwargs)
-        self.manager = manager
-        self._tooltip = ToolTip(text="Test")
-
-    def on_enter(self):
-        self._tooltip.text = self.manager.commandprocessor.get_help_text()
-        self._tooltip.font_size = dp(20 - (len(self._tooltip.text) // 400))  # mostly guessing on the numbers here
-        self.display_tooltip()
-
-    def on_leave(self):
-        self.animation_tooltip_dismiss()
-
-
-class GameManager(ThemedApp):
+class GameManager(App):
     logging_pairs = [
         ("Client", "Archipelago"),
     ]
     base_title: str = "Archipelago Client"
     last_autofillable_command: str
 
-    main_area_container: MDGridLayout
+    main_area_container: GridLayout
     """ subclasses can add more columns beside the tabs """
 
     def __init__(self, ctx: context_type):
@@ -835,80 +529,65 @@ class GameManager(ThemedApp):
             return max(1, len(self.tabs.tab_list))
         return 1
 
-    def on_start(self):
-        def on_start(*args):
-            self.root.md_bg_color = self.theme_cls.backgroundColor
-        super().on_start()
-        Clock.schedule_once(on_start)
-
     def build(self) -> Layout:
-        self.set_colors()
         self.container = ContainerLayout()
 
         self.grid = MainLayout()
         self.grid.cols = 1
-        self.connect_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40),
-                                          spacing=5, padding=(5, 10))
+        self.connect_layout = BoxLayout(orientation="horizontal", size_hint_y=None, height=dp(30))
         # top part
-        server_label = ServerLabel(width=dp(75))
+        server_label = ServerLabel()
         self.connect_layout.add_widget(server_label)
         self.server_connect_bar = ConnectBarTextInput(text=self.ctx.suggested_address or "archipelago.gg:",
-                                                      pos_hint={"center_x": 0.5, "center_y": 0.5})
+                                                      size_hint_y=None,
+                                                      height=dp(30), multiline=False, write_tab=False)
 
         def connect_bar_validate(sender):
             if not self.ctx.server:
                 self.connect_button_action(sender)
 
-        self.server_connect_bar.height = dp(30)
         self.server_connect_bar.bind(on_text_validate=connect_bar_validate)
         self.connect_layout.add_widget(self.server_connect_bar)
-        self.server_connect_button = MDButton(MDButtonText(text="Connect"), style="filled", size=(dp(100), dp(70)),
-                                              size_hint_x=None, size_hint_y=None, radius=5, pos_hint={"center_y": 0.55})
+        self.server_connect_button = Button(text="Connect", size=(dp(100), dp(30)), size_hint_y=None, size_hint_x=None)
         self.server_connect_button.bind(on_press=self.connect_button_action)
-        self.server_connect_button.height = self.server_connect_bar.height
         self.connect_layout.add_widget(self.server_connect_button)
         self.grid.add_widget(self.connect_layout)
-        self.progressbar = MDLinearProgressIndicator(size_hint_y=None, height=3)
+        self.progressbar = ProgressBar(size_hint_y=None, height=3)
         self.grid.add_widget(self.progressbar)
 
         # middle part
-        self.tabs = ClientTabs(pos_hint={"center_x": 0.5, "center_y": 0.5})
-        self.tabs.add_widget(MDTabsItem(MDTabsItemText(text="All" if len(self.logging_pairs) > 1 else "Archipelago")))
+        self.tabs = TabbedPanel(size_hint_y=1)
+        self.tabs.default_tab_text = "All"
         self.log_panels["All"] = self.tabs.default_tab_content = UILog(*(logging.getLogger(logger_name)
-                                                                             for logger_name, name in
-                                                                             self.logging_pairs))
-        self.tabs.carousel.add_widget(self.tabs.default_tab_content)
+                                                                         for logger_name, name in
+                                                                         self.logging_pairs))
 
         for logger_name, display_name in self.logging_pairs:
             bridge_logger = logging.getLogger(logger_name)
-            self.log_panels[display_name] = UILog(bridge_logger)
+            panel = TabbedPanelItem(text=display_name)
+            self.log_panels[display_name] = panel.content = UILog(bridge_logger)
             if len(self.logging_pairs) > 1:
-                panel = MDTabsItem(MDTabsItemText(text=display_name))
-                panel.content = self.log_panels[display_name]
                 # show Archipelago tab if other logging is present
-                self.tabs.carousel.add_widget(panel.content)
                 self.tabs.add_widget(panel)
 
-        hint_panel = self.add_client_tab("Hints", HintLayout())
-        self.hint_log = HintLog(self.json_to_kivy_parser)
+        hint_panel = self.add_client_tab("Hints", HintLog(self.json_to_kivy_parser))
         self.log_panels["Hints"] = hint_panel.content
-        hint_panel.content.add_widget(self.hint_log)
 
-        self.main_area_container = MDGridLayout(size_hint_y=1, rows=1)
+        if len(self.logging_pairs) == 1:
+            self.tabs.default_tab_text = "Archipelago"
+
+        self.main_area_container = GridLayout(size_hint_y=1, rows=1)
         self.main_area_container.add_widget(self.tabs)
 
         self.grid.add_widget(self.main_area_container)
 
         # bottom part
-        bottom_layout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40), spacing=5, padding=(5, 10))
-        info_button = CommandButton(MDButtonText(text="Command:", halign="left"), manager=self, radius=5,
-                                    style="filled", size=(dp(100), dp(70)), size_hint_x=None, size_hint_y=None,
-                                    pos_hint={"center_y": 0.575})
+        bottom_layout = BoxLayout(orientation="horizontal", size_hint_y=None, height=dp(30))
+        info_button = Button(size=(dp(100), dp(30)), text="Command:", size_hint_x=None)
         info_button.bind(on_release=self.command_button_action)
         bottom_layout.add_widget(info_button)
-        self.textinput = CommandPromptTextInput(size_hint_y=None, multiline=False, write_tab=False)
+        self.textinput = CommandPromptTextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
         self.textinput.bind(on_text_validate=self.on_message)
-        info_button.height = self.textinput.height
         self.textinput.text_validate_unfocus = False
         bottom_layout.add_widget(self.textinput)
         self.grid.add_widget(bottom_layout)
@@ -924,43 +603,29 @@ class GameManager(ThemedApp):
         self.server_connect_bar.focus = True
         self.server_connect_bar.select_text(port_start if port_start > 0 else host_start, len(s))
 
-        # Uncomment to enable the kivy live editor console
-        # Press Ctrl-E (with numlock/capslock) disabled to open
-        # from kivy.core.window import Window
-        # from kivy.modules import console
-        # console.create_console(Window, self.container)
-
         return self.container
 
-    def add_client_tab(self, title: str, content: Widget, index: int = -1) -> Widget:
+    def add_client_tab(self, title: str, content: Widget) -> Widget:
         """Adds a new tab to the client window with a given title, and provides a given Widget as its content.
          Returns the new tab widget, with the provided content being placed on the tab as content."""
-        new_tab = MDTabsItem(MDTabsItemText(text=title))
+        new_tab = TabbedPanelItem(text=title)
         new_tab.content = content
-        if -1 < index <= len(self.tabs.carousel.slides):
-            new_tab.bind(on_release=self.tabs.set_active_item)
-            new_tab._tabs = self.tabs
-            self.tabs.ids.container.add_widget(new_tab, index=index)
-            self.tabs.carousel.add_widget(new_tab.content, index=len(self.tabs.carousel.slides) - index)
-        else:
-            self.tabs.add_widget(new_tab)
-            self.tabs.carousel.add_widget(new_tab.content)
+        self.tabs.add_widget(new_tab)
         return new_tab
 
     def update_texts(self, dt):
-        for slide in self.tabs.carousel.slides:
-            if hasattr(slide, "fix_heights"):
-                slide.fix_heights()  # TODO: remove this when Kivy fixes this upstream
+        if hasattr(self.tabs.content.children[0], "fix_heights"):
+            self.tabs.content.children[0].fix_heights()  # TODO: remove this when Kivy fixes this upstream
         if self.ctx.server:
             self.title = self.base_title + " " + Utils.__version__ + \
                          f" | Connected to: {self.ctx.server_address} " \
                          f"{'.'.join(str(e) for e in self.ctx.server_version)}"
-            self.server_connect_button._button_text.text = "Disconnect"
+            self.server_connect_button.text = "Disconnect"
             self.server_connect_bar.readonly = True
             self.progressbar.max = len(self.ctx.checked_locations) + len(self.ctx.missing_locations)
             self.progressbar.value = len(self.ctx.checked_locations)
         else:
-            self.server_connect_button._button_text.text = "Connect"
+            self.server_connect_button.text = "Connect"
             self.server_connect_bar.readonly = False
             self.title = self.base_title + " " + Utils.__version__
             self.progressbar.value = 0
@@ -1023,8 +688,8 @@ class GameManager(ThemedApp):
 
     def enable_energy_link(self):
         if not hasattr(self, "energy_link_label"):
-            self.energy_link_label = MDLabel(text="Energy Link: Standby",
-                                           size_hint_x=None, width=150, halign="center")
+            self.energy_link_label = Label(text="Energy Link: Standby",
+                                           size_hint_x=None, width=150)
             self.connect_layout.add_widget(self.energy_link_label)
 
     def set_new_energy_link_value(self):
@@ -1033,7 +698,7 @@ class GameManager(ThemedApp):
 
     def update_hints(self):
         hints = self.ctx.stored_data.get(f"_read_hints_{self.ctx.team}_{self.ctx.slot}", [])
-        self.hint_log.refresh_hints(hints)
+        self.log_panels["Hints"].refresh_hints(hints)
 
     # default F1 keybind, opens a settings menu, that seems to break the layout engine once closed
     def open_settings(self, *largs):
@@ -1060,9 +725,8 @@ class LogtoUI(logging.Handler):
             self.on_log(self.format(record))
 
 
-class UILog(MDRecycleView):
+class UILog(RecycleView):
     messages: typing.ClassVar[int]  # comes from kv file
-    adaptive_height = True
 
     def __init__(self, *loggers_to_handle, **kwargs):
         super(UILog, self).__init__(**kwargs)
@@ -1089,24 +753,6 @@ class UILog(MDRecycleView):
                 element.height = element.texture_size[1]
 
 
-class HintLayout(MDBoxLayout):
-    orientation = "vertical"
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        boxlayout = MDBoxLayout(orientation="horizontal", size_hint_y=None, height=dp(40))
-        boxlayout.add_widget(MDLabel(text="New Hint:", size_hint_x=None, size_hint_y=None,
-                                     height=dp(40), width=dp(75), halign="center", valign="center"))
-        boxlayout.add_widget(AutocompleteHintInput())
-        self.add_widget(boxlayout)
-
-    def fix_heights(self):
-        for child in self.children:
-            fix_func = getattr(child, "fix_heights", None)
-            if fix_func:
-                fix_func()
-
-
 status_names: typing.Dict[HintStatus, str] = {
     HintStatus.HINT_FOUND: "Found",
     HintStatus.HINT_UNSPECIFIED: "Unspecified",
@@ -1121,15 +767,9 @@ status_colors: typing.Dict[HintStatus, str] = {
     HintStatus.HINT_AVOID: "salmon",
     HintStatus.HINT_PRIORITY: "plum",
 }
-status_sort_weights: dict[HintStatus, int] = {
-    HintStatus.HINT_FOUND: 0,
-    HintStatus.HINT_UNSPECIFIED: 1,
-    HintStatus.HINT_NO_PRIORITY: 2,
-    HintStatus.HINT_AVOID: 3,
-    HintStatus.HINT_PRIORITY: 4,
-}
 
-class HintLog(MDRecycleView):
+
+class HintLog(RecycleView):
     header = {
         "receiving": {"text": "[u]Receiving Player[/u]"},
         "item": {"text": "[u]Item[/u]"},
@@ -1140,7 +780,7 @@ class HintLog(MDRecycleView):
                    "hint": {"receiving_player": -1, "location": -1, "finding_player": -1, "status": ""}},
         "striped": True,
     }
-    data: list[typing.Any]
+
     sort_key: str = ""
     reversed: bool = True
 
@@ -1153,7 +793,7 @@ class HintLog(MDRecycleView):
         if not hints:  # Fix the scrolling looking visually wrong in some edge cases
             self.scroll_y = 1.0
         data = []
-        ctx = MDApp.get_running_app().ctx
+        ctx = App.get_running_app().ctx
         for hint in hints:
             if not hint.get("status"): # Allows connecting to old servers
                 hint["status"] = HintStatus.HINT_FOUND if hint["found"] else HintStatus.HINT_UNSPECIFIED
@@ -1203,7 +843,6 @@ class HintLog(MDRecycleView):
 
 
 class ApAsyncImage(AsyncImage):
-
     def is_uri(self, filename: str) -> bool:
         if filename.startswith("ap:"):
             return True
@@ -1218,8 +857,7 @@ class ImageLoaderPkgutil(ImageLoaderBase):
         data = pkgutil.get_data(module, path)
         return self._bytes_to_data(data)
 
-    @staticmethod
-    def _bytes_to_data(data: typing.Union[bytes, bytearray]) -> typing.List[ImageData]:
+    def _bytes_to_data(self, data: typing.Union[bytes, bytearray]) -> typing.List[ImageData]:
         loader = next(loader for loader in ImageLoader.loaders if loader.can_load_memory())
         return loader.load(loader, io.BytesIO(data))
 
@@ -1249,23 +887,7 @@ class E(ExceptionHandler):
 class KivyJSONtoTextParser(JSONtoTextParser):
     # dummy class to absorb kvlang definitions
     class TextColors(Widget):
-        white: str = StringProperty("FFFFFF")
-        black: str = StringProperty("000000")
-        red: str = StringProperty("EE0000")
-        green: str = StringProperty("00FF7F")
-        yellow: str = StringProperty("FAFAD2")
-        blue: str = StringProperty("6495ED")
-        magenta: str = StringProperty("EE00EE")
-        cyan: str = StringProperty("00EEEE")
-        slateblue: str = StringProperty("6D8BE8")
-        plum: str = StringProperty("AF99EF")
-        salmon: str = StringProperty("FA8072")
-        orange: str = StringProperty("FF7700")
-        # KivyMD parameters
-        theme_style: str = StringProperty("Dark")
-        primary_palette: str = StringProperty("Lightsteelblue")
-        dynamic_scheme_name: str = StringProperty("VIBRANT")
-        dynamic_scheme_contrast: int = NumericProperty(0)
+        pass
 
     def __init__(self, *args, **kwargs):
         # we grab the color definitions from the .kv file, then overwrite the JSONtoTextParser default entries

pytest.ini

@@ -1,7 +1,4 @@
 [pytest]
-python_files = test_*.py Test*.py __init__.py  # TODO: remove Test* once all worlds have been ported
+python_files = test_*.py Test*.py  # TODO: remove Test* once all worlds have been ported
 python_classes = Test
 python_functions = test
-testpaths =
-    test
-    worlds

requirements.txt

@@ -1,18 +1,14 @@
 colorama>=0.4.6
 websockets>=13.0.1,<14
 PyYAML>=6.0.2
-jellyfish>=1.1.3
-jinja2>=3.1.6
+jellyfish>=1.1.0
+jinja2>=3.1.4
 schema>=0.7.7
-kivy>=2.3.1
-bsdiff4>=1.2.6
-platformdirs>=4.3.6
-certifi>=2025.4.26
-cython>=3.0.12
-cymem>=2.0.11
-orjson>=3.10.15
-discord-webhook>=1.3.0
+kivy>=2.3.0
+bsdiff4>=1.2.4
+platformdirs>=4.2.2
+certifi>=2024.8.30
+cython>=3.0.11
+cymem>=2.0.8
+orjson>=3.10.7
 typing_extensions>=4.12.2
-pyshortcuts>=1.9.1
-kivymd @ git+https://github.com/kivymd/KivyMD@5ff9d0d
-kivymd>=2.0.1.dev0

settings.py

@@ -10,10 +10,9 @@ import sys
 import types
 import typing
 import warnings
-from collections.abc import Iterator, Sequence
 from enum import IntEnum
 from threading import Lock
-from typing import cast, Any, BinaryIO, ClassVar, TextIO, TypeVar, Union
+from typing import cast, Any, BinaryIO, ClassVar, Dict, Iterator, List, Optional, TextIO, Tuple, Union, TypeVar
 
 __all__ = [
     "get_settings", "fmt_doc", "no_gui",
@@ -24,7 +23,7 @@ __all__ = [
 
 no_gui = False
 skip_autosave = False
-_world_settings_name_cache: dict[str, str] = {}  # TODO: cache on disk and update when worlds change
+_world_settings_name_cache: Dict[str, str] = {}  # TODO: cache on disk and update when worlds change
 _world_settings_name_cache_updated = False
 _lock = Lock()
 
@@ -54,7 +53,7 @@ def fmt_doc(cls: type, level: int) -> str:
 
 
 class Group:
-    _type_cache: ClassVar[dict[str, Any] | None] = None
+    _type_cache: ClassVar[Optional[Dict[str, Any]]] = None
     _dumping: bool = False
     _has_attr: bool = False
     _changed: bool = False
@@ -107,10 +106,10 @@ class Group:
                                         self.__dict__.values()))
 
     @classmethod
-    def get_type_hints(cls) -> dict[str, Any]:
+    def get_type_hints(cls) -> Dict[str, Any]:
         """Returns resolved type hints for the class"""
         if cls._type_cache is None:
-            if not cls.__annotations__ or not isinstance(next(iter(cls.__annotations__.values())), str):
+            if not isinstance(next(iter(cls.__annotations__.values())), str):
                 # non-str: assume already resolved
                 cls._type_cache = cls.__annotations__
             else:
@@ -125,10 +124,10 @@ class Group:
             return self[key]
         return default
 
-    def items(self) -> list[tuple[str, Any]]:
+    def items(self) -> List[Tuple[str, Any]]:
         return [(key, getattr(self, key)) for key in self]
 
-    def update(self, dct: dict[str, Any]) -> None:
+    def update(self, dct: Dict[str, Any]) -> None:
         assert isinstance(dct, dict), f"{self.__class__.__name__}.update called with " \
                                       f"{dct.__class__.__name__} instead of dict."
 
@@ -197,7 +196,7 @@ class Group:
                         warnings.warn(f"{self.__class__.__name__}.{k} "
                                       f"assigned from incompatible type {type(v).__name__}")
 
-    def as_dict(self, *args: str, downcast: bool = True) -> dict[str, Any]:
+    def as_dict(self, *args: str, downcast: bool = True) -> Dict[str, Any]:
         return {
             name: _to_builtin(cast(object, getattr(self, name))) if downcast else getattr(self, name)
             for name in self if not args or name in args
@@ -212,7 +211,7 @@ class Group:
         f.write(f"{indent}{yaml_line}")
 
     @classmethod
-    def _dump_item(cls, name: str | None, attr: object, f: TextIO, level: int) -> None:
+    def _dump_item(cls, name: Optional[str], attr: object, f: TextIO, level: int) -> None:
         """Write a group, dict or sequence item to f, where attr can be a scalar or a collection"""
 
         # lazy construction of yaml Dumper to avoid loading Utils early
@@ -224,7 +223,7 @@ class Group:
                     def represent_mapping(self, tag: str, mapping: Any, flow_style: Any = None) -> MappingNode:
                         from yaml import ScalarNode
                         res: MappingNode = super().represent_mapping(tag, mapping, flow_style)
-                        pairs = cast(list[tuple[ScalarNode, Any]], res.value)
+                        pairs = cast(List[Tuple[ScalarNode, Any]], res.value)
                         for k, v in pairs:
                             k.style = None  # remove quotes from keys
                         return res
@@ -271,20 +270,15 @@ class Group:
             # fetch class to avoid going through getattr
             cls = self.__class__
             type_hints = cls.get_type_hints()
-            entries = [e for e in self]
-            if not entries:
-                # write empty dict for empty Group with no instance values
-                cls._dump_value({}, f, indent="  " * level)
             # validate group
             for name in cls.__annotations__.keys():
                 assert hasattr(cls, name), f"{cls}.{name} is missing a default value"
             # dump ordered members
-            for name in entries:
+            for name in self:
                 attr = cast(object, getattr(self, name))
                 attr_cls = type_hints[name] if name in type_hints else attr.__class__
                 attr_cls_origin = typing.get_origin(attr_cls)
-                # resolve to first type for doc string
-                while attr_cls_origin is Union or attr_cls_origin is types.UnionType:
+                while attr_cls_origin is Union:  # resolve to first type for doc string
                     attr_cls = typing.get_args(attr_cls)[0]
                     attr_cls_origin = typing.get_origin(attr_cls)
                 if attr_cls.__doc__ and attr_cls.__module__ != "builtins":
@@ -330,9 +324,9 @@ class Path(str):
     """Marks the file as required and opens a file browser when missing"""
     is_exe: bool = False
     """Special cross-platform handling for executables"""
-    description: str | None = None
+    description: Optional[str] = None
     """Title to display when browsing for the file"""
-    copy_to: str | None = None
+    copy_to: Optional[str] = None
     """If not None, copy to AP folder instead of linking it"""
 
     @classmethod
@@ -340,7 +334,7 @@ class Path(str):
         """Overload and raise to validate input files from browse"""
         pass
 
-    def browse(self: T, **kwargs: Any) -> T | None:
+    def browse(self: T, **kwargs: Any) -> Optional[T]:
         """Opens a file browser to search for the file"""
         raise NotImplementedError(f"Please use a subclass of Path for {self.__class__.__name__}")
 
@@ -370,12 +364,12 @@ class _LocalPath(str):
 class FilePath(Path):
     # path to a file
 
-    md5s: ClassVar[list[str | bytes]] = []
+    md5s: ClassVar[List[Union[str, bytes]]] = []
     """MD5 hashes for default validator."""
 
     def browse(self: T,
-               filetypes: Sequence[tuple[str, Sequence[str]]] | None = None, **kwargs: Any)\
-            -> T | None:
+               filetypes: Optional[typing.Sequence[typing.Tuple[str, typing.Sequence[str]]]] = None, **kwargs: Any)\
+            -> Optional[T]:
         from Utils import open_filename, is_windows
         if not filetypes:
             if self.is_exe:
@@ -440,7 +434,7 @@ class FilePath(Path):
 class FolderPath(Path):
     # path to a folder
 
-    def browse(self: T, **kwargs: Any) -> T | None:
+    def browse(self: T, **kwargs: Any) -> Optional[T]:
         from Utils import open_directory
         res = open_directory(f"Select {self.description or self.__class__.__name__}", self)
         if res:
@@ -598,16 +592,16 @@ class ServerOptions(Group):
         OFF = 0
         ON = 1
 
-    host: str | None = None
+    host: Optional[str] = None
     port: int = 38281
-    password: str | None = None
-    multidata: str | None = None
-    savefile: str | None = None
+    password: Optional[str] = None
+    multidata: Optional[str] = None
+    savefile: Optional[str] = None
     disable_save: bool = False
     loglevel: str = "info"
     logtime: bool = False
-    server_password: ServerPassword | None = None
-    disable_item_cheat: DisableItemCheat | bool = False
+    server_password: Optional[ServerPassword] = None
+    disable_item_cheat: Union[DisableItemCheat, bool] = False
     location_check_points: LocationCheckPoints = LocationCheckPoints(1)
     hint_cost: HintCost = HintCost(10)
     release_mode: ReleaseMode = ReleaseMode("auto")
@@ -684,8 +678,6 @@ class GeneratorOptions(Group):
     race: Race = Race(0)
     plando_options: PlandoOptions = PlandoOptions("bosses, connections, texts")
     panic_method: PanicMethod = PanicMethod("swap")
-    loglevel: str = "info"
-    logtime: bool = False
 
 
 class SNIOptions(Group):
@@ -703,7 +695,7 @@ does nothing if not found
         """
 
     sni_path: SNIPath = SNIPath("SNI")
-    snes_rom_start: SnesRomStart | bool = True
+    snes_rom_start: Union[SnesRomStart, bool] = True
 
 
 class BizHawkClientOptions(Group):
@@ -722,7 +714,7 @@ class BizHawkClientOptions(Group):
         """
 
     emuhawk_path: EmuHawkPath = EmuHawkPath(None)
-    rom_start: RomStart | bool = True
+    rom_start: Union[RomStart, bool] = True
 
 
 # Top-level group with lazy loading of worlds
@@ -734,7 +726,7 @@ class Settings(Group):
     sni_options: SNIOptions = SNIOptions()
     bizhawkclient_options: BizHawkClientOptions = BizHawkClientOptions()
 
-    _filename: str | None = None
+    _filename: Optional[str] = None
 
     def __getattribute__(self, key: str) -> Any:
         if key.startswith("_") or key in self.__class__.__dict__:
@@ -788,22 +780,12 @@ class Settings(Group):
 
         return super().__getattribute__(key)
 
-    def __init__(self, location: str | None):  # change to PathLike[str] once we drop 3.8?
+    def __init__(self, location: Optional[str]):  # change to PathLike[str] once we drop 3.8?
         super().__init__()
         if location:
             from Utils import parse_yaml
             with open(location, encoding="utf-8-sig") as f:
-                from yaml.error import MarkedYAMLError
-                try:
-                    options = parse_yaml(f.read())
-                except MarkedYAMLError as ex:
-                    if ex.problem_mark:
-                        f.seek(0)
-                        lines = f.readlines()
-                        problem_line = lines[ex.problem_mark.line]
-                        error_line = " " * ex.problem_mark.column + "^"
-                        raise Exception(f"{ex.context} {ex.problem}\n{problem_line}{error_line}")
-                    raise ex
+                options = parse_yaml(f.read())
                 # TODO: detect if upgrade is required
                 # TODO: once we have a cache for _world_settings_name_cache, detect if any game section is missing
                 self.update(options or {})
@@ -822,7 +804,7 @@ class Settings(Group):
             import atexit
             atexit.register(autosave)
 
-    def save(self, location: str | None = None) -> None:  # as above
+    def save(self, location: Optional[str] = None) -> None:  # as above
         from Utils import parse_yaml
         location = location or self._filename
         assert location, "No file specified"
@@ -855,7 +837,7 @@ class Settings(Group):
         super().dump(f, level)
 
     @property
-    def filename(self) -> str | None:
+    def filename(self) -> Optional[str]:
         return self._filename
 
 
@@ -868,7 +850,7 @@ def get_settings() -> Settings:
         if not res:
             from Utils import user_path, local_path
             filenames = ("options.yaml", "host.yaml")
-            locations: list[str] = []
+            locations: List[str] = []
             if os.path.join(os.getcwd()) != local_path():
                 locations += filenames  # use files from cwd only if it's not the local_path
             locations += [user_path(filename) for filename in filenames]

setup.py

@@ -1,23 +1,25 @@
 import base64
 import datetime
-import io
-import json
 import os
 import platform
 import shutil
-import subprocess
 import sys
 import sysconfig
-import threading
-import urllib.request
 import warnings
 import zipfile
-from collections.abc import Iterable, Sequence
+import urllib.request
+import io
+import json
+import threading
+import subprocess
+
 from hashlib import sha3_512
 from pathlib import Path
+from typing import Dict, Iterable, List, Optional, Sequence, Set, Tuple, Union
+
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
-requirement = 'cx-Freeze==8.0.0'
+requirement = 'cx-Freeze==7.2.0'
 try:
     import pkg_resources
     try:
@@ -58,7 +60,7 @@ from Cython.Build import cythonize
 
 
 # On  Python < 3.10 LogicMixin is not currently supported.
-non_apworlds: set[str] = {
+non_apworlds: Set[str] = {
     "A Link to the Past",
     "Adventure",
     "ArchipIDLE",
@@ -70,6 +72,7 @@ non_apworlds: set[str] = {
     "Ocarina of Time",
     "Overcooked! 2",
     "Raft",
+    "Slay the Spire",
     "Sudoku",
     "Super Mario 64",
     "VVVVVV",
@@ -145,13 +148,13 @@ def download_SNI() -> None:
         print(f"No SNI found for system spec {platform_name} {machine_name}")
 
 
-signtool: str | None
+signtool: Optional[str]
 if os.path.exists("X:/pw.txt"):
     print("Using signtool")
     with open("X:/pw.txt", encoding="utf-8-sig") as f:
         pw = f.read()
     signtool = r'signtool sign /f X:/_SITS_Zertifikat_.pfx /p "' + pw + \
-               r'" /fd sha256 /td sha256 /tr http://timestamp.digicert.com/ '
+               r'" /fd sha256 /tr http://timestamp.digicert.com/ '
 else:
     signtool = None
 
@@ -203,7 +206,7 @@ def remove_sprites_from_folder(folder: Path) -> None:
             os.remove(folder / file)
 
 
-def _threaded_hash(filepath: str | Path) -> str:
+def _threaded_hash(filepath: Union[str, Path]) -> str:
     hasher = sha3_512()
     hasher.update(open(filepath, "rb").read())
     return base64.b85encode(hasher.digest()).decode()
@@ -253,7 +256,7 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
         self.libfolder = Path(self.buildfolder, "lib")
         self.library = Path(self.libfolder, "library.zip")
 
-    def installfile(self, path: Path, subpath: str | Path | None = None, keep_content: bool = False) -> None:
+    def installfile(self, path: Path, subpath: Optional[Union[str, Path]] = None, keep_content: bool = False) -> None:
         folder = self.buildfolder
         if subpath:
             folder /= subpath
@@ -372,7 +375,7 @@ class BuildExeCommand(cx_Freeze.command.build_exe.build_exe):
         from worlds.AutoWorld import AutoWorldRegister
         assert not non_apworlds - set(AutoWorldRegister.world_types), \
             f"Unknown world {non_apworlds - set(AutoWorldRegister.world_types)} designated for .apworld"
-        folders_to_remove: list[str] = []
+        folders_to_remove: List[str] = []
         disabled_worlds_folder = "worlds_disabled"
         for entry in os.listdir(disabled_worlds_folder):
             if os.path.isdir(os.path.join(disabled_worlds_folder, entry)):
@@ -444,12 +447,12 @@ class AppImageCommand(setuptools.Command):
         ("app-exec=", None, "The application to run inside the image."),
         ("yes", "y", 'Answer "yes" to all questions.'),
     ]
-    build_folder: Path | None
-    dist_file: Path | None
-    app_dir: Path | None
+    build_folder: Optional[Path]
+    dist_file: Optional[Path]
+    app_dir: Optional[Path]
     app_name: str
-    app_exec: Path | None
-    app_icon: Path | None  # source file
+    app_exec: Optional[Path]
+    app_icon: Optional[Path]  # source file
     app_id: str  # lower case name, used for icon and .desktop
     yes: bool
 
@@ -491,7 +494,7 @@ $APPDIR/$exe "$@"
 """)
         launcher_filename.chmod(0o755)
 
-    def install_icon(self, src: Path, name: str | None = None, symlink: Path | None = None) -> None:
+    def install_icon(self, src: Path, name: Optional[str] = None, symlink: Optional[Path] = None) -> None:
         assert self.app_dir, "Invalid app_dir"
         try:
             from PIL import Image
@@ -554,7 +557,7 @@ $APPDIR/$exe "$@"
         subprocess.call(f'ARCH={build_arch} ./appimagetool -n "{self.app_dir}" "{self.dist_file}"', shell=True)
 
 
-def find_libs(*args: str) -> Sequence[tuple[str, str]]:
+def find_libs(*args: str) -> Sequence[Tuple[str, str]]:
     """Try to find system libraries to be included."""
     if not args:
         return []
@@ -562,7 +565,7 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
     arch = build_arch.replace('_', '-')
     libc = 'libc6'  # we currently don't support musl
 
-    def parse(line: str) -> tuple[tuple[str, str, str], str]:
+    def parse(line: str) -> Tuple[Tuple[str, str, str], str]:
         lib, path = line.strip().split(' => ')
         lib, typ = lib.split(' ', 1)
         for test_arch in ('x86-64', 'i386', 'aarch64'):
@@ -587,8 +590,8 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
             k: v for k, v in (parse(line) for line in data if "=>" in line)
         }
 
-    def find_lib(lib: str, arch: str, libc: str) -> str | None:
-        cache: dict[tuple[str, str, str], str] = getattr(find_libs, "cache")
+    def find_lib(lib: str, arch: str, libc: str) -> Optional[str]:
+        cache: Dict[Tuple[str, str, str], str] = getattr(find_libs, "cache")
         for k, v in cache.items():
             if k == (lib, arch, libc):
                 return v
@@ -597,7 +600,7 @@ def find_libs(*args: str) -> Sequence[tuple[str, str]]:
                 return v
         return None
 
-    res: list[tuple[str, str]] = []
+    res: List[Tuple[str, str]] = []
     for arg in args:
         # try exact match, empty libc, empty arch, empty arch and libc
         file = find_lib(arg, arch, libc)
@@ -626,13 +629,12 @@ cx_Freeze.setup(
     ext_modules=cythonize("_speedups.pyx"),
     options={
         "build_exe": {
-            "packages": ["worlds", "kivy", "cymem", "websockets", "kivymd"],
+            "packages": ["worlds", "kivy", "cymem", "websockets"],
             "includes": [],
             "excludes": ["numpy", "Cython", "PySide2", "PIL",
-                         "pandas"],
-            "zip_includes": [],
+                         "pandas", "zstandard"],
             "zip_include_packages": ["*"],
-            "zip_exclude_packages": ["worlds", "sc2", "kivymd"],
+            "zip_exclude_packages": ["worlds", "sc2"],
             "include_files": [],  # broken in cx 6.14.0, we use more special sauce now
             "include_msvcr": False,
             "replace_paths": ["*."],

test/benchmark/locations.py

@@ -18,15 +18,7 @@ def run_locations_benchmark():
 
     class BenchmarkRunner:
         gen_steps: typing.Tuple[str, ...] = (
-            "generate_early",
-            "create_regions",
-            "create_items",
-            "set_rules",
-            "connect_entrances",
-            "generate_basic",
-            "pre_fill",
-        )
-
+            "generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
         rule_iterations: int = 100_000
 
         if sys.version_info >= (3, 9):

test/cpp/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.16)
+cmake_minimum_required(VERSION 3.5)
 project(ap-cpp-tests)
 
 enable_testing()
@@ -7,8 +7,8 @@ find_package(GTest REQUIRED)
 
 if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
     add_definitions("/source-charset:utf-8")
-    # set(CMAKE_CXX_FLAGS_DEBUG "/MDd") # this is the default
-    # set(CMAKE_CXX_FLAGS_RELEASE "/MD") # this is the default
+    set(CMAKE_CXX_FLAGS_DEBUG "/MTd")
+    set(CMAKE_CXX_FLAGS_RELEASE "/MT")
 elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     # enable static analysis for gcc
     add_compile_options(-fanalyzer -Werror)

test/general/__init__.py

@@ -5,15 +5,7 @@ from BaseClasses import CollectionState, Item, ItemClassification, Location, Mul
 from worlds import network_data_package
 from worlds.AutoWorld import World, call_all
 
-gen_steps = (
-    "generate_early",
-    "create_regions",
-    "create_items",
-    "set_rules",
-    "connect_entrances",
-    "generate_basic",
-    "pre_fill",
-)
+gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
 
 
 def setup_solo_multiworld(

test/general/test_entrance_rando.py

@@ -1,4 +1,3 @@
-from typing import Callable
 import unittest
 from enum import IntEnum
 
@@ -35,7 +34,7 @@ def generate_entrance_pair(region: Region, name_suffix: str, group: int):
 
 
 def generate_disconnected_region_grid(multiworld: MultiWorld, grid_side_length: int, region_size: int = 0,
-                                      region_creator: Callable[[str, int, MultiWorld], Region] = Region):
+                                      region_type: type[Region] = Region):
     """
     Generates a grid-like region structure for ER testing, where menu is connected to the top-left region, and each
     region "in vanilla" has 2 2-way exits going either down or to the right, until reaching the goal region in the
@@ -45,7 +44,7 @@ def generate_disconnected_region_grid(multiworld: MultiWorld, grid_side_length:
         for col in range(grid_side_length):
             index = row * grid_side_length + col
             name = f"region{index}"
-            region = region_creator(name, 1, multiworld)
+            region = region_type(name, 1, multiworld)
             multiworld.regions.append(region)
             generate_locations(region_size, 1, region=region, tag=f"_{name}")
 
@@ -66,10 +65,8 @@ class TestEntranceLookup(unittest.TestCase):
         """tests that get_targets shuffles targets between groups when requested"""
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 5)
-        exits_set = set([ex for region in multiworld.get_regions(1)
-                        for ex in region.exits if not ex.connected_region])
 
-        lookup = EntranceLookup(multiworld.worlds[1].random, coupled=True, usable_exits=exits_set)
+        lookup = EntranceLookup(multiworld.worlds[1].random, coupled=True)
         er_targets = [entrance for region in multiworld.get_regions(1)
                       for entrance in region.entrances if not entrance.parent_region]
         for entrance in er_targets:
@@ -89,10 +86,8 @@ class TestEntranceLookup(unittest.TestCase):
         """tests that get_targets does not shuffle targets between groups when requested"""
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 5)
-        exits_set = set([ex for region in multiworld.get_regions(1)
-                        for ex in region.exits if not ex.connected_region])
 
-        lookup = EntranceLookup(multiworld.worlds[1].random, coupled=True, usable_exits=exits_set)
+        lookup = EntranceLookup(multiworld.worlds[1].random, coupled=True)
         er_targets = [entrance for region in multiworld.get_regions(1)
                       for entrance in region.entrances if not entrance.parent_region]
         for entrance in er_targets:
@@ -104,30 +99,6 @@ class TestEntranceLookup(unittest.TestCase):
         group_order = [prev := group.randomization_group for group in retrieved_targets if prev != group.randomization_group]
         self.assertEqual([ERTestGroups.TOP, ERTestGroups.BOTTOM], group_order)
 
-    def test_selective_dead_ends(self):
-        """test that entrances that EntranceLookup has not been told to consider are ignored when finding dead-ends"""
-        multiworld = generate_test_multiworld()
-        generate_disconnected_region_grid(multiworld, 5)
-        exits_set = set([ex for region in multiworld.get_regions(1)
-                        for ex in region.exits if not ex.connected_region
-                         and ex.name != "region20_right" and ex.name != "region21_left"])
-
-        lookup = EntranceLookup(multiworld.worlds[1].random, coupled=True, usable_exits=exits_set)
-        er_targets = [entrance for region in multiworld.get_regions(1)
-                      for entrance in region.entrances if not entrance.parent_region and
-                      entrance.name != "region20_right" and entrance.name != "region21_left"]
-        for entrance in er_targets:
-            lookup.add(entrance)
-        # region 20 is the bottom left corner of the grid, and therefore only has a right entrance from region 21
-        # and a top entrance from region 15; since we've told lookup to ignore the right entrance from region 21,
-        # the top entrance from region 15 should be considered a dead-end
-        dead_end_region = multiworld.get_region("region20", 1)
-        for dead_end in dead_end_region.entrances:
-            if dead_end.name == "region20_top":
-                break
-        # there should be only this one dead-end
-        self.assertTrue(dead_end in lookup.dead_ends)
-        self.assertEqual(len(lookup.dead_ends), 1)
 
 class TestBakeTargetGroupLookup(unittest.TestCase):
     def test_lookup_generation(self):
@@ -177,7 +148,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
         e.randomization_group = 1
         e.connect(r2)
 
-        disconnect_entrance_for_randomization(e, one_way_target_name="foo")
+        disconnect_entrance_for_randomization(e)
 
         self.assertIsNone(e.connected_region)
         self.assertEqual([], r1.entrances)
@@ -187,22 +158,10 @@ class TestDisconnectForRandomization(unittest.TestCase):
 
         self.assertEqual(1, len(r2.entrances))
         self.assertIsNone(r2.entrances[0].parent_region)
-        self.assertEqual("foo", r2.entrances[0].name)
+        self.assertEqual("r2", r2.entrances[0].name)
         self.assertEqual(EntranceType.ONE_WAY, r2.entrances[0].randomization_type)
         self.assertEqual(1, r2.entrances[0].randomization_group)
 
-    def test_disconnect_default_1way_no_vanilla_target_raises(self):
-        multiworld = generate_test_multiworld()
-        r1 = Region("r1", 1, multiworld)
-        r2 = Region("r2", 1, multiworld)
-        e = r1.create_exit("e")
-        e.randomization_type = EntranceType.ONE_WAY
-        e.randomization_group = 1
-        e.connect(r2)
-
-        with self.assertRaises(ValueError):
-            disconnect_entrance_for_randomization(e)
-
     def test_disconnect_uses_alternate_group(self):
         multiworld = generate_test_multiworld()
         r1 = Region("r1", 1, multiworld)
@@ -212,7 +171,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
         e.randomization_group = 1
         e.connect(r2)
 
-        disconnect_entrance_for_randomization(e, 2, "foo")
+        disconnect_entrance_for_randomization(e, 2)
 
         self.assertIsNone(e.connected_region)
         self.assertEqual([], r1.entrances)
@@ -222,7 +181,7 @@ class TestDisconnectForRandomization(unittest.TestCase):
 
         self.assertEqual(1, len(r2.entrances))
         self.assertIsNone(r2.entrances[0].parent_region)
-        self.assertEqual("foo", r2.entrances[0].name)
+        self.assertEqual("r2", r2.entrances[0].name)
         self.assertEqual(EntranceType.ONE_WAY, r2.entrances[0].randomization_type)
         self.assertEqual(2, r2.entrances[0].randomization_group)
 
@@ -259,7 +218,7 @@ class TestRandomizeEntrances(unittest.TestCase):
         self.assertEqual(80, len(result.pairings))
         self.assertEqual(80, len(result.placements))
 
-    def test_coupled(self):
+    def test_coupling(self):
         """tests that in coupled mode, all 2 way transitions have an inverse"""
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 5)
@@ -277,36 +236,6 @@ class TestRandomizeEntrances(unittest.TestCase):
         # if we didn't visit every placement the verification on_connect doesn't really mean much
         self.assertEqual(len(result.placements), seen_placement_count)
 
-    def test_uncoupled_succeeds_stage1_indirect_condition(self):
-        multiworld = generate_test_multiworld()
-        menu = multiworld.get_region("Menu", 1)
-        generate_entrance_pair(menu, "_right", ERTestGroups.RIGHT)
-        end = Region("End", 1, multiworld)
-        multiworld.regions.append(end)
-        generate_entrance_pair(end, "_left", ERTestGroups.LEFT)
-        multiworld.register_indirect_condition(end, None)
-
-        result = randomize_entrances(multiworld.worlds[1], False, directionally_matched_group_lookup)
-        self.assertSetEqual({
-            ("Menu_right", "End_left"),
-            ("End_left", "Menu_right")
-        }, set(result.pairings))
-
-    def test_coupled_succeeds_stage1_indirect_condition(self):
-        multiworld = generate_test_multiworld()
-        menu = multiworld.get_region("Menu", 1)
-        generate_entrance_pair(menu, "_right", ERTestGroups.RIGHT)
-        end = Region("End", 1, multiworld)
-        multiworld.regions.append(end)
-        generate_entrance_pair(end, "_left", ERTestGroups.LEFT)
-        multiworld.register_indirect_condition(end, None)
-
-        result = randomize_entrances(multiworld.worlds[1], True, directionally_matched_group_lookup)
-        self.assertSetEqual({
-            ("Menu_right", "End_left"),
-            ("End_left", "Menu_right")
-        }, set(result.pairings))
-
     def test_uncoupled(self):
         """tests that in uncoupled mode, no transitions have an (intentional) inverse"""
         multiworld = generate_test_multiworld()
@@ -382,37 +311,6 @@ class TestRandomizeEntrances(unittest.TestCase):
         self.assertEqual([], [exit_ for region in multiworld.get_regions()
                               for exit_ in region.exits if not exit_.connected_region])
 
-    def test_minimal_entrance_rando_with_collect_override(self):
-        """
-        tests that entrance randomization can complete with minimal accessibility and unreachable exits
-        when the world defines a collect override that add extra values to prog_items
-        """
-        multiworld = generate_test_multiworld()
-        multiworld.worlds[1].options.accessibility = Accessibility.from_any(Accessibility.option_minimal)
-        multiworld.completion_condition[1] = lambda state: state.can_reach("region24", player=1)
-        generate_disconnected_region_grid(multiworld, 5, 1)
-        prog_items = generate_items(10, 1, True)
-        multiworld.itempool += prog_items
-        filler_items = generate_items(15, 1, False)
-        multiworld.itempool += filler_items
-        e = multiworld.get_entrance("region1_right", 1)
-        set_rule(e, lambda state: False)
-
-        old_collect = multiworld.worlds[1].collect
-
-        def new_collect(state, item):
-            old_collect(state, item)
-            state.prog_items[item.player]["counter"] += 300
-
-        multiworld.worlds[1].collect = new_collect
-
-        randomize_entrances(multiworld.worlds[1], False, directionally_matched_group_lookup)
-
-        self.assertEqual([], [entrance for region in multiworld.get_regions()
-                              for entrance in region.entrances if not entrance.parent_region])
-        self.assertEqual([], [exit_ for region in multiworld.get_regions()
-                              for exit_ in region.exits if not exit_.connected_region])
-
     def test_restrictive_region_requirement_does_not_fail(self):
         multiworld = generate_test_multiworld()
         generate_disconnected_region_grid(multiworld, 2, 1)
@@ -466,7 +364,7 @@ class TestRandomizeEntrances(unittest.TestCase):
             entrance_type = CustomEntrance
 
         multiworld = generate_test_multiworld()
-        generate_disconnected_region_grid(multiworld, 5, region_creator=CustomRegion)
+        generate_disconnected_region_grid(multiworld, 5, region_type=CustomRegion)
 
         self.assertRaises(EntranceRandomizationError, randomize_entrances, multiworld.worlds[1], False,
                           directionally_matched_group_lookup)

test/general/test_entrances.py

@@ -1,63 +0,0 @@
-import unittest
-from worlds.AutoWorld import AutoWorldRegister, call_all, World
-from . import setup_solo_multiworld
-
-
-class TestBase(unittest.TestCase):
-    def test_entrance_connection_steps(self):
-        """Tests that Entrances are connected and not changed after connect_entrances."""
-        def get_entrance_name_to_source_and_target_dict(world: World):
-            return [
-                (entrance.name, entrance.parent_region, entrance.connected_region)
-                for entrance in world.get_entrances()
-            ]
-
-        gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances")
-        additional_steps = ("generate_basic", "pre_fill")
-
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Game", game_name=game_name):
-                multiworld = setup_solo_multiworld(world_type, gen_steps)
-
-                original_entrances = get_entrance_name_to_source_and_target_dict(multiworld.worlds[1])
-
-                self.assertTrue(
-                    all(entrance[1] is not None and entrance[2] is not None for entrance in original_entrances),
-                    f"{game_name} had unconnected entrances after connect_entrances"
-                )
-
-                for step in additional_steps:
-                    with self.subTest("Step", step=step):
-                        call_all(multiworld, step)
-                        step_entrances = get_entrance_name_to_source_and_target_dict(multiworld.worlds[1])
-
-                        self.assertEqual(
-                            original_entrances, step_entrances, f"{game_name} modified entrances during {step}"
-                        )
-
-    def test_all_state_before_connect_entrances(self):
-        """Before connect_entrances, Entrance objects may be unconnected.
-        Thus, we test that get_all_state is performed with allow_partial_entrances if used before or during
-        connect_entrances."""
-
-        gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances")
-
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Game", game_name=game_name):
-                multiworld = setup_solo_multiworld(world_type, ())
-
-                original_get_all_state = multiworld.get_all_state
-
-                def patched_get_all_state(use_cache: bool, allow_partial_entrances: bool = False):
-                    self.assertTrue(allow_partial_entrances, (
-                        "Before the connect_entrances step finishes, other worlds might still have partial entrances. "
-                        "As such, any call to get_all_state must use allow_partial_entrances = True."
-                    ))
-
-                    return original_get_all_state(use_cache, allow_partial_entrances)
-
-                multiworld.get_all_state = patched_get_all_state
-
-                for step in gen_steps:
-                    with self.subTest("Step", step=step):
-                        call_all(multiworld, step)

test/general/test_helpers.py

@@ -1,8 +1,6 @@
 import unittest
 from typing import Callable, Dict, Optional
 
-from typing_extensions import override
-
 from BaseClasses import CollectionState, MultiWorld, Region
 
 
@@ -10,7 +8,6 @@ class TestHelpers(unittest.TestCase):
     multiworld: MultiWorld
     player: int = 1
 
-    @override
     def setUp(self) -> None:
         self.multiworld = MultiWorld(self.player)
         self.multiworld.game[self.player] = "helper_test_game"
@@ -41,15 +38,15 @@ class TestHelpers(unittest.TestCase):
             "TestRegion1": {"TestRegion2": "connection"},
             "TestRegion2": {"TestRegion1": None},
         }
-
+        
         reg_exit_set: Dict[str, set[str]] = {
             "TestRegion1": {"TestRegion3"}
         }
-
+        
         exit_rules: Dict[str, Callable[[CollectionState], bool]] = {
             "TestRegion1": lambda state: state.has("test_item", self.player)
         }
-
+        
         self.multiworld.regions += [Region(region, self.player, self.multiworld, regions[region]) for region in regions]
 
         with self.subTest("Test Location Creation Helper"):
@@ -76,7 +73,7 @@ class TestHelpers(unittest.TestCase):
                         entrance_name = exit_name if exit_name else f"{parent} -> {exit_reg}"
                         self.assertEqual(exit_rules[exit_reg],
                                          self.multiworld.get_entrance(entrance_name, self.player).access_rule)
-
+            
             for region in reg_exit_set:
                 current_region = self.multiworld.get_region(region, self.player)
                 current_region.add_exits(reg_exit_set[region])

test/general/test_ids.py

@@ -47,39 +47,13 @@ class TestIDs(unittest.TestCase):
         """Test that a game doesn't have item id overlap within its own datapackage"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
-                len_item_id_to_name = len(world_type.item_id_to_name)
-                len_item_name_to_id = len(world_type.item_name_to_id)
-
-                if len_item_id_to_name != len_item_name_to_id:
-                    self.assertCountEqual(
-                        world_type.item_id_to_name.values(), 
-                        world_type.item_name_to_id.keys(),
-                        "\nThese items have overlapping ids with other items in its own world")
-                    self.assertCountEqual(
-                        world_type.item_id_to_name.keys(), 
-                        world_type.item_name_to_id.values(),
-                        "\nThese items have overlapping names with other items in its own world")
-                    
-                self.assertEqual(len_item_id_to_name, len_item_name_to_id)
+                self.assertEqual(len(world_type.item_id_to_name), len(world_type.item_name_to_id))
 
     def test_duplicate_location_ids(self):
         """Test that a game doesn't have location id overlap within its own datapackage"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
-                len_location_id_to_name = len(world_type.location_id_to_name)
-                len_location_name_to_id = len(world_type.location_name_to_id)
-
-                if len_location_id_to_name != len_location_name_to_id:
-                    self.assertCountEqual(
-                        world_type.location_id_to_name.values(), 
-                        world_type.location_name_to_id.keys(),
-                        "\nThese locations have overlapping ids with other locations in its own world")
-                    self.assertCountEqual(
-                        world_type.location_id_to_name.keys(), 
-                        world_type.location_name_to_id.values(),
-                        "\nThese locations have overlapping names with other locations in its own world")
-
-                self.assertEqual(len_location_id_to_name, len_location_name_to_id)
+                self.assertEqual(len(world_type.location_id_to_name), len(world_type.location_name_to_id))
 
     def test_postgen_datapackage(self):
         """Generates a solo multiworld and checks that the datapackage is still valid"""

test/general/test_implemented.py

@@ -39,7 +39,7 @@ class TestImplemented(unittest.TestCase):
         """Tests that if a world creates slot data, it's json serializable."""
         for game_name, world_type in AutoWorldRegister.world_types.items():
             # has an await for generate_output which isn't being called
-            if game_name in {"Ocarina of Time"}:
+            if game_name in {"Ocarina of Time", "Zillion"}:
                 continue
             multiworld = setup_solo_multiworld(world_type)
             with self.subTest(game=game_name, seed=multiworld.seed):
@@ -53,22 +53,6 @@ class TestImplemented(unittest.TestCase):
         if failed_world_loads:
             self.fail(f"The following worlds failed to load: {failed_world_loads}")
 
-    def test_prefill_items(self):
-        """Test that every world can reach every location from allstate before pre_fill."""
-        for gamename, world_type in AutoWorldRegister.world_types.items():
-            if gamename not in ("Archipelago", "Sudoku", "Final Fantasy", "Test Game"):
-                with self.subTest(gamename):
-                    multiworld = setup_solo_multiworld(world_type, ("generate_early", "create_regions", "create_items",
-                                                                    "set_rules", "connect_entrances", "generate_basic"))
-                    allstate = multiworld.get_all_state(False)
-                    locations = multiworld.get_locations()
-                    reachable = multiworld.get_reachable_locations(allstate)
-                    unreachable = [location for location in locations if location not in reachable]
-
-                    self.assertTrue(not unreachable,
-                                    f"Locations were not reachable with all state before prefill: "
-                                    f"{unreachable}. Seed: {multiworld.seed}")
-                    
     def test_explicit_indirect_conditions_spheres(self):
         """Tests that worlds using explicit indirect conditions produce identical spheres as when using implicit
         indirect conditions"""
@@ -133,12 +117,3 @@ class TestImplemented(unittest.TestCase):
                                       f"\nUnexpectedly reachable locations in sphere {sphere_num}:"
                                       f"\n{reachable_only_with_explicit}")
                 self.fail("Unreachable")
-
-    def test_no_items_or_locations_or_regions_submitted_in_init(self):
-        """Test that worlds don't submit items/locations/regions to the multiworld in __init__"""
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Game", game=game_name):
-                multiworld = setup_solo_multiworld(world_type, ())
-                self.assertEqual(len(multiworld.itempool), 0)
-                self.assertEqual(len(multiworld.get_locations()), 0)
-                self.assertEqual(len(multiworld.get_regions()), 0)

test/general/test_items.py

@@ -1,11 +1,6 @@
 import unittest
-from argparse import Namespace
-from typing import Type
 
-from BaseClasses import CollectionState, MultiWorld
-from Fill import distribute_items_restrictive
-from Options import ItemLinks
-from worlds.AutoWorld import AutoWorldRegister, World, call_all
+from worlds.AutoWorld import AutoWorldRegister, call_all
 from . import setup_solo_multiworld
 
 
@@ -13,31 +8,12 @@ class TestBase(unittest.TestCase):
     def test_create_item(self):
         """Test that a world can successfully create all items in its datapackage"""
         for game_name, world_type in AutoWorldRegister.world_types.items():
-            multiworld = setup_solo_multiworld(world_type, steps=("generate_early", "create_regions", "create_items"))
-            proxy_world = multiworld.worlds[1]
+            proxy_world = setup_solo_multiworld(world_type, ()).worlds[1]
             for item_name in world_type.item_name_to_id:
-                test_state = CollectionState(multiworld)
                 with self.subTest("Create Item", item_name=item_name, game_name=game_name):
                     item = proxy_world.create_item(item_name)
-
-                with self.subTest("Item Name", item_name=item_name, game_name=game_name):
                     self.assertEqual(item.name, item_name)
 
-                if item.advancement:
-                    with self.subTest("Item State Collect", item_name=item_name, game_name=game_name):
-                        test_state.collect(item, True)
-
-                    with self.subTest("Item State Remove", item_name=item_name, game_name=game_name):
-                        test_state.remove(item)
-
-                        self.assertEqual(test_state.prog_items, multiworld.state.prog_items,
-                                         "Item Collect -> Remove should restore empty state.")
-                else:
-                    with self.subTest("Item State Collect No Change", item_name=item_name, game_name=game_name):
-                        # Non-Advancement should not modify state.
-                        test_state.collect(item)
-                        self.assertEqual(test_state.prog_items, multiworld.state.prog_items)
-
     def test_item_name_group_has_valid_item(self):
         """Test that all item name groups contain valid items. """
         # This cannot test for Event names that you may have declared for logic, only sendable Items.
@@ -87,52 +63,11 @@ class TestBase(unittest.TestCase):
                 multiworld = setup_solo_multiworld(world_type)
                 for item in multiworld.itempool:
                     self.assertIn(item.name, world_type.item_name_to_id)
-    
-    def test_item_links(self) -> None:
-        """
-        Tests item link creation by creating a multiworld of 2 worlds for every game and linking their items together.
-        """
-        def setup_link_multiworld(world: Type[World], link_replace: bool) -> None:
-            multiworld = MultiWorld(2)
-            multiworld.game = {1: world.game, 2: world.game}
-            multiworld.player_name = {1: "Linker 1", 2: "Linker 2"}
-            multiworld.set_seed()
-            item_link_group = [{
-                "name": "ItemLinkTest",
-                "item_pool": ["Everything"],
-                "link_replacement": link_replace,
-                "replacement_item": None,
-            }]
-            args = Namespace()
-            for name, option in world.options_dataclass.type_hints.items():
-                setattr(args, name, {1: option.from_any(option.default), 2: option.from_any(option.default)})
-            setattr(args, "item_links",
-                    {1: ItemLinks.from_any(item_link_group), 2: ItemLinks.from_any(item_link_group)})
-            multiworld.set_options(args)
-            multiworld.set_item_links()
-            # groups get added to state during its constructor so this has to be after item links are set
-            multiworld.state = CollectionState(multiworld)
-            gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "connect_entrances", "generate_basic")
-            for step in gen_steps:
-                call_all(multiworld, step)
-            # link the items together and attempt to fill
-            multiworld.link_items()
-            multiworld._all_state = None
-            call_all(multiworld, "pre_fill")
-            distribute_items_restrictive(multiworld)
-            call_all(multiworld, "post_fill")
-            self.assertTrue(multiworld.can_beat_game(CollectionState(multiworld)), f"seed = {multiworld.seed}")
-
-        for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Can generate with link replacement", game=game_name):
-                setup_link_multiworld(world_type, True)
-            with self.subTest("Can generate without link replacement", game=game_name):
-                setup_link_multiworld(world_type, False)
 
     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")
-        additional_steps = ("set_rules", "connect_entrances", "generate_basic", "pre_fill")
+        additional_steps = ("set_rules", "generate_basic", "pre_fill")
         excluded_games = ("Links Awakening DX", "Ocarina of Time", "SMZ3")
         worlds_to_test = {game: world
                           for game, world in AutoWorldRegister.world_types.items() if game not in excluded_games}
@@ -149,7 +84,7 @@ class TestBase(unittest.TestCase):
     def test_locality_not_modified(self):
         """Test that worlds don't modify the locality of items after duplicates are resolved"""
         gen_steps = ("generate_early", "create_regions", "create_items")
-        additional_steps = ("set_rules", "connect_entrances", "generate_basic", "pre_fill")
+        additional_steps = ("set_rules", "generate_basic", "pre_fill")
         worlds_to_test = {game: world for game, world in AutoWorldRegister.world_types.items()}
         for game_name, world_type in worlds_to_test.items():
             with self.subTest("Game", game=game_name):

test/general/test_locations.py

@@ -45,12 +45,6 @@ class TestBase(unittest.TestCase):
                 self.assertEqual(location_count, len(multiworld.get_locations()),
                                  f"{game_name} modified locations count during rule creation")
 
-                call_all(multiworld, "connect_entrances")
-                self.assertEqual(region_count, len(multiworld.get_regions()),
-                                 f"{game_name} modified region count during rule creation")
-                self.assertEqual(location_count, len(multiworld.get_locations()),
-                                 f"{game_name} modified locations count during rule creation")
-
                 call_all(multiworld, "generate_basic")
                 self.assertEqual(region_count, len(multiworld.get_regions()),
                                  f"{game_name} modified region count during generate_basic")

test/general/test_memory.py

@@ -1,21 +1,16 @@
 import unittest
 
-from BaseClasses import MultiWorld
 from worlds.AutoWorld import AutoWorldRegister
 from . import setup_solo_multiworld
 
 
 class TestWorldMemory(unittest.TestCase):
-    def test_leak(self) -> None:
+    def test_leak(self):
         """Tests that worlds don't leak references to MultiWorld or themselves with default options."""
         import gc
         import weakref
-        refs: dict[str, weakref.ReferenceType[MultiWorld]] = {}
         for game_name, world_type in AutoWorldRegister.world_types.items():
-            with self.subTest("Game creation", game_name=game_name):
+            with self.subTest("Game", game_name=game_name):
                 weak = weakref.ref(setup_solo_multiworld(world_type))
-                refs[game_name] = weak
-        gc.collect()
-        for game_name, weak in refs.items():
-            with self.subTest("Game cleanup", game_name=game_name):
+                gc.collect()
                 self.assertFalse(weak(), "World leaked a reference")

test/general/test_names.py

@@ -3,7 +3,7 @@ from worlds.AutoWorld import AutoWorldRegister
 
 
 class TestNames(unittest.TestCase):
-    def test_item_names_format(self) -> None:
+    def test_item_names_format(self):
         """Item names must not be all numeric in order to differentiate between ID and name in !hint"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):
@@ -11,7 +11,7 @@ class TestNames(unittest.TestCase):
                     self.assertFalse(item_name.isnumeric(),
                                      f"Item name \"{item_name}\" is invalid. It must not be numeric.")
 
-    def test_location_name_format(self) -> None:
+    def test_location_name_format(self):
         """Location names must not be all numeric in order to differentiate between ID and name in !hint_location"""
         for gamename, world_type in AutoWorldRegister.world_types.items():
             with self.subTest(game=gamename):

test/general/test_packages.py

@@ -1,14 +0,0 @@
-import unittest
-import os
-
-
-class TestPackages(unittest.TestCase):
-    def test_packages_have_init(self):
-        """Test that all world folders containing .py files also have a __init__.py file,
-        to indicate full package rather than namespace package."""
-        import Utils
-
-        worlds_path = Utils.local_path("worlds")
-        for dirpath, dirnames, filenames in os.walk(worlds_path):
-            with self.subTest(directory=dirpath):
-                self.assertEqual("__init__.py" in filenames, any(file.endswith(".py") for file in filenames))