Fix WebHost.py merge conflict

2025-02-01 21:31:59 +00:00 · 2025-02-01 21:31:59 +00:00 · 60c529edc9
parent 04efdf11d7 051518e72a
commit 60c529edc9
1162 changed files with 140562 additions and 43157 deletions
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,2 @@
 worlds/blasphemous/region_data.py linguist-generated=true
 worlds/yachtdice/YachtWeights.py linguist-generated=true
--- a/.github/pyright-config.json
+++ b/.github/pyright-config.json
@ -1,8 +1,20 @@
 {
  "include": [
-    "type_check.py",
+    "../BizHawkClient.py",
    "../Patch.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",
    "../worlds/AutoSNIClient.py",
-    "../Patch.py"
+    "type_check.py"
  ],
  "exclude": [
@ -16,7 +28,7 @@
  "reportMissingImports": true,
  "reportMissingTypeStubs": true,
-  "pythonVersion": "3.8",
+  "pythonVersion": "3.10",
  "pythonPlatform": "Windows",
  "executionEnvironments": [
--- a/.github/workflows/analyze-modified-files.yml
+++ b/.github/workflows/analyze-modified-files.yml
@ -53,7 +53,7 @@ jobs:
      - uses: actions/setup-python@v5
        if: env.diff != ''
        with:
-          python-version: 3.8
+          python-version: '3.10'
      - name: "Install dependencies"
        if: env.diff != ''
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -24,22 +24,28 @@ env:
 jobs:
  # build-release-macos: # LF volunteer
-  build-win-py38: # RCs will still be built and signed by hand
+  build-win: # RCs will still be built and signed by hand
    runs-on: windows-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install python
        uses: actions/setup-python@v5
        with:
-          python-version: '3.8'
+          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"
@ -49,12 +55,6 @@ jobs:
          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: Store 7z
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ZIP_NAME }}
          path: dist/${{ env.ZIP_NAME }}
          retention-days: 7  # keep for 7 days, should be enough
      - name: Build Setup
        run: |
          & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
@ -65,11 +65,38 @@ jobs:
          $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
          $SETUP_NAME=$contents[0].Name
          echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
      - name: Check build loads expected worlds
        shell: bash
        run: |
          cd build/exe*
          mv Players/Templates/meta.yaml .
          ls -1 Players/Templates | sort > setup-player-templates.txt
          rm -R Players/Templates
          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
          ls -1 Players/Templates | sort > generated-player-templates.txt
          cmp setup-player-templates.txt generated-player-templates.txt \
            || diff setup-player-templates.txt generated-player-templates.txt
          mv meta.yaml Players/Templates/
      - name: Test Generate
        shell: bash
        run: |
          cd build/exe*
          cp Players/Templates/Clique.yaml Players/
          timeout 30 ./ArchipelagoGenerate
      - name: Store 7z
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.ZIP_NAME }}
          path: dist/${{ env.ZIP_NAME }}
          compression-level: 0  # .7z is incompressible by zip
          if-no-files-found: error
          retention-days: 7  # keep for 7 days, should be enough
      - name: Store Setup
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.SETUP_NAME }}
          path: setups/${{ env.SETUP_NAME }}
          if-no-files-found: error
          retention-days: 7  # keep for 7 days, should be enough
  build-ubuntu2004:
@ -85,10 +112,11 @@ jobs:
      - name: Get a recent python
        uses: actions/setup-python@v5
        with:
-          python-version: '3.11'
+          python-version: '~3.12.7'
          check-latest: true
      - name: Install build-time dependencies
        run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
          chmod a+rx appimagetool-x86_64.AppImage
          ./appimagetool-x86_64.AppImage --appimage-extract
@ -110,7 +138,7 @@ jobs:
          echo -e "setup.py dist output:\n `ls dist`"
          cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
          export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
-          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
          echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
          echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
      # - copy code above to release.yml -
@ -118,15 +146,36 @@ jobs:
        run: |
          source venv/bin/activate
          python setup.py build_exe --yes
      - name: Check build loads expected worlds
        shell: bash
        run: |
          cd build/exe*
          mv Players/Templates/meta.yaml .
          ls -1 Players/Templates | sort > setup-player-templates.txt
          rm -R Players/Templates
          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
          ls -1 Players/Templates | sort > generated-player-templates.txt
          cmp setup-player-templates.txt generated-player-templates.txt \
            || diff setup-player-templates.txt generated-player-templates.txt
          mv meta.yaml Players/Templates/
      - name: Test Generate
        shell: bash
        run: |
          cd build/exe*
          cp Players/Templates/Clique.yaml Players/
          timeout 30 ./ArchipelagoGenerate
      - name: Store AppImage
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.APPIMAGE_NAME }}
          path: dist/${{ env.APPIMAGE_NAME }}
          if-no-files-found: error
          retention-days: 7
      - name: Store .tar.gz
        uses: actions/upload-artifact@v4
        with:
          name: ${{ env.TAR_NAME }}
          path: dist/${{ env.TAR_NAME }}
          compression-level: 0  # .gz is incompressible by zip
          if-no-files-found: error
          retention-days: 7
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@ -47,7 +47,7 @@ jobs:
    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
      with:
        languages: ${{ matrix.language }}
        # If you wish to specify custom queries, you can do so here or in a config file.
@ -58,7 +58,7 @@ jobs:
    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
+      uses: github/codeql-action/autobuild@v3
    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 https://git.io/JvXDl
@ -72,4 +72,4 @@ jobs:
    #   make release
    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3
--- a/.github/workflows/ctest.yml
+++ b/.github/workflows/ctest.yml
@ -0,0 +1,54 @@
 # Run CMake / CTest C++ unit tests
 name: ctest
 on:
  push:
    paths:
      - '**.cc?'
      - '**.cpp'
      - '**.cxx'
      - '**.hh?'
      - '**.hpp'
      - '**.hxx'
      - '**.CMakeLists'
      - '.github/workflows/ctest.yml'
  pull_request:
    paths:
      - '**.cc?'
      - '**.cpp'
      - '**.cxx'
      - '**.hh?'
      - '**.hpp'
      - '**.hxx'
      - '**.CMakeLists'
      - '.github/workflows/ctest.yml'
 jobs:
  ctest:
    runs-on: ${{ matrix.os }}
    name: Test C++ ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest]
    steps:
    - uses: actions/checkout@v4
    - uses: ilammy/msvc-dev-cmd@v1
      if: startsWith(matrix.os,'windows')
    - uses: Bacondish2023/setup-googletest@v1
      with:
        build-type: 'Release'
    - name: Build tests
      run: |
        cd test/cpp
        mkdir build
        cmake -S . -B build/ -DCMAKE_BUILD_TYPE=Release
        cmake --build build/ --config Release
        ls
    - name: Run tests
      run: |
        cd test/cpp
        ctest --test-dir build/ -C Release --output-on-failure
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -44,10 +44,11 @@ jobs:
      - name: Get a recent python
        uses: actions/setup-python@v5
        with:
-          python-version: '3.11'
+          python-version: '~3.12.7'
          check-latest: true
      - name: Install build-time dependencies
        run: |
-          echo "PYTHON=python3.11" >> $GITHUB_ENV
+          echo "PYTHON=python3.12" >> $GITHUB_ENV
          wget -nv https://github.com/AppImage/AppImageKit/releases/download/$APPIMAGETOOL_VERSION/appimagetool-x86_64.AppImage
          chmod a+rx appimagetool-x86_64.AppImage
          ./appimagetool-x86_64.AppImage --appimage-extract
@ -69,7 +70,7 @@ jobs:
          echo -e "setup.py dist output:\n `ls dist`"
          cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
          export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
-          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
          echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
          echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
      # - code above copied from build.yml -
--- a/.github/workflows/scan-build.yml
+++ b/.github/workflows/scan-build.yml
@ -40,10 +40,10 @@ jobs:
      run: |
        wget https://apt.llvm.org/llvm.sh
        chmod +x ./llvm.sh
-        sudo ./llvm.sh 17
+        sudo ./llvm.sh 19
    - name: Install scan-build command
      run: |
-        sudo apt install clang-tools-17
+        sudo apt install clang-tools-19
    - name: Get a recent python
      uses: actions/setup-python@v5
      with:
@ -56,7 +56,7 @@ jobs:
    - name: scan-build
      run: |
        source venv/bin/activate
-        scan-build-17 --status-bugs -o scan-build-reports -disable-checker deadcode.DeadStores python setup.py build -y
+        scan-build-19 --status-bugs -o scan-build-reports -disable-checker deadcode.DeadStores python setup.py build -y
    - name: Store report
      if: failure()
      uses: actions/upload-artifact@v4
--- a/.github/workflows/strict-type-check.yml
+++ b/.github/workflows/strict-type-check.yml
@ -26,7 +26,7 @@ jobs:
      - name: "Install dependencies"
        run: |
-          python -m pip install --upgrade pip pyright==1.1.358
+          python -m pip install --upgrade pip pyright==1.1.392.post0
          python ModuleUpdate.py --append "WebHostLib/requirements.txt" --force --yes
      - name: "pyright: strict check on specific files"
--- a/.github/workflows/unittests.yml
+++ b/.github/workflows/unittests.yml
@ -33,16 +33,15 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        python:
          - {version: '3.8'}
          - {version: '3.9'}
          - {version: '3.10'}
          - {version: '3.11'}
          - {version: '3.12'}
        include:
-          - python: {version: '3.8'}  # win7 compat
+          - python: {version: '3.10'}  # old compat
            os: windows-latest
-          - python: {version: '3.11'}  # current
+          - python: {version: '3.12'}  # current
            os: windows-latest
-          - python: {version: '3.11'}  # current
+          - python: {version: '3.12'}  # current
            os: macos-latest
    steps:
@ -70,7 +69,7 @@ jobs:
        os:
          - ubuntu-latest
        python:
-          - {version: '3.11'}  # current
+          - {version: '3.12'}  # current
    steps:
    - uses: actions/checkout@v4
@ -88,4 +87,4 @@ jobs:
      run: |
        source venv/bin/activate
        export PYTHONPATH=$(pwd)
-        python test/hosting/__main__.py
+        timeout 600 python test/hosting/__main__.py
--- a/.gitignore
+++ b/.gitignore
@ -150,7 +150,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-.code-workspace
+*.code-workspace
 shell.nix
 # Spyder project settings
@ -178,6 +178,7 @@ dmypy.json
 cython_debug/
 # Cython intermediates
 _speedups.c
 _speedups.cpp
 _speedups.html
--- a/AdventureClient.py
+++ b/AdventureClient.py
@ -112,7 +112,7 @@ class AdventureContext(CommonContext):
            if ': !' not in msg:
                self._set_message(msg, SYSTEM_MESSAGE_ID)
        elif cmd == "ReceivedItems":
-            msg = f"Received {', '.join([self.item_names.lookup_in_slot(item.item) for item in args['items']])}"
+            msg = f"Received {', '.join([self.item_names.lookup_in_game(item.item) for item in args['items']])}"
            self._set_message(msg, SYSTEM_MESSAGE_ID)
        elif cmd == "Retrieved":
            if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
--- a/BaseClasses.py
+++ b/BaseClasses.py
@ -1,37 +1,38 @@
 from __future__ import annotations
-import copy
+import collections
 import itertools
 import functools
 import logging
 import random
 import secrets
 import typing  # this can go away when Python 3.8 support is dropped
 from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, NamedTuple, Optional, Set, Tuple, \
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
-                   TypedDict, Union, Type, ClassVar
+                    Optional, Protocol, Set, Tuple, Union, TYPE_CHECKING)
 from typing_extensions import NotRequired, TypedDict
 import NetUtils
 import Options
 import Utils
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
    from entrance_rando import ERPlacementState
    from worlds import AutoWorld
-class Group(TypedDict, total=False):
+class Group(TypedDict):
    name: str
    game: str
    world: "AutoWorld.World"
-    players: Set[int]
+    players: AbstractSet[int]
-    item_pool: Set[str]
+    item_pool: NotRequired[Set[str]]
-    replacement_items: Dict[int, Optional[str]]
+    replacement_items: NotRequired[Dict[int, Optional[str]]]
-    local_items: Set[str]
+    local_items: NotRequired[Set[str]]
-    non_local_items: Set[str]
+    non_local_items: NotRequired[Set[str]]
-    link_replacement: bool
+    link_replacement: NotRequired[bool]
 class ThreadBarrierProxy:
@ -48,6 +49,11 @@ class ThreadBarrierProxy:
                               "Please use multiworld.per_slot_randoms[player] or randomize ahead of output.")
 class HasNameAndPlayer(Protocol):
    name: str
    player: int
 class MultiWorld():
    debug_types = False
    player_name: Dict[int, str]
@ -63,7 +69,6 @@ class MultiWorld():
    state: CollectionState
    plando_options: PlandoOptions
    accessibility: Dict[int, Options.Accessibility]
    early_items: Dict[int, Dict[str, int]]
    local_early_items: Dict[int, Dict[str, int]]
    local_items: Dict[int, Options.LocalItems]
@ -157,7 +162,7 @@ class MultiWorld():
        self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
        for player in range(1, players + 1):
-            def set_player_attr(attr, val):
+            def set_player_attr(attr: str, val) -> None:
                self.__dict__.setdefault(attr, {})[player] = val
            set_player_attr('plando_items', [])
            set_player_attr('plando_texts', {})
@ -166,13 +171,13 @@ class MultiWorld():
            set_player_attr('completion_condition', lambda state: True)
        self.worlds = {}
        self.per_slot_randoms = Utils.DeprecateDict("Using per_slot_randoms is now deprecated. Please use the "
-                                                      "world's random object instead (usually self.random)")
+                                                    "world's random object instead (usually self.random)")
        self.plando_options = PlandoOptions.none
    def get_all_ids(self) -> Tuple[int, ...]:
        return self.player_ids + tuple(self.groups)
-    def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tuple[int, Group]:
+    def add_group(self, name: str, game: str, players: AbstractSet[int] = frozenset()) -> Tuple[int, Group]:
        """Create a group with name and return the assigned player ID and group.
        If a group of this name already exists, the set of players is extended instead of creating a new one."""
        from worlds import AutoWorld
@ -188,7 +193,9 @@ class MultiWorld():
        self.player_types[new_id] = NetUtils.SlotType.group
        world_type = AutoWorld.AutoWorldRegister.world_types[game]
        self.worlds[new_id] = world_type.create_group(self, new_id, players)
-        self.worlds[new_id].collect_item = classmethod(AutoWorld.World.collect_item).__get__(self.worlds[new_id])
+        self.worlds[new_id].collect_item = AutoWorld.World.collect_item.__get__(self.worlds[new_id])
        self.worlds[new_id].collect = AutoWorld.World.collect.__get__(self.worlds[new_id])
        self.worlds[new_id].remove = AutoWorld.World.remove.__get__(self.worlds[new_id])
        self.player_name[new_id] = name
        new_group = self.groups[new_id] = Group(name=name, game=game, players=players,
@ -196,7 +203,7 @@ class MultiWorld():
        return new_id, new_group
-    def get_player_groups(self, player) -> Set[int]:
+    def get_player_groups(self, player: int) -> Set[int]:
        return {group_id for group_id, group in self.groups.items() if player in group["players"]}
    def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
@ -223,7 +230,7 @@ class MultiWorld():
        for player in self.player_ids:
            world_type = AutoWorld.AutoWorldRegister.world_types[self.game[player]]
            self.worlds[player] = world_type(self, player)
-            options_dataclass: typing.Type[Options.PerGameCommonOptions] = world_type.options_dataclass
+            options_dataclass: type[Options.PerGameCommonOptions] = world_type.options_dataclass
            self.worlds[player].options = options_dataclass(**{option_key: getattr(args, option_key)[player]
                                                               for option_key in options_dataclass.type_hints})
@ -259,7 +266,7 @@ class MultiWorld():
                        "link_replacement": replacement_prio.index(item_link["link_replacement"]),
                    }
-        for name, item_link in item_links.items():
+        for _name, item_link in item_links.items():
            current_item_name_groups = AutoWorld.AutoWorldRegister.world_types[item_link["game"]].item_name_groups
            pool = set()
            local_items = set()
@ -288,6 +295,88 @@ class MultiWorld():
            group["non_local_items"] = item_link["non_local_items"]
            group["link_replacement"] = replacement_prio[item_link["link_replacement"]]
    def link_items(self) -> None:
        """Called to link together items in the itempool related to the registered item link groups."""
        from worlds import AutoWorld
        for group_id, group in self.groups.items():
            def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
                Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
            ]:
                classifications: Dict[str, int] = collections.defaultdict(int)
                counters = {player: {name: 0 for name in shared_pool} for player in players}
                for item in self.itempool:
                    if item.player in counters and item.name in shared_pool:
                        counters[item.player][item.name] += 1
                        classifications[item.name] |= item.classification
                for player in players.copy():
                    if all([counters[player][item] == 0 for item in shared_pool]):
                        players.remove(player)
                        del (counters[player])
                if not players:
                    return None, None
                for item in shared_pool:
                    count = min(counters[player][item] for player in players)
                    if count:
                        for player in players:
                            counters[player][item] = count
                    else:
                        for player in players:
                            del (counters[player][item])
                return counters, classifications
            common_item_count, classifications = find_common_pool(group["players"], group["item_pool"])
            if not common_item_count:
                continue
            new_itempool: List[Item] = []
            for item_name, item_count in next(iter(common_item_count.values())).items():
                for _ in range(item_count):
                    new_item = group["world"].create_item(item_name)
                    # mangle together all original classification bits
                    new_item.classification |= classifications[item_name]
                    new_itempool.append(new_item)
            region = Region(group["world"].origin_region_name, group_id, self, "ItemLink")
            self.regions.append(region)
            locations = region.locations
            # ensure that progression items are linked first, then non-progression
            self.itempool.sort(key=lambda item: item.advancement)
            for item in self.itempool:
                count = common_item_count.get(item.player, {}).get(item.name, 0)
                if count:
                    loc = Location(group_id, f"Item Link: {item.name} -> {self.player_name[item.player]} {count}",
                        None, region)
                    loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                        state.has(item_name, group_id_, count_)
                    locations.append(loc)
                    loc.place_locked_item(item)
                    common_item_count[item.player][item.name] -= 1
                else:
                    new_itempool.append(item)
            itemcount = len(self.itempool)
            self.itempool = new_itempool
            while itemcount > len(self.itempool):
                items_to_add = []
                for player in group["players"]:
                    if group["link_replacement"]:
                        item_player = group_id
                    else:
                        item_player = player
                    if group["replacement_items"][player]:
                        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))
                self.random.shuffle(items_to_add)
                self.itempool.extend(items_to_add[:itemcount - len(self.itempool)])
    def secure(self):
        self.random = ThreadBarrierProxy(secrets.SystemRandom())
        self.is_race = True
@ -309,7 +398,7 @@ class MultiWorld():
        return tuple(world for player, world in self.worlds.items() if
                     player not in self.groups and self.game[player] == game_name)
-    def get_name_string_for_object(self, obj) -> str:
+    def get_name_string_for_object(self, obj: HasNameAndPlayer) -> str:
        return obj.name if self.players == 1 else f'{obj.name} ({self.get_player_name(obj.player)})'
    def get_player_name(self, player: int) -> str:
@ -338,12 +427,12 @@ 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) -> 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()
-        ret = CollectionState(self)
+        ret = CollectionState(self, allow_partial_entrances)
        for item in self.itempool:
            self.worlds[item.player].collect(ret, item)
@ -351,7 +440,7 @@ class MultiWorld():
            subworld = self.worlds[player]
            for item in subworld.get_pre_fill_items():
                subworld.collect(ret, item)
-        ret.sweep_for_events()
+        ret.sweep_for_advancements()
        if use_cache:
            self._all_state = ret
@ -360,7 +449,7 @@ class MultiWorld():
    def get_items(self) -> List[Item]:
        return [loc.item for loc in self.get_filled_locations()] + self.itempool
-    def find_item_locations(self, item, player: int, resolve_group_locations: bool = False) -> List[Location]:
+    def find_item_locations(self, item: str, player: int, resolve_group_locations: bool = False) -> List[Location]:
        if resolve_group_locations:
            player_groups = self.get_player_groups(player)
            return [location for location in self.get_locations() if
@ -369,7 +458,7 @@ class MultiWorld():
        return [location for location in self.get_locations() if
                location.item and location.item.name == item and location.item.player == player]
-    def find_item(self, item, player: int) -> Location:
+    def find_item(self, item: str, player: int) -> Location:
        return next(location for location in self.get_locations() if
                    location.item and location.item.name == item and location.item.player == player)
@ -462,9 +551,9 @@ class MultiWorld():
                return True
            state = starting_state.copy()
        else:
            if self.has_beaten_game(self.state):
                return True
            state = CollectionState(self)
            if self.has_beaten_game(state):
                return True
        prog_locations = {location for location in self.get_locations() if location.item
                          and location.item.advancement and location not in state.locations_checked}
@ -516,6 +605,49 @@ class MultiWorld():
                state.collect(location.item, True, location)
            locations -= sphere
    def get_sendable_spheres(self) -> Iterator[Set[Location]]:
        """
        yields a set of multiserver sendable locations (location.item.code: int) for each logical sphere
        If there are unreachable locations, the last sphere of reachable locations is followed by an empty set,
        and then a set of all of the unreachable locations.
        """
        state = CollectionState(self)
        locations: Set[Location] = set()
        events: Set[Location] = set()
        for location in self.get_filled_locations():
            if type(location.item.code) is int:
                locations.add(location)
            else:
                events.add(location)
        while locations:
            sphere: Set[Location] = set()
            # cull events out
            done_events: Set[Union[Location, None]] = {None}
            while done_events:
                done_events = set()
                for event in events:
                    if event.can_reach(state):
                        state.collect(event.item, True, event)
                        done_events.add(event)
                events -= done_events
            for location in locations:
                if location.can_reach(state):
                    sphere.add(location)
            yield sphere
            if not sphere:
                if locations:
                    yield locations  # unreachable locations
                break
            for location in sphere:
                state.collect(location.item, True, location)
            locations -= sphere
    def fulfills_accessibility(self, state: Optional[CollectionState] = None):
        """Check if accessibility rules are fulfilled with current or supplied state."""
        if not state:
@ -523,26 +655,21 @@ class MultiWorld():
        players: Dict[str, Set[int]] = {
            "minimal": set(),
            "items": set(),
-            "locations": set()
+            "full": set()
        }
-        for player, access in self.accessibility.items():
+        for player, world in self.worlds.items():
-            players[access.current_key].add(player)
+            players[world.options.accessibility.current_key].add(player)
        beatable_fulfilled = False
-        def location_condition(location: Location):
+        def location_condition(location: Location) -> bool:
            """Determine if this location has to be accessible, location is already filtered by location_relevant"""
-            if location.player in players["locations"] or (location.item and location.item.player not in
+            return location.player in players["full"] or \
-                                                           players["minimal"]):
+                (location.item and location.item.player not in players["minimal"])
                return True
            return False
-        def location_relevant(location: Location):
+        def location_relevant(location: Location) -> bool:
            """Determine if this location is relevant to sweep."""
-            if location.progress_type != LocationProgressType.EXCLUDED \
+            return location.player in players["full"] or location.advancement
               and (location.player in players["locations"] or location.advancement):
                return True
            return False
        def all_done() -> bool:
            """Check if all access rules are fulfilled"""
@ -587,22 +714,24 @@ class CollectionState():
    multiworld: MultiWorld
    reachable_regions: Dict[int, Set[Region]]
    blocked_connections: Dict[int, Set[Entrance]]
-    events: Set[Location]
+    advancements: Set[Location]
    path: Dict[Union[Region, Entrance], PathValue]
    locations_checked: Set[Location]
    stale: Dict[int, bool]
    allow_partial_entrances: bool
    additional_init_functions: List[Callable[[CollectionState, MultiWorld], None]] = []
    additional_copy_functions: List[Callable[[CollectionState, CollectionState], CollectionState]] = []
-    def __init__(self, parent: MultiWorld):
+    def __init__(self, parent: MultiWorld, allow_partial_entrances: bool = False):
        self.prog_items = {player: Counter() for player in parent.get_all_ids()}
        self.multiworld = parent
        self.reachable_regions = {player: set() for player in parent.get_all_ids()}
        self.blocked_connections = {player: set() for player in parent.get_all_ids()}
-        self.events = set()
+        self.advancements = set()
        self.path = {}
        self.locations_checked = set()
        self.stale = {player: True for player in parent.get_all_ids()}
        self.allow_partial_entrances = allow_partial_entrances
        for function in self.additional_init_functions:
            function(self, parent)
        for items in parent.precollected_items.values():
@ -611,17 +740,25 @@ class CollectionState():
    def update_reachable_regions(self, player: int):
        self.stale[player] = False
        world: AutoWorld.World = self.multiworld.worlds[player]
        reachable_regions = self.reachable_regions[player]
        blocked_connections = self.blocked_connections[player]
        queue = deque(self.blocked_connections[player])
-        start = self.multiworld.get_region("Menu", player)
+        start: Region = world.get_region(world.origin_region_name)
        # init on first call - this can't be done on construction since the regions don't exist yet
        if start not in reachable_regions:
            reachable_regions.add(start)
-            blocked_connections.update(start.exits)
+            self.blocked_connections[player].update(start.exits)
            queue.extend(start.exits)
        if world.explicit_indirect_conditions:
            self._update_reachable_regions_explicit_indirect_conditions(player, queue)
        else:
            self._update_reachable_regions_auto_indirect_conditions(player, queue)
    def _update_reachable_regions_explicit_indirect_conditions(self, player: int, queue: deque):
        reachable_regions = self.reachable_regions[player]
        blocked_connections = self.blocked_connections[player]
        # run BFS on all connections, and keep track of those blocked by missing items
        while queue:
            connection = queue.popleft()
@ -629,7 +766,9 @@ class CollectionState():
            if new_region in reachable_regions:
                blocked_connections.remove(connection)
            elif connection.can_reach(self):
-                assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
+                if self.allow_partial_entrances and not new_region:
                    continue
                assert new_region, f"tried to search through an Entrance \"{connection}\" with no connected Region"
                reachable_regions.add(new_region)
                blocked_connections.remove(connection)
                blocked_connections.update(new_region.exits)
@ -641,16 +780,42 @@ class CollectionState():
                    if new_entrance in blocked_connections and new_entrance not in queue:
                        queue.append(new_entrance)
    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque):
        reachable_regions = self.reachable_regions[player]
        blocked_connections = self.blocked_connections[player]
        new_connection: bool = True
        # run BFS on all connections, and keep track of those blocked by missing items
        while new_connection:
            new_connection = False
            while queue:
                connection = queue.popleft()
                new_region = connection.connected_region
                if new_region in reachable_regions:
                    blocked_connections.remove(connection)
                elif connection.can_reach(self):
                    if self.allow_partial_entrances and not new_region:
                        continue
                    assert new_region, f"tried to search through an Entrance \"{connection}\" with no connected Region"
                    reachable_regions.add(new_region)
                    blocked_connections.remove(connection)
                    blocked_connections.update(new_region.exits)
                    queue.extend(new_region.exits)
                    self.path[new_region] = (new_region.name, self.path.get(connection, None))
                    new_connection = True
            # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
            queue.extend(blocked_connections)
    def copy(self) -> CollectionState:
        ret = CollectionState(self.multiworld)
-        ret.prog_items = copy.deepcopy(self.prog_items)
+        ret.prog_items = {player: counter.copy() for player, counter in self.prog_items.items()}
-        ret.reachable_regions = {player: copy.copy(self.reachable_regions[player]) for player in
+        ret.reachable_regions = {player: region_set.copy() for player, region_set in
-                                 self.reachable_regions}
+                                 self.reachable_regions.items()}
-        ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in
+        ret.blocked_connections = {player: entrance_set.copy() for player, entrance_set in
-                                   self.blocked_connections}
+                                   self.blocked_connections.items()}
-        ret.events = copy.copy(self.events)
+        ret.advancements = self.advancements.copy()
-        ret.path = copy.copy(self.path)
+        ret.path = self.path.copy()
-        ret.locations_checked = copy.copy(self.locations_checked)
+        ret.locations_checked = self.locations_checked.copy()
        ret.allow_partial_entrances = self.allow_partial_entrances
        for function in self.additional_copy_functions:
            ret = function(self, ret)
        return ret
@ -680,20 +845,25 @@ class CollectionState():
    def can_reach_region(self, spot: str, player: int) -> bool:
        return self.multiworld.get_region(spot, player).can_reach(self)
-    def sweep_for_events(self, key_only: bool = False, locations: Optional[Iterable[Location]] = None) -> None:
+    def sweep_for_events(self, locations: Optional[Iterable[Location]] = None) -> None:
        Utils.deprecate("sweep_for_events has been renamed to sweep_for_advancements. The functionality is the same. "
                        "Please switch over to sweep_for_advancements.")
        return self.sweep_for_advancements(locations)
    def sweep_for_advancements(self, locations: Optional[Iterable[Location]] = None) -> None:
        if locations is None:
            locations = self.multiworld.get_filled_locations()
-        reachable_events = True
+        reachable_advancements = True
-        # since the loop has a good chance to run more than once, only filter the events once
+        # since the loop has a good chance to run more than once, only filter the advancements once
-        locations = {location for location in locations if location.advancement and location not in self.events and
+        locations = {location for location in locations if location.advancement and location not in self.advancements}
-                     not key_only or getattr(location.item, "locked_dungeon_item", False)}
+
-        while reachable_events:
+        while reachable_advancements:
-            reachable_events = {location for location in locations if location.can_reach(self)}
+            reachable_advancements = {location for location in locations if location.can_reach(self)}
-            locations -= reachable_events
+            locations -= reachable_advancements
-            for event in reachable_events:
+            for advancement in reachable_advancements:
-                self.events.add(event)
+                self.advancements.add(advancement)
-                assert isinstance(event.item, Item), "tried to collect Event with no Item"
+                assert isinstance(advancement.item, Item), "tried to collect Event with no Item"
-                self.collect(event.item, True, event)
+                self.collect(advancement.item, True, advancement)
    # item name related
    def has(self, item: str, player: int, count: int = 1) -> bool:
@ -788,20 +958,16 @@ class CollectionState():
        )
    # Item related
-    def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
+    def collect(self, item: Item, prevent_sweep: bool = False, location: Optional[Location] = None) -> bool:
        if location:
            self.locations_checked.add(location)
        changed = self.multiworld.worlds[item.player].collect(self, item)
        if not changed and event:
            self.prog_items[item.player][item.name] += 1
            changed = True
        self.stale[item.player] = True
-        if changed and not event:
+        if changed and not prevent_sweep:
-            self.sweep_for_events()
+            self.sweep_for_advancements()
        return changed
@ -814,6 +980,11 @@ class CollectionState():
            self.stale[item.player] = True
 class EntranceType(IntEnum):
    ONE_WAY = 1
    TWO_WAY = 2
 class Entrance:
    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
    hide_path: bool = False
@ -821,18 +992,24 @@ class Entrance:
    name: str
    parent_region: Optional[Region]
    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: Region = None):
+    def __init__(self, player: int, name: str = "", parent: Optional[Region] = None,
                 randomization_group: int = 0, randomization_type: EntranceType = EntranceType.ONE_WAY) -> None:
        self.name = name
        self.parent_region = parent
        self.player = player
        self.randomization_group = randomization_group
        self.randomization_type = randomization_type
    def can_reach(self, state: CollectionState) -> bool:
        assert self.parent_region, f"called can_reach on an Entrance \"{self}\" with no parent_region"
        if self.parent_region.can_reach(state) and self.access_rule(state):
-            if not self.hide_path and not self in state.path:
+            if not self.hide_path and self not in state.path:
                state.path[self] = (self.name, state.path.get(self.parent_region, (self.parent_region.name, None)))
            return True
@ -844,10 +1021,33 @@ class Entrance:
        self.addresses = addresses
        region.entrances.append(self)
-    def __repr__(self):
+    def is_valid_source_transition(self, er_state: "ERPlacementState") -> bool:
-        return self.__str__()
+        """
        Determines whether this is a valid source transition, that is, whether the entrance
        randomizer is allowed to pair it to place any other regions. By default, this is the
        same as a reachability check, but can be modified by Entrance implementations to add
        other restrictions based on the placement state.
-    def __str__(self):
+        :param er_state: The current (partial) state of the ongoing entrance randomization
        """
        return self.can_reach(er_state.collection_state)
    def can_connect_to(self, other: Entrance, dead_end: bool, er_state: "ERPlacementState") -> bool:
        """
        Determines whether a given Entrance is a valid target transition, that is, whether
        the entrance randomizer is allowed to pair this Entrance to that Entrance. By default,
        only allows connection between entrances of the same type (one ways only go to one ways,
        two ways always go to two ways) and prevents connecting an exit to itself in coupled mode.
        :param other: The proposed Entrance to connect to
        :param dead_end: Whether the other entrance considered a dead end by Entrance randomization
        :param er_state: The current (partial) state of the ongoing entrance randomization
        """
        # the implementation of coupled causes issues for self-loops since the reverse entrance will be the
        # same as the forward entrance. In uncoupled they are ok.
        return self.randomization_type == other.randomization_type and (not er_state.coupled or self.name != other.name)
    def __repr__(self):
        multiworld = self.parent_region.multiworld if self.parent_region else None
        return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
@ -860,7 +1060,7 @@ class Region:
    entrances: List[Entrance]
    exits: List[Entrance]
    locations: List[Location]
-    entrance_type: ClassVar[Type[Entrance]] = Entrance
+    entrance_type: ClassVar[type[Entrance]] = Entrance
    class Register(MutableSequence):
        region_manager: MultiWorld.RegionManager
@ -960,7 +1160,7 @@ class Region:
            return entrance.parent_region.get_connecting_entrance(is_main_entrance)
    def add_locations(self, locations: Dict[str, Optional[int]],
-                      location_type: Optional[Type[Location]] = None) -> None:
+                      location_type: Optional[type[Location]] = None) -> None:
        """
        Adds locations to the Region object, where location_type is your Location class and locations is a dict of
        location names to address.
@ -973,7 +1173,7 @@ class Region:
            self.locations.append(location_type(self.player, location, address, self))
    def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[Callable[[CollectionState], bool]] = None) -> entrance_type:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
        """
        Connects this Region to another Region, placing the provided rule on the connection.
@ -996,8 +1196,18 @@ class Region:
        self.exits.append(exit_)
        return exit_
    def create_er_target(self, name: str) -> Entrance:
        """
        Creates and returns an Entrance object as an entrance to this region
        :param name: name of the Entrance being created
        """
        entrance = self.entrance_type(self.player, name)
        entrance.connect(self)
        return entrance
    def add_exits(self, exits: Union[Iterable[str], Dict[str, Optional[str]]],
-                  rules: Dict[str, Callable[[CollectionState], bool]] = None) -> None:
+                  rules: Dict[str, Callable[[CollectionState], bool]] = None) -> List[Entrance]:
        """
        Connects current region to regions in exit dictionary. Passed region names must exist first.
@ -1007,15 +1217,16 @@ class Region:
        """
        if not isinstance(exits, Dict):
            exits = dict.fromkeys(exits)
-        for connecting_region, name in exits.items():
+        return [
-            self.connect(self.multiworld.get_region(connecting_region, self.player),
+            self.connect(
-                         name,
+                self.multiworld.get_region(connecting_region, self.player),
-                         rules[connecting_region] if rules and connecting_region in rules else None)
+                name,
                rules[connecting_region] if rules and connecting_region in rules else None,
            )
            for connecting_region, name in exits.items()
        ]
    def __repr__(self):
        return self.__str__()
    def __str__(self):
        return self.multiworld.get_name_string_for_object(self) if self.multiworld else f'{self.name} (Player {self.player})'
@ -1034,9 +1245,9 @@ class Location:
    locked: bool = False
    show_in_spoiler: bool = True
    progress_type: LocationProgressType = LocationProgressType.DEFAULT
-    always_allow = staticmethod(lambda state, item: False)
+    always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
    access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
-    item_rule = staticmethod(lambda item: True)
+    item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
    item: Optional[Item] = None
    def __init__(self, player: int, name: str = '', address: Optional[int] = None, parent: Optional[Region] = None):
@ -1045,16 +1256,20 @@ class Location:
        self.address = address
        self.parent_region = parent
-    def can_fill(self, state: CollectionState, item: Item, check_access=True) -> bool:
+    def can_fill(self, state: CollectionState, item: Item, check_access: bool = True) -> bool:
-        return ((self.always_allow(state, item) and item.name not in state.multiworld.worlds[item.player].options.non_local_items)
+        return ((
-                or ((self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
+            self.always_allow(state, item)
-                    and self.item_rule(item)
+            and item.name not in state.multiworld.worlds[item.player].options.non_local_items
-                    and (not check_access or self.can_reach(state))))
+        ) or (
            (self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
            and self.item_rule(item)
            and (not check_access or self.can_reach(state))
        ))
    def can_reach(self, state: CollectionState) -> bool:
-        # self.access_rule computes faster on average, so placing it first for faster abort
+        # Region.can_reach is just a cache lookup, so placing it first for faster abort on average
-        assert self.parent_region, "Can't reach location without region"
+        assert self.parent_region, f"called can_reach on a Location \"{self}\" with no parent_region"
-        return self.access_rule(state) and self.parent_region.can_reach(state)
+        return self.parent_region.can_reach(state) and self.access_rule(state)
    def place_locked_item(self, item: Item):
        if self.item:
@ -1064,9 +1279,6 @@ class Location:
        self.locked = True
    def __repr__(self):
        return self.__str__()
    def __str__(self):
        multiworld = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
        return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
@ -1088,7 +1300,7 @@ class Location:
    @property
    def native_item(self) -> bool:
        """Returns True if the item in this location matches game."""
-        return self.item and self.item.game == self.game
+        return self.item is not None and self.item.game == self.game
    @property
    def hint_text(self) -> str:
@ -1096,13 +1308,26 @@ class Location:
 class ItemClassification(IntFlag):
-    filler = 0b0000  # aka trash, as in filler items like ammo, currency etc,
+    filler = 0b0000
-    progression = 0b0001  # Item that is logically relevant
+    """ aka trash, as in filler items like ammo, currency etc """
-    useful = 0b0010  # Item that is generally quite useful, but not required for anything logical
+
-    trap = 0b0100  # detrimental or entirely useless (nothing) item
+    progression = 0b0001
-    skip_balancing = 0b1000  # should technically never occur on its own
+    """ Item that is logically relevant.
-    # Item that is logically relevant, but progression balancing should not touch.
+    Protects this item from being placed on excluded or unreachable locations. """
-    # Typically currency or other counted items.
+
    useful = 0b0010
    """ Item that is especially useful.
    Protects this item from being placed on excluded or unreachable locations.
    When combined with another flag like "progression", it means "an especially useful progression item". """
    trap = 0b0100
    """ Item that is detrimental in some way. """
    skip_balancing = 0b1000
    """ should technically never occur on its own
    Item that is logically relevant, but progression balancing should not touch.
    Typically currency or other counted items. """
    progression_skip_balancing = 0b1001  # only progression gets balanced
    def as_flag(self) -> int:
@ -1151,6 +1376,14 @@ class Item:
    def trap(self) -> bool:
        return ItemClassification.trap in self.classification
    @property
    def filler(self) -> bool:
        return not (self.advancement or self.useful or self.trap)
    @property
    def excludable(self) -> bool:
        return not (self.advancement or self.useful)
    @property
    def flags(self) -> int:
        return self.classification.as_flag()
@ -1171,9 +1404,6 @@ class Item:
        return hash((self.name, self.player))
    def __repr__(self) -> str:
        return self.__str__()
    def __str__(self) -> str:
        if self.location and self.location.parent_region and self.location.parent_region.multiworld:
            return self.location.parent_region.multiworld.get_name_string_for_object(self)
        return f"{self.name} (Player {self.player})"
@ -1251,9 +1481,9 @@ class Spoiler:
        # in the second phase, we cull each sphere such that the game is still beatable,
        # reducing each range of influence to the bare minimum required inside it
-        restore_later = {}
+        restore_later: Dict[Location, Item] = {}
        for num, sphere in reversed(tuple(enumerate(collection_spheres))):
-            to_delete = set()
+            to_delete: Set[Location] = set()
            for location in sphere:
                # we remove the item at location and check if game is still beatable
                logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name,
@ -1271,15 +1501,22 @@ class Spoiler:
            sphere -= to_delete
        # second phase, sphere 0
-        removed_precollected = []
+        removed_precollected: List[Item] = []
-        for item in (i for i in chain.from_iterable(multiworld.precollected_items.values()) if i.advancement):
+
-            logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
+        for precollected_items in multiworld.precollected_items.values():
-            multiworld.precollected_items[item.player].remove(item)
+            # The list of items is mutated by removing one item at a time to determine if each item is required to beat
-            multiworld.state.remove(item)
+            # the game, and re-adding that item if it was required, so a copy needs to be made before iterating.
-            if not multiworld.can_beat_game():
+            for item in precollected_items.copy():
-                multiworld.push_precollected(item)
+                if not item.advancement:
-            else:
+                    continue
-                removed_precollected.append(item)
+                logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
                precollected_items.remove(item)
                multiworld.state.remove(item)
                if not multiworld.can_beat_game():
                    # Add the item back into `precollected_items` and collect it into `multiworld.state`.
                    multiworld.push_precollected(item)
                else:
                    removed_precollected.append(item)
        # we are now down to just the required progress items in collection_spheres. Unfortunately
        # the previous pruning stage could potentially have made certain items dependant on others
@ -1291,8 +1528,6 @@ class Spoiler:
        state = CollectionState(multiworld)
        collection_spheres = []
        while required_locations:
            state.sweep_for_events(key_only=True)
            sphere = set(filter(state.can_reach, required_locations))
            for location in sphere:
@ -1354,7 +1589,7 @@ class Spoiler:
                # Maybe move the big bomb over to the Event system instead?
                if any(exit_path == 'Pyramid Fairy' for path in self.paths.values()
                       for (_, exit_path) in path):
-                    if multiworld.mode[player] != 'inverted':
+                    if multiworld.worlds[player].options.mode != 'inverted':
                        self.paths[str(multiworld.get_region('Big Bomb Shop', player))] = \
                            get_path(state, multiworld.get_region('Big Bomb Shop', player))
                    else:
@ -1420,15 +1655,15 @@ class Spoiler:
                [f"  {location}: {item}" for (location, item) in sphere.items()] if isinstance(sphere, dict) else
                [f"  {item}" for item in sphere])) for (sphere_nr, sphere) in self.playthrough.items()]))
            if self.unreachables:
-                outfile.write('\n\nUnreachable Items:\n\n')
+                outfile.write('\n\nUnreachable Progression Items:\n\n')
                outfile.write(
                    '\n'.join(['%s: %s' % (unreachable.item, unreachable) for unreachable in self.unreachables]))
            if self.paths:
                outfile.write('\n\nPaths:\n\n')
-                path_listings = []
+                path_listings: List[str] = []
                for location, path in sorted(self.paths.items()):
-                    path_lines = []
+                    path_lines: List[str] = []
                    for region, exit in path:
                        if exit is not None:
                            path_lines.append("{} -> {}".format(region, exit))
--- a/BizHawkClient.py
+++ b/BizHawkClient.py
@ -1,9 +1,10 @@
 from __future__ import annotations
 import sys
 import ModuleUpdate
 ModuleUpdate.update()
 from worlds._bizhawk.context import launch
 if __name__ == "__main__":
-    launch()
+    launch(*sys.argv[1:])
--- a/CommonClient.py
+++ b/CommonClient.py
@ -23,7 +23,7 @@ if __name__ == "__main__":
 from MultiServer import CommandProcessor
 from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, HintStatus, SlotType)
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
@ -31,6 +31,7 @@ import ssl
 if typing.TYPE_CHECKING:
    import kvui
    import argparse
 logger = logging.getLogger("Client")
@ -45,10 +46,21 @@ def get_ssl_context():
 class ClientCommandProcessor(CommandProcessor):
    """
    The Command Processor will parse every method of the class that starts with "_cmd_" as a command to be called
    when parsing user input, i.e. _cmd_exit will be called when the user sends the command "/exit".
    The decorator @mark_raw can be imported from MultiServer and tells the parser to only split on the first
    space after the command i.e. "/exit one two three" will be passed in as method("one two three") with mark_raw
    and method("one", "two", "three") without.
    In addition all docstrings for command methods will be displayed to the user on launch and when using "/help"
    """
    def __init__(self, ctx: CommonContext):
        self.ctx = ctx
    def output(self, text: str):
        """Helper function to abstract logging to the CommonClient UI"""
        logger.info(text)
    def _cmd_exit(self) -> bool:
@ -61,6 +73,7 @@ class ClientCommandProcessor(CommandProcessor):
        if address:
            self.ctx.server_address = None
            self.ctx.username = None
            self.ctx.password = None
        elif not self.ctx.server_address:
            self.output("Please specify an address.")
            return False
@ -163,13 +176,14 @@ class ClientCommandProcessor(CommandProcessor):
        async_start(self.ctx.send_msgs([{"cmd": "StatusUpdate", "status": state}]), name="send StatusUpdate")
    def default(self, raw: str):
        """The default message parser to be used when parsing any messages that do not match a command"""
        raw = self.ctx.on_user_say(raw)
        if raw:
            async_start(self.ctx.send_msgs([{"cmd": "Say", "text": raw}]), name="send Say")
 class CommonContext:
-    # Should be adjusted as needed in subclasses
+    # The following attributes are used to Connect and should be adjusted as needed in subclasses
    tags: typing.Set[str] = {"AP"}
    game: typing.Optional[str] = None
    items_handling: typing.Optional[int] = None
@ -225,6 +239,9 @@ class CommonContext:
        def lookup_in_slot(self, code: int, slot: typing.Optional[int] = None) -> str:
            """Returns the name for an item/location id in the context of a specific slot or own slot if `slot` is
            omitted.
            Use of `lookup_in_slot` should not be used when not connected to a server. If looking in own game, set
            `ctx.game` and use `lookup_in_game` method instead.
            """
            if slot is None:
                slot = self.ctx.slot
@ -248,7 +265,7 @@ class CommonContext:
    starting_reconnect_delay: int = 5
    current_reconnect_delay: int = starting_reconnect_delay
    command_processor: typing.Type[CommandProcessor] = ClientCommandProcessor
-    ui = None
+    ui: typing.Optional["kvui.GameManager"] = None
    ui_task: typing.Optional["asyncio.Task[None]"] = None
    input_task: typing.Optional["asyncio.Task[None]"] = None
    keep_alive_task: typing.Optional["asyncio.Task[None]"] = None
@ -339,6 +356,8 @@ class CommonContext:
        self.item_names = self.NameLookupDict(self, "item")
        self.location_names = self.NameLookupDict(self, "location")
        self.versions = {}
        self.checksums = {}
        self.jsontotextparser = JSONtoTextParser(self)
        self.rawjsontotextparser = RawJSONtoTextParser(self)
@ -394,6 +413,7 @@ class CommonContext:
            await self.server.socket.close()
        if self.server_task is not None:
            await self.server_task
        self.ui.update_hints()
    async def send_msgs(self, msgs: typing.List[typing.Any]) -> None:
        """ `msgs` JSON serializable """
@ -425,7 +445,10 @@ class CommonContext:
                self.auth = await self.console_input()
    async def send_connect(self, **kwargs: typing.Any) -> None:
-        """ send `Connect` packet to log in to server """
+        """
        Send a `Connect` packet to log in to the server,
        additional keyword args can override any value in the connection packet
        """
        payload = {
            'cmd': 'Connect',
            'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
@ -435,6 +458,14 @@ class CommonContext:
        if kwargs:
            payload.update(kwargs)
        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:
@ -455,6 +486,7 @@ class CommonContext:
        return False
    def slot_concerns_self(self, slot) -> bool:
        """Helper function to abstract player groups, should be used instead of checking slot == self.slot directly."""
        if slot == self.slot:
            return True
        if slot in self.slot_info:
@ -462,6 +494,7 @@ class CommonContext:
        return False
    def is_echoed_chat(self, print_json_packet: dict) -> bool:
        """Helper function for filtering out messages sent by self."""
        return print_json_packet.get("type", "") == "Chat" \
            and print_json_packet.get("team", None) == self.team \
            and print_json_packet.get("slot", None) == self.slot
@ -500,6 +533,7 @@ class CommonContext:
        self.ui.print_json([{"text": text, "type": "color", "color": "orange"}])
    def update_permissions(self, permissions: typing.Dict[str, int]):
        """Internal method to parse and save server permissions from RoomInfo"""
        for permission_name, permission_flag in permissions.items():
            try:
                flag = Permission(permission_flag)
@ -511,6 +545,7 @@ class CommonContext:
    async def shutdown(self):
        self.server_address = ""
        self.username = None
        self.password = None
        self.cancel_autoreconnect()
        if self.server and not self.server.socket.closed:
            await self.server.socket.close()
@ -526,6 +561,13 @@ class CommonContext:
        if self.input_task:
            self.input_task.cancel()
    # Hints
    def update_hint(self, location: int, finding_player: int, status: typing.Optional[HintStatus]) -> None:
        msg = {"cmd": "UpdateHint", "location": location, "player": finding_player}
        if status is not None:
            msg["status"] = status
        async_start(self.send_msgs([msg]), name="update_hint")
    # DataPackage
    async def prepare_data_package(self, relevant_games: typing.Set[str],
                                   remote_date_package_versions: typing.Dict[str, int],
@ -547,26 +589,34 @@ class CommonContext:
                needed_updates.add(game)
                continue
-            local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
+            cached_version: int = self.versions.get(game, 0)
-            local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
+            cached_checksum: typing.Optional[str] = self.checksums.get(game)
-            # no action required if local version is new enough
+            # no action required if cached version is new enough
-            if (not remote_checksum and (remote_version > local_version or remote_version == 0)) \
+            if (not remote_checksum and (remote_version > cached_version or remote_version == 0)) \
-                    or remote_checksum != local_checksum:
+                    or remote_checksum != cached_checksum:
-                cached_game = Utils.load_data_package_for_checksum(game, remote_checksum)
+                local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
-                cache_version: int = cached_game.get("version", 0)
+                local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
-                cache_checksum: typing.Optional[str] = cached_game.get("checksum")
+                if ((remote_checksum or remote_version <= local_version and remote_version != 0)
-                # download remote version if cache is not new enough
+                        and remote_checksum == local_checksum):
-                if (not remote_checksum and (remote_version > cache_version or remote_version == 0)) \
+                    self.update_game(network_data_package["games"][game], game)
                        or remote_checksum != cache_checksum:
                    needed_updates.add(game)
                else:
-                    self.update_game(cached_game, game)
+                    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 (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)
        if needed_updates:
            await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
    def update_game(self, game_package: dict, game: str):
        self.item_names.update_game(game, game_package["item_name_to_id"])
        self.location_names.update_game(game, game_package["location_name_to_id"])
        self.versions[game] = game_package.get("version", 0)
        self.checksums[game] = game_package.get("checksum")
    def update_data_package(self, data_package: dict):
        for game, game_data in data_package["games"].items():
@ -608,6 +658,7 @@ class CommonContext:
            logger.info(f"DeathLink: Received from {data['source']}")
    async def send_death(self, death_text: str = ""):
        """Helper function to send a deathlink using death_text as the unique death cause string."""
        if self.server and self.server.socket:
            logger.info("DeathLink: Sending death to your friends...")
            self.last_death_link = time.time()
@ -621,6 +672,7 @@ class CommonContext:
            }])
    async def update_death_link(self, death_link: bool):
        """Helper function to set Death Link connection tag on/off and update the connection if already connected."""
        old_tags = self.tags.copy()
        if death_link:
            self.tags.add("DeathLink")
@ -630,7 +682,7 @@ class CommonContext:
            await self.send_msgs([{"cmd": "ConnectUpdate", "tags": self.tags}])
    def gui_error(self, title: str, text: typing.Union[Exception, str]) -> typing.Optional["kvui.MessageBox"]:
-        """Displays an error messagebox"""
+        """Displays an error messagebox in the loaded Kivy UI. Override if using a different UI framework"""
        if not self.ui:
            return None
        title = title or "Error"
@ -657,21 +709,36 @@ class CommonContext:
        logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
        self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
-    def run_gui(self):
+    def make_gui(self) -> "type[kvui.GameManager]":
-        """Import kivy UI system and start running it as self.ui_task."""
+        """
        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")`
        """
        from kvui import GameManager
        class TextManager(GameManager):
            logging_pairs = [
                ("Client", "Archipelago")
            ]
            base_title = "Archipelago Text Client"
-        self.ui = TextManager(self)
+        return TextManager
    def run_gui(self):
        """Import kivy UI system from make_gui() and start running it as self.ui_task."""
        ui_class = self.make_gui()
        self.ui = ui_class(self)
        self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
    def run_cli(self):
        if sys.stdin:
            if sys.stdin.fileno() != 0:
                from multiprocessing import parent_process
                if parent_process():
                    return  # ignore MultiProcessing pipe
            # steam overlay breaks when starting console_loop
            if 'gameoverlayrenderer' in os.environ.get('LD_PRELOAD', ''):
                logger.info("Skipping terminal input, due to conflicting Steam Overlay detected. Please use GUI only.")
@ -859,7 +926,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
        ctx.team = args["team"]
        ctx.slot = args["slot"]
        # int keys get lost in JSON transfer
-        ctx.slot_info = {int(pid): data for pid, data in args["slot_info"].items()}
+        ctx.slot_info = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
        ctx.slot_info.update({int(pid): data for pid, data in args["slot_info"].items()})
        ctx.hint_points = args.get("hint_points", 0)
        ctx.consume_players_package(args["players"])
        ctx.stored_data_notification_keys.add(f"_read_hints_{ctx.team}_{ctx.slot}")
@ -979,6 +1047,7 @@ async def console_loop(ctx: CommonContext):
 def get_base_parser(description: typing.Optional[str] = None):
    """Base argument parser to be reused for components subclassing off of CommonClient"""
    import argparse
    parser = argparse.ArgumentParser(description=description)
    parser.add_argument('--connect', default=None, help='Address of the multiworld host.')
@ -988,7 +1057,33 @@ def get_base_parser(description: typing.Optional[str] = None):
    return parser
-def run_as_textclient():
+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
        tags = CommonContext.tags | {"TextOnly"}
@ -1027,16 +1122,11 @@ def run_as_textclient():
    parser = get_base_parser(description="Gameless Archipelago Client, for text interfacing.")
    parser.add_argument('--name', default=None, help="Slot Name to connect as.")
    parser.add_argument("url", nargs="?", help="Archipelago connection url")
-    args = parser.parse_args()
+    args = parser.parse_args(args)
-    if args.url:
+    args = handle_url_arg(args, parser=parser)
        url = urllib.parse.urlparse(args.url)
        args.connect = url.netloc
        if url.username:
            args.name = urllib.parse.unquote(url.username)
        if url.password:
            args.password = urllib.parse.unquote(url.password)
    # use colorama to display colored text highlighting on windows
    colorama.init()
    asyncio.run(main(args))
@ -1045,4 +1135,4 @@ def run_as_textclient():
 if __name__ == '__main__':
    logging.getLogger().setLevel(logging.INFO)  # force log-level to work around log level resetting to WARNING
-    run_as_textclient()
+    run_as_textclient(*sys.argv[1:])  # default value for parse_args
--- a/Fill.py
+++ b/Fill.py
@ -12,7 +12,12 @@ from worlds.generic.Rules import add_item_rule
 class FillError(RuntimeError):
-    pass
+    def __init__(self, *args: typing.Union[str, typing.Any], **kwargs) -> None:
        if "multiworld" in kwargs and isinstance(args[0], str):
            placements = (args[0] + f"\nAll Placements:\n" +
                          f"{[(loc, loc.item) for loc in kwargs['multiworld'].get_filled_locations()]}")
            args = (placements, *args[1:])
        super().__init__(*args)
 def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
@ -24,14 +29,15 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
    new_state = base_state.copy()
    for item in itempool:
        new_state.collect(item, True)
-    new_state.sweep_for_events(locations=locations)
+    new_state.sweep_for_advancements(locations=locations)
    return new_state
 def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locations: typing.List[Location],
                     item_pool: typing.List[Item], single_player_placement: bool = False, lock: bool = False,
                     swap: bool = True, on_place: typing.Optional[typing.Callable[[Location], None]] = None,
-                     allow_partial: bool = False, allow_excluded: bool = False, name: str = "Unknown") -> None:
+                     allow_partial: bool = False, allow_excluded: bool = False, one_item_per_player: bool = True,
                     name: str = "Unknown") -> None:
    """
    :param multiworld: Multiworld to be filled.
    :param base_state: State assumed before fill.
@ -58,14 +64,22 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
    placed = 0
    while any(reachable_items.values()) and locations:
-        # grab one item per player
+        if one_item_per_player:
-        items_to_place = [items.pop()
+            # grab one item per player
-                          for items in reachable_items.values() if items]
+            items_to_place = [items.pop()
                              for items in reachable_items.values() if items]
        else:
            next_player = multiworld.random.choice([player for player, items in reachable_items.items() if items])
            items_to_place = []
            if item_pool:
                items_to_place.append(reachable_items[next_player].pop())
        for item in items_to_place:
            for p, pool_item in enumerate(item_pool):
                if pool_item is item:
                    item_pool.pop(p)
                    break
        maximum_exploration_state = sweep_from_pool(
            base_state, item_pool + unplaced_items, multiworld.get_filled_locations(item.player)
            if single_player_placement else None)
@ -212,7 +226,7 @@ def fill_restrictive(multiworld: MultiWorld, base_state: CollectionState, locati
                            f"Unfilled locations:\n"
                            f"{', '.join(str(location) for location in locations)}\n"
                            f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
    item_pool.extend(unplaced_items)
@ -221,18 +235,30 @@ def remaining_fill(multiworld: MultiWorld,
                   locations: typing.List[Location],
                   itempool: typing.List[Item],
                   name: str = "Remaining", 
-                   move_unplaceable_to_start_inventory: bool = False) -> None:
+                   move_unplaceable_to_start_inventory: bool = False,
                   check_location_can_fill: bool = False) -> None:
    unplaced_items: typing.List[Item] = []
    placements: typing.List[Location] = []
    swapped_items: typing.Counter[typing.Tuple[int, str]] = Counter()
    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
    if check_location_can_fill:
        state = CollectionState(multiworld)
        def location_can_fill_item(location_to_fill: Location, item_to_fill: Item):
            return location_to_fill.can_fill(state, item_to_fill, check_access=False)
    else:
        def location_can_fill_item(location_to_fill: Location, item_to_fill: Item):
            return location_to_fill.item_rule(item_to_fill)
    while locations and itempool:
        item_to_place = itempool.pop()
        spot_to_fill: typing.Optional[Location] = None
        for i, location in enumerate(locations):
-            if location.item_rule(item_to_place):
+            if location_can_fill_item(location, item_to_place):
                # popping by index is faster than removing by content,
                spot_to_fill = locations.pop(i)
                # skipping a scan for the element
@ -253,7 +279,7 @@ def remaining_fill(multiworld: MultiWorld,
                location.item = None
                placed_item.location = None
-                if location.item_rule(item_to_place):
+                if location_can_fill_item(location, item_to_place):
                    # Add this item to the existing placement, and
                    # add the old item to the back of the queue
                    spot_to_fill = placements.pop(i)
@ -299,7 +325,7 @@ def remaining_fill(multiworld: MultiWorld,
                            f"Unfilled locations:\n"
                            f"{', '.join(str(location) for location in locations)}\n"
                            f"Already placed {len(placements)}:\n"
-                            f"{', '.join(str(place) for place in placements)}")
+                            f"{', '.join(str(place) for place in placements)}", multiworld=multiworld)
    itempool.extend(unplaced_items)
@ -324,8 +350,8 @@ def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, lo
            pool.append(location.item)
            state.remove(location.item)
            location.item = None
-            if location in state.events:
+            if location in state.advancements:
-                state.events.remove(location)
+                state.advancements.remove(location)
            locations.append(location)
    if pool and locations:
        locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
@ -358,7 +384,7 @@ def distribute_early_items(multiworld: MultiWorld,
        early_priority_locations: typing.List[Location] = []
        loc_indexes_to_remove: typing.Set[int] = set()
        base_state = multiworld.state.copy()
-        base_state.sweep_for_events(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state.sweep_for_advancements(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
        for i, loc in enumerate(fill_locations):
            if loc.can_reach(base_state):
                if loc.progress_type == LocationProgressType.PRIORITY:
@ -470,28 +496,33 @@ def distribute_items_restrictive(multiworld: MultiWorld,
        nonlocal lock_later
        lock_later.append(location)
    single_player = multiworld.players == 1 and not multiworld.groups
    if prioritylocations:
        # "priority fill"
        fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
-                         single_player_placement=multiworld.players == 1, swap=False, on_place=mark_for_locking,
+                         single_player_placement=single_player, swap=False, on_place=mark_for_locking,
-                         name="Priority")
+                         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
            fill_restrictive(multiworld, multiworld.state, prioritylocations, progitempool,
                            single_player_placement=single_player, swap=False, on_place=mark_for_locking,
                            name="Priority Retry", one_item_per_player=False)
        accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
        defaultlocations = prioritylocations + defaultlocations
    if progitempool:
        # "advancement/progression fill"
        if panic_method == "swap":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=True,
-                             swap=True,
+                             name="Progression", single_player_placement=single_player)
                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
        elif panic_method == "raise":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
-                             swap=False,
+                             name="Progression", single_player_placement=single_player)
                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
        elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
-                             swap=False, allow_partial=True,
+                             allow_partial=True, name="Progression", single_player_placement=single_player)
                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
            if progitempool:
                for item in progitempool:
                    logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
@ -506,7 +537,9 @@ def distribute_items_restrictive(multiworld: MultiWorld,
        if progitempool:
            raise FillError(
                f"Not enough locations for progression items. "
-                f"There are {len(progitempool)} more progression items than there are available locations."
+                f"There are {len(progitempool)} more progression items than there are available locations.\n"
                f"Unfilled locations:\n{multiworld.get_unfilled_locations()}.",
                multiworld=multiworld,
            )
        accessibility_corrections(multiworld, multiworld.state, defaultlocations)
@ -523,7 +556,8 @@ def distribute_items_restrictive(multiworld: MultiWorld,
    if excludedlocations:
        raise FillError(
            f"Not enough filler items for excluded locations. "
-            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
+            f"There are {len(excludedlocations)} more excluded locations than excludable items.",
            multiworld=multiworld,
        )
    restitempool = filleritempool + usefulitempool
@ -543,6 +577,26 @@ 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
@ -551,7 +605,7 @@ def flood_items(multiworld: MultiWorld) -> None:
    progress_done = False
    # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_events()
+    multiworld.state.sweep_for_advancements()
    # fill multiworld from top of itempool while we can
    while not progress_done:
@ -589,7 +643,7 @@ def flood_items(multiworld: MultiWorld) -> None:
            if candidate_item_to_place is not None:
                item_to_place = candidate_item_to_place
            else:
-                raise FillError('No more progress items left to place.')
+                raise FillError('No more progress items left to place.', multiworld=multiworld)
        # find item to replace with progress item
        location_list = multiworld.get_reachable_locations()
@ -646,7 +700,6 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
        def get_sphere_locations(sphere_state: CollectionState,
                                 locations: typing.Set[Location]) -> typing.Set[Location]:
            sphere_state.sweep_for_events(key_only=True, locations=locations)
            return {loc for loc in locations if sphere_state.can_reach(loc)}
        def item_percentage(player: int, num: int) -> float:
@ -740,7 +793,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                            ), items_to_test):
                                reducing_state.collect(location.item, True, location)
-                            reducing_state.sweep_for_events(locations=locations_to_test)
+                            reducing_state.sweep_for_advancements(locations=locations_to_test)
                            if multiworld.has_beaten_game(balancing_state):
                                if not multiworld.has_beaten_game(reducing_state):
@ -823,7 +876,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
            warn(warning, force)
    swept_state = multiworld.state.copy()
-    swept_state.sweep_for_events()
+    swept_state.sweep_for_advancements()
    reachable = frozenset(multiworld.get_reachable_locations(swept_state))
    early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
    non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
@ -974,15 +1027,32 @@ def distribute_planned(multiworld: MultiWorld) -> None:
            multiworld.random.shuffle(items)
            count = 0
            err: typing.List[str] = []
-            successful_pairs: typing.List[typing.Tuple[Item, Location]] = []
+            successful_pairs: typing.List[typing.Tuple[int, Item, Location]] = []
            claimed_indices: typing.Set[typing.Optional[int]] = set()
            for item_name in items:
-                item = multiworld.worlds[player].create_item(item_name)
+                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((item, location))
+                                    successful_pairs.append((index_to_delete, item, location))
                                    claimed_indices.add(index_to_delete)
                                    candidates.remove(location)
                                    count = count + 1
                                    break
@ -994,6 +1064,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                            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']:
@ -1001,17 +1072,16 @@ def distribute_planned(multiworld: MultiWorld) -> None:
                failed(
                    f"Plando block failed to place {m - count} of {m} item(s) for {multiworld.player_name[player]}, error(s): {' '.join(err)}",
                    placement['force'])
-            for (item, location) in successful_pairs:
+
            # 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 from_pool:
+                if index is not None:  # If this item is from_pool and was found in the pool, remove it.
-                    try:
+                    multiworld.itempool.pop(index)
                        multiworld.itempool.remove(item)
                    except ValueError:
                        warn(
                            f"Could not remove {item} from pool for {multiworld.player_name[player]} as it's already missing from it.",
                            placement['force'])
        except Exception as e:
            raise Exception(
--- a/Generate.py
+++ b/Generate.py
@ -42,11 +42,13 @@ 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='info', help='Sets log level')
+    parser.add_argument('--log_level', default=defaults.loglevel, help='Sets log level')
-    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
+    parser.add_argument('--log_time', help="Add timestamps to STDOUT",
-                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
+                        default=defaults.logtime, action='store_true')
-    parser.add_argument('--plando', default=defaults.plando_options,
+    parser.add_argument("--csv_output", action="store_true",
-                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
+                        help="Output rolled player options to csv (made for async multiworld).")
    parser.add_argument("--plando", default=defaults.plando_options,
                        help="List of options that can be set manually. Can be combined, for example \"bosses, items\"")
    parser.add_argument("--skip_prog_balancing", action="store_true",
                        help="Skip progression balancing step during generation.")
    parser.add_argument("--skip_output", action="store_true",
@ -65,15 +67,17 @@ def get_seed_name(random_source) -> str:
    return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
-def main(args=None):
+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.")
    if not args:
        args = mystery_argparse()
    seed = get_seed(args.seed)
-    # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
+
-    if __name__ == "__main__" and "worlds" in sys.modules:
+    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level, add_timestamp=args.log_time)
        raise Exception("Worlds system should not be loaded before logging init.")
    Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
    random.seed(seed)
    seed_name = get_seed_name(random)
@ -108,11 +112,18 @@ def main(args=None):
    player_files = {}
    for file in os.scandir(args.player_files_path):
        fname = file.name
-        if file.is_file() and not fname.startswith(".") and \
+        if file.is_file() and not fname.startswith(".") and not fname.lower().endswith(".ini") and \
                os.path.join(args.player_files_path, fname) not in {args.meta_file_path, args.weights_file_path}:
            path = os.path.join(args.player_files_path, fname)
            try:
-                weights_cache[fname] = read_weights_yamls(path)
+                weights_for_file = []
                for doc_idx, yaml in enumerate(read_weights_yamls(path)):
                    if yaml is None:
                        logging.warning(f"Ignoring empty yaml document #{doc_idx + 1} in {fname}")
                    else:
                        weights_for_file.append(yaml)
                weights_cache[fname] = tuple(weights_for_file)
            except Exception as e:
                raise ValueError(f"File {fname} is invalid. Please fix your yaml.") from e
@ -153,6 +164,8 @@ def main(args=None):
    erargs.outputpath = args.outputpath
    erargs.skip_prog_balancing = args.skip_prog_balancing
    erargs.skip_output = args.skip_output
    erargs.name = {}
    erargs.csv_output = args.csv_output
    settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
        {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
@ -200,7 +213,7 @@ def main(args=None):
                    if path == args.weights_file_path:  # if name came from the weights file, just use base player name
                        erargs.name[player] = f"Player{player}"
-                    elif not erargs.name[player]:  # if name was not specified, generate it from filename
+                    elif player not in erargs.name:  # if name was not specified, generate it from filename
                        erargs.name[player] = os.path.splitext(os.path.split(path)[-1])[0]
                    erargs.name[player] = handle_name(erargs.name[player], player, name_counter)
@ -213,30 +226,7 @@ def main(args=None):
    if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
        raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in erargs.name.values())}")
-    if args.yaml_output:
+    return erargs, seed
        import yaml
        important = {}
        for option, player_settings in vars(erargs).items():
            if type(player_settings) == dict:
                if all(type(value) != list for value in player_settings.values()):
                    if len(player_settings.values()) > 1:
                        important[option] = {player: value for player, value in player_settings.items() if
                                             player <= args.yaml_output}
                    else:
                        logging.debug(f"No player settings defined for option '{option}'")
            else:
                if player_settings != "":  # is not empty name
                    important[option] = player_settings
                else:
                    logging.debug(f"No player settings defined for option '{option}'")
        if args.outputpath:
            os.makedirs(args.outputpath, exist_ok=True)
        with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
            yaml.dump(important, f)
    from Main import main as ERmain
    return ERmain(erargs, seed)
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@ -450,7 +440,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
    if "linked_options" in weights:
        weights = roll_linked_options(weights)
-    valid_keys = set()
+    valid_keys = {"triggers"}
    if "triggers" in weights:
        weights = roll_triggers(weights, weights["triggers"], valid_keys)
@ -472,6 +462,10 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
            raise Exception(f"Option {option_key} has to be in a game's section, not on its own.")
    ret.game = get_choice("game", weights)
    if not isinstance(ret.game, str):
        if ret.game is None:
            raise Exception('"game" not specified')
        raise Exception(f"Invalid game: {ret.game}")
    if ret.game not in AutoWorldRegister.world_types:
        from worlds import failed_world_loads
        picks = Utils.get_fuzzy_results(ret.game, list(AutoWorldRegister.world_types) + failed_world_loads, limit=1)[0]
@ -505,15 +499,23 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
    for option_key, option in world_type.options_dataclass.type_hints.items():
        handle_option(ret, game_weights, option_key, option, plando_options)
        valid_keys.add(option_key)
-    for option_key in game_weights:
+
-        if option_key in {"triggers", *valid_keys}:
+    # TODO remove plando_items after moving it to the options system
-            continue
+    valid_keys.add("plando_items")
        logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers.")
    if PlandoOptions.items in plando_options:
-        ret.plando_items = game_weights.get("plando_items", [])
+        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
    if ret.game == "A Link to the Past":
        # 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:
            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}.")
    return ret
@ -545,7 +547,9 @@ def roll_alttp_settings(ret: argparse.Namespace, weights):
 if __name__ == '__main__':
    import atexit
    confirmation = atexit.register(input, "Press enter to close.")
-    multiworld = main()
+    erargs, seed = main()
    from Main import main as ERmain
    multiworld = ERmain(erargs, seed)
    if __debug__:
        import gc
        import sys
--- a/KH1Client.py
+++ b/KH1Client.py
@ -0,0 +1,9 @@
 if __name__ == '__main__':
    import ModuleUpdate
    ModuleUpdate.update()
    import Utils
    Utils.init_logging("KH1Client", exception_logger="Client")
    from worlds.kh1.Client import launch
    launch()
--- a/2
+++ b/2
@ -1,7 +1,7 @@
 MIT License
 Copyright (c) 2017 LLCoolDave
-Copyright (c) 2022 Berserker66
+Copyright (c) 2025 Berserker66
 Copyright (c) 2022 CaitSith2
 Copyright (c) 2021 LegendaryLinux
--- a/Launcher.py
+++ b/Launcher.py
@ -16,25 +16,27 @@ import multiprocessing
 import shlex
 import subprocess
 import sys
 import urllib.parse
 import webbrowser
 from os.path import isfile
 from shutil import which
-from typing import Callable, Sequence, Union, Optional
+from typing import Callable, Optional, Sequence, Tuple, Union
 import Utils
 import settings
 from worlds.LauncherComponents import Component, components, Type, SuffixIdentifier, icon_paths
 if __name__ == "__main__":
    import ModuleUpdate
    ModuleUpdate.update()
-from Utils import is_frozen, user_path, local_path, init_logging, open_filename, messagebox, \
+import settings
-    is_windows, is_macos, is_linux
+import Utils
 from Utils import (init_logging, is_frozen, is_linux, is_macos, is_windows, local_path, messagebox, open_filename,
                   user_path)
 from worlds.LauncherComponents import Component, components, icon_paths, SuffixIdentifier, Type
 def open_host_yaml():
-    file = settings.get_settings().filename
+    s = settings.get_settings()
    file = s.filename
    s.save()
    assert file, "host.yaml missing"
    if is_linux:
        exe = which('sensible-editor') or which('gedit') or \
@ -101,13 +103,71 @@ components.extend([
    Component("Open host.yaml", func=open_host_yaml),
    Component("Open Patch", func=open_patch),
    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("Browse Files", func=browse_files),
 ])
-def identify(path: Union[None, str]):
+def handle_uri(path: str, launch_args: Tuple[str, ...]) -> None:
    url = urllib.parse.urlparse(path)
    queries = urllib.parse.parse_qs(url.query)
    launch_args = (path, *launch_args)
    client_component = None
    text_client_component = None
    if "game" in queries:
        game = queries["game"][0]
    else:  # TODO around 0.6.0 - this is for pre this change webhost uri's
        game = "Archipelago"
    for component in components:
        if component.supports_uri and component.game_name == game:
            client_component = component
        elif component.display_name == "Text Client":
            text_client_component = component
    if client_component is None:
        run_component(text_client_component, *launch_args)
        return
    from kvui import App, Button, BoxLayout, Label, Window
    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: Union[None, str]) -> Tuple[Union[None, str], Union[None, Component]]:
    if path is None:
        return None, None
    for component in components:
@ -164,9 +224,8 @@ refresh_components: Optional[Callable[[], None]] = None
 def run_gui():
-    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
+    from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget, ApAsyncImage
    from kivy.core.window import Window
    from kivy.uix.image import AsyncImage
    from kivy.uix.relativelayout import RelativeLayout
    class Launcher(App):
@ -177,7 +236,7 @@ def run_gui():
        _client_layout: Optional[ScrollBox] = None
        def __init__(self, ctx=None):
-            self.title = self.base_title
+            self.title = self.base_title + " " + Utils.__version__
            self.ctx = ctx
            self.icon = r"data/icon.png"
            super().__init__()
@ -199,8 +258,8 @@ def run_gui():
                button.component = component
                button.bind(on_release=self.component_action)
                if component.icon != "icon":
-                    image = AsyncImage(source=icon_paths[component.icon],
+                    image = ApAsyncImage(source=icon_paths[component.icon],
-                                       size=(38, 38), size_hint=(None, 1), pos=(5, 0))
+                                         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)
@ -266,7 +325,7 @@ def run_gui():
            if file and component:
                run_component(component, file)
            else:
-                logging.warning(f"unable to identify component for {filename}")
+                logging.warning(f"unable to identify component for {file}")
        def _stop(self, *largs):
            # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
@ -299,20 +358,24 @@ def main(args: Optional[Union[argparse.Namespace, dict]] = None):
    elif not args:
        args = {}
-    if args.get("Patch|Game|Component", None) is not None:
+    path = args.get("Patch|Game|Component|url", None)
-        file, component = identify(args["Patch|Game|Component"])
+    if path is not None:
        if path.startswith("archipelago://"):
            handle_uri(path, args.get("args", ()))
            return
        file, component = identify(path)
        if file:
            args['file'] = file
        if component:
            args['component'] = component
        if not component:
-            logging.warning(f"Could not identify Component responsible for {args['Patch|Game|Component']}")
+            logging.warning(f"Could not identify Component responsible for {path}")
    if args["update_settings"]:
        update_settings()
-    if 'file' in args:
+    if "file" in args:
        run_component(args["component"], args["file"], *args["args"])
-    elif 'component' in args:
+    elif "component" in args:
        run_component(args["component"], *args["args"])
    elif not args["update_settings"]:
        run_gui()
@ -322,12 +385,16 @@ if __name__ == '__main__':
    init_logging('Launcher')
    Utils.freeze_support()
    multiprocessing.set_start_method("spawn")  # if launched process uses kivy, fork won't work
-    parser = argparse.ArgumentParser(description='Archipelago Launcher')
+    parser = argparse.ArgumentParser(
        description='Archipelago Launcher',
        usage="[-h] [--update_settings] [Patch|Game|Component] [-- component args here]"
    )
    run_group = parser.add_argument_group("Run")
    run_group.add_argument("--update_settings", action="store_true",
                           help="Update host.yaml and exit.")
-    run_group.add_argument("Patch|Game|Component", type=str, nargs="?",
+    run_group.add_argument("Patch|Game|Component|url", type=str, nargs="?",
-                           help="Pass either a patch file, a generated game or the name of a component to run.")
+                           help="Pass either a patch file, a generated game, the component name to run, or a url to "
                                "connect with.")
    run_group.add_argument("args", nargs="*",
                           help="Arguments to pass to component.")
    main(parser.parse_args())
--- a/LinksAwakeningClient.py
+++ b/LinksAwakeningClient.py
@ -235,7 +235,7 @@ class RAGameboy():
    def check_command_response(self, command: str, response: bytes):
        if command == "VERSION":
-            ok = re.match("\d+\.\d+\.\d+", response.decode('ascii')) is not None
+            ok = re.match(r"\d+\.\d+\.\d+", response.decode('ascii')) is not None
        else:
            ok = response.startswith(command.encode())
        if not ok:
@ -467,6 +467,8 @@ class LinksAwakeningContext(CommonContext):
    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str], magpie: typing.Optional[bool]) -> None:
        self.client = LinksAwakeningClient()
        self.slot_data = {}
        if magpie:
            self.magpie_enabled = True
            self.magpie = MagpieBridge()
@ -558,12 +560,18 @@ 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()
    def on_package(self, cmd: str, args: dict):
        if cmd == "Connected":
            self.game = self.slot_info[self.slot].game
            self.slot_data = args.get("slot_data", {})
        # TODO - use watcher_event
        if cmd == "ReceivedItems":
            for index, item in enumerate(args["items"], start=args["index"]):
@ -628,6 +636,7 @@ class LinksAwakeningContext(CommonContext):
                            self.magpie.set_checks(self.client.tracker.all_checks)
                            await self.magpie.set_item_tracker(self.client.item_tracker)
                            await self.magpie.send_gps(self.client.gps_tracker)
                            self.magpie.slot_data = self.slot_data
                        except Exception:
                            # Don't let magpie errors take out the client
                            pass
--- a/LttPAdjuster.py
+++ b/LttPAdjuster.py
@ -14,7 +14,7 @@ import tkinter as tk
 from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
-from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, BOTH, TOP, LabelFrame, \
    IntVar, Checkbutton, E, W, OptionMenu, Toplevel, BOTTOM, RIGHT, font as font, PhotoImage
 from tkinter.constants import DISABLED, NORMAL
 from urllib.parse import urlparse
@ -29,7 +29,8 @@ from Utils import output_path, local_path, user_path, open_file, get_cert_none_s
 GAME_ALTTP = "A Link to the Past"
-
+WINDOW_MIN_HEIGHT = 525
 WINDOW_MIN_WIDTH = 425
 class AdjusterWorld(object):
    def __init__(self, sprite_pool):
@ -242,16 +243,17 @@ def adjustGUI():
    from argparse import Namespace
    from Utils import __version__ as MWVersion
    adjustWindow = Tk()
    adjustWindow.minsize(WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT)
    adjustWindow.wm_title("Archipelago %s LttP Adjuster" % MWVersion)
    set_icon(adjustWindow)
    rom_options_frame, rom_vars, set_sprite = get_rom_options_frame(adjustWindow)
-    bottomFrame2 = Frame(adjustWindow)
+    bottomFrame2 = Frame(adjustWindow, padx=8, pady=2)
    romFrame, romVar = get_rom_frame(adjustWindow)
-    romDialogFrame = Frame(adjustWindow)
+    romDialogFrame = Frame(adjustWindow, padx=8, pady=2)
    baseRomLabel2 = Label(romDialogFrame, text='Rom to adjust')
    romVar2 = StringVar()
    romEntry2 = Entry(romDialogFrame, textvariable=romVar2)
@ -261,9 +263,9 @@ def adjustGUI():
        romVar2.set(rom)
    romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
-    romDialogFrame.pack(side=TOP, expand=True, fill=X)
+    romDialogFrame.pack(side=TOP, expand=False, fill=X)
-    baseRomLabel2.pack(side=LEFT)
+    baseRomLabel2.pack(side=LEFT, expand=False, fill=X, padx=(0, 8))
-    romEntry2.pack(side=LEFT, expand=True, fill=X)
+    romEntry2.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
    romSelectButton2.pack(side=LEFT)
    def adjustRom():
@ -331,12 +333,11 @@ def adjustGUI():
        messagebox.showinfo(title="Success", message="Settings saved to persistent storage")
    adjustButton = Button(bottomFrame2, text='Adjust Rom', command=adjustRom)
-    rom_options_frame.pack(side=TOP)
+    rom_options_frame.pack(side=TOP, padx=8, pady=8, fill=BOTH, expand=True)
    adjustButton.pack(side=LEFT, padx=(5,5))
    saveButton = Button(bottomFrame2, text='Save Settings', command=saveGUISettings)
    saveButton.pack(side=LEFT, padx=(5,5))
    bottomFrame2.pack(side=TOP, pady=(5,5))
    tkinter_center_window(adjustWindow)
@ -576,7 +577,7 @@ class AttachTooltip(object):
 def get_rom_frame(parent=None):
    adjuster_settings = get_adjuster_settings(GAME_ALTTP)
-    romFrame = Frame(parent)
+    romFrame = Frame(parent, padx=8, pady=8)
    baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
    romVar = StringVar(value=adjuster_settings.baserom)
    romEntry = Entry(romFrame, textvariable=romVar)
@ -596,20 +597,19 @@ def get_rom_frame(parent=None):
    romSelectButton = Button(romFrame, text='Select Rom', command=RomSelect)
    baseRomLabel.pack(side=LEFT)
-    romEntry.pack(side=LEFT, expand=True, fill=X)
+    romEntry.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
    romSelectButton.pack(side=LEFT)
-    romFrame.pack(side=TOP, expand=True, fill=X)
+    romFrame.pack(side=TOP, fill=X)
    return romFrame, romVar
 def get_rom_options_frame(parent=None):
    adjuster_settings = get_adjuster_settings(GAME_ALTTP)
-    romOptionsFrame = LabelFrame(parent, text="Rom options")
+    romOptionsFrame = LabelFrame(parent, text="Rom options", padx=8, pady=8)
-    romOptionsFrame.columnconfigure(0, weight=1)
+
    romOptionsFrame.columnconfigure(1, weight=1)
    for i in range(5):
-        romOptionsFrame.rowconfigure(i, weight=1)
+        romOptionsFrame.rowconfigure(i, weight=0, pad=4)
    vars = Namespace()
    vars.MusicVar = IntVar()
@ -660,7 +660,7 @@ def get_rom_options_frame(parent=None):
    spriteSelectButton = Button(spriteDialogFrame, text='...', command=SpriteSelect)
    baseSpriteLabel.pack(side=LEFT)
-    spriteEntry.pack(side=LEFT)
+    spriteEntry.pack(side=LEFT, expand=True, fill=X)
    spriteSelectButton.pack(side=LEFT)
    oofDialogFrame = Frame(romOptionsFrame)
--- a/Main.py
+++ b/Main.py
@ -11,7 +11,8 @@ from typing import Dict, List, Optional, Set, Tuple, Union
 import worlds
 from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
-from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, flood_items
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
    flood_items
 from Options import StartInventoryPool
 from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
@ -45,6 +46,9 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
    multiworld.sprite_pool = args.sprite_pool.copy()
    multiworld.set_options(args)
    if args.csv_output:
        from Options import dump_player_options
        dump_player_options(multiworld)
    multiworld.set_item_links()
    multiworld.state = CollectionState(multiworld)
    logger.info('Archipelago Version %s  -  Seed: %s\n', __version__, multiworld.seed)
@ -100,7 +104,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                multiworld.early_items[player][item_name] = max(0, early-count)
                remaining_count = count-early
                if remaining_count > 0:
-                    local_early = multiworld.early_local_items[player].get(item_name, 0)
+                    local_early = multiworld.local_early_items[player].get(item_name, 0)
                    if local_early:
                        multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
                    del local_early
@ -124,14 +128,19 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
    for player in multiworld.player_ids:
        exclusion_rules(multiworld, player, multiworld.worlds[player].options.exclude_locations.value)
        multiworld.worlds[player].options.priority_locations.value -= multiworld.worlds[player].options.exclude_locations.value
        world_excluded_locations = set()
        for location_name in multiworld.worlds[player].options.priority_locations.value:
            try:
                location = multiworld.get_location(location_name, player)
-            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
+            except KeyError:
-                if location_name not in multiworld.worlds[player].location_name_to_id:
+                continue
-                    raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
+
-            else:
+            if location.progress_type != LocationProgressType.EXCLUDED:
                location.progress_type = LocationProgressType.PRIORITY
            else:
                logger.warning(f"Unable to prioritize location \"{location_name}\" in player {player}'s world because the world excluded it.")
                world_excluded_locations.add(location_name)
        multiworld.worlds[player].options.priority_locations.value -= world_excluded_locations
    # Set local and non-local item rules.
    if multiworld.players > 1:
@ -140,121 +149,45 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
        multiworld.worlds[1].options.non_local_items.value = set()
        multiworld.worlds[1].options.local_items.value = set()
    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.
-    if any(getattr(multiworld.worlds[player].options, "start_inventory_from_pool", None) for player in multiworld.player_ids):
+    fallback_inventory = StartInventoryPool({})
-        new_items: List[Item] = []
+    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()
-            player: getattr(multiworld.worlds[player].options,
+        for player in multiworld.player_ids
-                            "start_inventory_from_pool",
+    }
-                            StartInventoryPool({})).value.copy()
+    target_per_player = {
-            for player in multiworld.player_ids
+        player: sum(target_items.values()) for player, target_items in depletion_pool.items() if target_items
-        }
+    }
        for player, items in depletion_pool.items():
            player_world: AutoWorld.World = multiworld.worlds[player]
            for count in items.values():
                for _ in range(count):
                    new_items.append(player_world.create_filler())
        target: int = sum(sum(items.values()) for items in depletion_pool.values())
        for i, item in enumerate(multiworld.itempool):
            if depletion_pool[item.player].get(item.name, 0):
                target -= 1
                depletion_pool[item.player][item.name] -= 1
                # quick abort if we have found all items
                if not target:
                    new_items.extend(multiworld.itempool[i+1:])
                    break
            else:
                new_items.append(item)
        # leftovers?
        if target:
            for player, remaining_items in depletion_pool.items():
                remaining_items = {name: count for name, count in remaining_items.items() if count}
                if remaining_items:
                    raise Exception(f"{multiworld.get_player_name(player)}"
                                    f" is trying to remove items from their pool that don't exist: {remaining_items}")
        assert len(multiworld.itempool) == len(new_items), "Item Pool amounts should not change."
        multiworld.itempool[:] = new_items
    # temporary home for item links, should be moved out of Main
    for group_id, group in multiworld.groups.items():
        def find_common_pool(players: Set[int], shared_pool: Set[str]) -> Tuple[
            Optional[Dict[int, Dict[str, int]]], Optional[Dict[str, int]]
        ]:
            classifications: Dict[str, int] = collections.defaultdict(int)
            counters = {player: {name: 0 for name in shared_pool} for player in players}
            for item in multiworld.itempool:
                if item.player in counters and item.name in shared_pool:
                    counters[item.player][item.name] += 1
                    classifications[item.name] |= item.classification
            for player in players.copy():
                if all([counters[player][item] == 0 for item in shared_pool]):
                    players.remove(player)
                    del (counters[player])
            if not players:
                return None, None
            for item in shared_pool:
                count = min(counters[player][item] for player in players)
                if count:
                    for player in players:
                        counters[player][item] = count
                else:
                    for player in players:
                        del (counters[player][item])
            return counters, classifications
        common_item_count, classifications = find_common_pool(group["players"], group["item_pool"])
        if not common_item_count:
            continue
    if target_per_player:
        new_itempool: List[Item] = []
        for item_name, item_count in next(iter(common_item_count.values())).items():
            for _ in range(item_count):
                new_item = group["world"].create_item(item_name)
                # mangle together all original classification bits
                new_item.classification |= classifications[item_name]
                new_itempool.append(new_item)
-        region = Region("Menu", group_id, multiworld, "ItemLink")
+        # Make new itempool with start_inventory_from_pool items removed
        multiworld.regions.append(region)
        locations = region.locations
        for item in multiworld.itempool:
-            count = common_item_count.get(item.player, {}).get(item.name, 0)
+            if depletion_pool[item.player].get(item.name, 0):
-            if count:
+                depletion_pool[item.player][item.name] -= 1
                loc = Location(group_id, f"Item Link: {item.name} -> {multiworld.player_name[item.player]} {count}",
                               None, region)
                loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
                    state.has(item_name, group_id_, count_)
                locations.append(loc)
                loc.place_locked_item(item)
                common_item_count[item.player][item.name] -= 1
            else:
                new_itempool.append(item)
-        itemcount = len(multiworld.itempool)
+        # Create filler in place of the removed items, warn if any items couldn't be found in the multiworld itempool
-        multiworld.itempool = new_itempool
+        for player, target in target_per_player.items():
            unfound_items = {item: count for item, count in depletion_pool[player].items() if count}
-        while itemcount > len(multiworld.itempool):
+            if unfound_items:
-            items_to_add = []
+                player_name = multiworld.get_player_name(player)
-            for player in group["players"]:
+                logger.warning(f"{player_name} tried to remove items from their pool that don't exist: {unfound_items}")
-                if group["link_replacement"]:
+
-                    item_player = group_id
+            needed_items = target_per_player[player] - sum(unfound_items.values())
-                else:
+            new_itempool += [multiworld.worlds[player].create_filler() for _ in range(needed_items)]
-                    item_player = player
+
-                if group["replacement_items"][player]:
+        assert len(multiworld.itempool) == len(new_itempool), "Item Pool amounts should not change."
-                    items_to_add.append(AutoWorld.call_single(multiworld, "create_item", item_player,
+        multiworld.itempool[:] = new_itempool
-                                                                group["replacement_items"][player]))
+
-                else:
+    multiworld.link_items()
                    items_to_add.append(AutoWorld.call_single(multiworld, "create_filler", item_player))
            multiworld.random.shuffle(items_to_add)
            multiworld.itempool.extend(items_to_add[:itemcount - len(multiworld.itempool)])
    if any(multiworld.item_links.values()):
        multiworld._all_state = None
@ -310,6 +243,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
            def write_multidata():
                import NetUtils
                from NetUtils import HintStatus
                slot_data = {}
                client_versions = {}
                games = {}
@ -334,10 +268,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                for slot in multiworld.player_ids:
                    slot_data[slot] = multiworld.worlds[slot].fill_slot_data()
-                def precollect_hint(location):
+                def precollect_hint(location: Location, auto_status: HintStatus):
                    entrance = er_hint_data.get(location.player, {}).get(location.address, "")
                    hint = NetUtils.Hint(location.item.player, location.player, location.address,
-                                         location.item.code, False, entrance, location.item.flags)
+                                         location.item.code, False, entrance, location.item.flags, auto_status)
                    precollected_hints[location.player].add(hint)
                    if location.item.player not in multiworld.groups:
                        precollected_hints[location.item.player].add(hint)
@ -350,19 +284,22 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                    if type(location.address) == int:
                        assert location.item.code is not None, "item code None should be event, " \
                                                               "location.address should then also be None. Location: " \
-                                                               f" {location}"
+                                                               f" {location}, Item: {location.item}"
                        assert location.address not in locations_data[location.player], (
                            f"Locations with duplicate address. {location} and "
                            f"{locations_data[location.player][location.address]}")
                        locations_data[location.player][location.address] = \
                            location.item.code, location.item.player, location.item.flags
                        auto_status = HintStatus.HINT_AVOID if location.item.trap else HintStatus.HINT_PRIORITY
                        if location.name in multiworld.worlds[location.player].options.start_location_hints:
-                            precollect_hint(location)
+                            if not location.item.trap:  # Unspecified status for location hints, except traps
                                auto_status = HintStatus.HINT_UNSPECIFIED
                            precollect_hint(location, auto_status)
                        elif location.item.name in multiworld.worlds[location.item.player].options.start_hints:
-                            precollect_hint(location)
+                            precollect_hint(location, auto_status)
                        elif any([location.item.name in multiworld.worlds[player].options.start_hints
                                  for player in multiworld.groups.get(location.item.player, {}).get("players", [])]):
-                            precollect_hint(location)
+                            precollect_hint(location, auto_status)
                # embedded data package
                data_package = {
@ -374,11 +311,10 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                # get spheres -> filter address==None -> skip empty
                spheres: List[Dict[int, Set[int]]] = []
-                for sphere in multiworld.get_spheres():
+                for sphere in multiworld.get_sendable_spheres():
                    current_sphere: Dict[int, Set[int]] = collections.defaultdict(set)
                    for sphere_location in sphere:
-                        if type(sphere_location.address) is int:
+                        current_sphere[sphere_location.player].add(sphere_location.address)
                            current_sphere[sphere_location.player].add(sphere_location.address)
                    if current_sphere:
                        spheres.append(dict(current_sphere))
@ -399,6 +335,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                    "seed_name": multiworld.seed_name,
                    "spheres": spheres,
                    "datapackage": data_package,
                    "race_mode": int(multiworld.is_race),
                }
                AutoWorld.call_all(multiworld, "modify_multidata", multidata)
@ -411,7 +348,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
            output_file_futures.append(pool.submit(write_multidata))
            if not check_accessibility_task.result():
                if not multiworld.can_beat_game():
-                    raise Exception("Game appears as unbeatable. Aborting.")
+                    raise FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
                else:
                    logger.warning("Location Accessibility requirements not fulfilled.")
--- a/ModuleUpdate.py
+++ b/ModuleUpdate.py
@ -5,8 +5,15 @@ import multiprocessing
 import warnings
-if sys.version_info < (3, 8, 6):
+if sys.platform in ("win32", "darwin") and sys.version_info < (3, 10, 11):
-    raise RuntimeError("Incompatible Python Version. 3.8.7+ is supported.")
+    # Official micro version updates. This should match the number in docs/running from source.md.
    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. Official 3.10.15+ is supported.")
 elif sys.platform in ("win32", "darwin") and sys.version_info < (3, 10, 15):
    # There are known security issues, but no easy way to install fixed versions on Windows for testing.
    warnings.warn(f"Python Version {sys.version_info} has security issues. Don't use in production.")
 elif sys.version_info < (3, 10, 1):
    # Other platforms may get security backports instead of micro updates, so the number is unreliable.
    raise RuntimeError(f"Incompatible Python Version found: {sys.version_info}. 3.10.1+ is supported.")
 # don't run update if environment is frozen/compiled or if not the parent process (skip in subprocess)
 _skip_update = bool(getattr(sys, "frozen", False) or multiprocessing.parent_process())
@ -75,13 +82,13 @@ def update(yes: bool = False, force: bool = False) -> None:
    if not update_ran:
        update_ran = True
        install_pkg_resources(yes=yes)
        import pkg_resources
        if force:
            update_command()
            return
        install_pkg_resources(yes=yes)
        import pkg_resources
        prev = ""  # if a line ends in \ we store here and merge later
        for req_file in requirements_files:
            path = os.path.join(os.path.dirname(sys.argv[0]), req_file)
--- a/MultiServer.py
+++ b/MultiServer.py
@ -15,6 +15,7 @@ import math
 import operator
 import pickle
 import random
 import shlex
 import threading
 import time
 import typing
@ -27,9 +28,11 @@ ModuleUpdate.update()
 if typing.TYPE_CHECKING:
    import ssl
    from NetUtils import ServerConnection
 import websockets
 import colorama
 import websockets
 from websockets.extensions.permessage_deflate import PerMessageDeflate
 try:
    # ponyorm is a requirement for webhost, not default server, so may not be importable
    from pony.orm.dbapiprovider import OperationalError
@ -40,7 +43,8 @@ import NetUtils
 import Utils
 from Utils import version_tuple, restricted_loads, Version, async_start, get_intended_text
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
-    SlotType, LocationStore
+    SlotType, LocationStore, Hint, HintStatus
 from BaseClasses import ItemClassification
 min_client_version = Version(0, 1, 6)
 colorama.init()
@ -67,6 +71,21 @@ def update_dict(dictionary, entries):
    return dictionary
 def queue_gc():
    import gc
    from threading import Thread
    gc_thread: typing.Optional[Thread] = getattr(queue_gc, "_thread", None)
    def async_collect():
        time.sleep(2)
        setattr(queue_gc, "_thread", None)
        gc.collect()
    if not gc_thread:
        gc_thread = Thread(target=async_collect)
        setattr(queue_gc, "_thread", gc_thread)
        gc_thread.start()
 # functions callable on storable data on the server by clients
 modify_functions = {
    # generic:
@ -102,13 +121,14 @@ 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: websockets.WebSocketServerProtocol, ctx: Context):
+    def __init__(self, socket: "ServerConnection", ctx: Context) -> None:
        super().__init__(socket)
        self.auth = False
        self.team = None
@ -158,6 +178,7 @@ 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]
@ -169,11 +190,9 @@ class Context:
    slot_info: typing.Dict[int, NetworkSlot]
    generator_version = Version(0, 0, 0)
    checksums: typing.Dict[str, str]
-    item_names: typing.Dict[str, typing.Dict[int, str]] = (
+    item_names: typing.Dict[str, typing.Dict[int, str]]
        collections.defaultdict(lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')))
    item_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
-    location_names: typing.Dict[str, typing.Dict[int, str]] = (
+    location_names: typing.Dict[str, typing.Dict[int, str]]
        collections.defaultdict(lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')))
    location_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
    all_item_and_group_names: typing.Dict[str, typing.Set[str]]
    all_location_and_group_names: typing.Dict[str, typing.Set[str]]
@ -182,7 +201,6 @@ class Context:
    """ each sphere is { player: { location_id, ... } } """
    logger: logging.Logger
    def __init__(self, host: str, port: int, server_password: str, password: str, location_check_points: int,
                 hint_cost: int, item_cheat: bool, release_mode: str = "disabled", collect_mode="disabled",
                 remaining_mode: str = "disabled", auto_shutdown: typing.SupportsFloat = 0, compatibility: int = 2,
@ -215,7 +233,7 @@ class Context:
        self.hint_cost = hint_cost
        self.location_check_points = location_check_points
        self.hints_used = collections.defaultdict(int)
-        self.hints: typing.Dict[team_slot, typing.Set[NetUtils.Hint]] = collections.defaultdict(set)
+        self.hints: typing.Dict[team_slot, typing.Set[Hint]] = collections.defaultdict(set)
        self.release_mode: str = release_mode
        self.remaining_mode: str = remaining_mode
        self.collect_mode: str = collect_mode
@ -253,6 +271,10 @@ class Context:
        self.location_name_groups = {}
        self.all_item_and_group_names = {}
        self.all_location_and_group_names = {}
        self.item_names = collections.defaultdict(
            lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})'))
        self.location_names = collections.defaultdict(
            lambda: Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})'))
        self.non_hintable_names = collections.defaultdict(frozenset)
        self._load_game_data()
@ -346,18 +368,28 @@ class Context:
            return True
    def broadcast_all(self, msgs: typing.List[dict]):
-        msgs = self.dumper(msgs)
+        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
-        endpoints = (endpoint for endpoint in self.endpoints if endpoint.auth)
+        data = self.dumper(msgs)
-        async_start(self.broadcast_send_encoded_msgs(endpoints, 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))
    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]):
-        msgs = self.dumper(msgs)
+        msg_is_text = all(msg["cmd"] == "PrintJSON" for msg in msgs)
-        endpoints = (endpoint for endpoint in itertools.chain.from_iterable(self.clients[team].values()))
+        data = self.dumper(msgs)
-        async_start(self.broadcast_send_encoded_msgs(endpoints, 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))
    def broadcast(self, endpoints: typing.Iterable[Client], msgs: typing.List[dict]):
        msgs = self.dumper(msgs)
@ -371,13 +403,13 @@ class Context:
        await on_client_disconnected(self, endpoint)
    def notify_client(self, client: Client, text: str, additional_arguments: dict = {}):
-        if not client.auth:
+        if not client.auth or client.no_text:
            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:
+        if not client.auth or client.no_text:
            return
        async_start(self.send_msgs(client,
                                   [{"cmd": "PrintJSON", "data": [{ "text": text }], **additional_arguments}
@ -412,6 +444,8 @@ class Context:
              use_embedded_server_options: bool):
        self.read_data = {}
        # there might be a better place to put this.
        self.read_data["race_mode"] = lambda: decoded_obj.get("race_mode", 0)
        mdata_ver = decoded_obj["minimum_versions"]["server"]
        if mdata_ver > version_tuple:
            raise RuntimeError(f"Supplied Multidata (.archipelago) requires a server of at least version {mdata_ver},"
@ -424,7 +458,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: slot_info.group_members 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()
                       if slot_info.type == SlotType.group}
        self.clients = {0: {}}
@ -551,6 +585,9 @@ class Context:
                        self.logger.info(f"Saving failed. Retry in {self.auto_save_interval} seconds.")
                    else:
                        self.save_dirty = False
                if not atexit_save:  # if atexit is used, that keeps a reference anyway
                    queue_gc()
            self.auto_saver_thread = threading.Thread(target=save_regularly, daemon=True)
            self.auto_saver_thread.start()
@ -634,13 +671,29 @@ class Context:
            return max(1, int(self.hint_cost * 0.01 * len(self.locations[slot])))
        return 0
-    def recheck_hints(self, team: typing.Optional[int] = None, slot: typing.Optional[int] = None):
+    def recheck_hints(self, team: typing.Optional[int] = None, slot: typing.Optional[int] = None,
                      changed: typing.Optional[typing.Set[team_slot]] = None) -> None:
        """Refreshes the hints for the specified team/slot. Providing 'None' for either team or slot
        will refresh all teams or all slots respectively. If a set is passed for 'changed', each (team,slot)
        pair that has at least one hint modified will be added to the set.
        """
        for hint_team, hint_slot in self.hints:
-            if (team is None or team == hint_team) and (slot is None or slot == hint_slot):
+            if team != hint_team and team is not None:
-                self.hints[hint_team, hint_slot] = {
+                continue  # Check specified team only, all if team is None
-                    hint.re_check(self, hint_team) for hint in
+            if slot != hint_slot and slot is not None:
-                    self.hints[hint_team, hint_slot]
+                continue  # Check specified slot only, all if slot is None
-                }
+            new_hints: typing.Set[Hint] = set()
            for hint in self.hints[hint_team, hint_slot]:
                new_hint = hint.re_check(self, hint_team)
                new_hints.add(new_hint)
                if hint == new_hint:
                    continue
                for player in self.slot_set(hint.receiving_player) | {hint.finding_player}:
                    if changed is not None:
                        changed.add((hint_team,player))
                    if slot is not None and slot != player:
                        self.replace_hint(hint_team, player, hint, new_hint)
            self.hints[hint_team, hint_slot] = new_hints
    def get_rechecked_hints(self, team: int, slot: int):
        self.recheck_hints(team, slot)
@ -689,7 +742,7 @@ class Context:
        else:
            return self.player_names[team, slot]
-    def notify_hints(self, team: int, hints: typing.List[NetUtils.Hint], only_new: bool = False,
+    def notify_hints(self, team: int, hints: typing.List[Hint], only_new: bool = False,
                     recipients: typing.Sequence[int] = None):
        """Send and remember hints."""
        if only_new:
@ -704,7 +757,8 @@ 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
@ -720,13 +774,24 @@ class Context:
            self.on_new_hint(team, slot)
        for slot, hint_data in concerns.items():
            if recipients is None or slot in recipients:
-                clients = self.clients[team].get(slot)
+                clients = filter(lambda c: not c.no_text, 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)]
                for client in clients:
                    async_start(self.send_msgs(client, client_hints))
    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:
                return hint
        return None
    def replace_hint(self, team: int, slot: int, old_hint: Hint, new_hint: Hint) -> None:
        if old_hint in self.hints[team, slot]:
            self.hints[team, slot].remove(old_hint)
            self.hints[team, slot].add(new_hint)
    # "events"
    def on_goal_achieved(self, client: Client):
@ -768,7 +833,7 @@ def update_aliases(ctx: Context, team: int):
            async_start(ctx.send_encoded_msgs(client, cmd))
-async def server(websocket, path: str = "/", ctx: Context = None):
+async def server(websocket: "ServerConnection", path: str = "/", ctx: Context = None) -> None:
    client = Client(websocket, ctx)
    ctx.endpoints.append(client)
@ -859,6 +924,10 @@ 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)
@ -925,9 +994,13 @@ def get_status_string(ctx: Context, team: int, tag: str):
        tagged = len([client for client in ctx.clients[team][slot] if tag in client.tags])
        completion_text = f"({len(ctx.location_checks[team, slot])}/{len(ctx.locations[slot])})"
        tag_text = f" {tagged} of which are tagged {tag}" if connected and tag else ""
-        goal_text = " and has finished." if ctx.client_game_state[team, slot] == ClientStatus.CLIENT_GOAL else "."
+        status_text = (
            " and has finished." if ctx.client_game_state[team, slot] == ClientStatus.CLIENT_GOAL else
            " and is ready." if ctx.client_game_state[team, slot] == ClientStatus.CLIENT_READY else
            "."
            )
        text += f"\n{ctx.get_aliased_name(team, slot)} has {connected} connection{'' if connected == 1 else 's'}" \
-                f"{tag_text}{goal_text} {completion_text}"
+                f"{tag_text}{status_text} {completion_text}"
    return text
@ -991,7 +1064,7 @@ def collect_player(ctx: Context, team: int, slot: int, is_group: bool = False):
                    collect_player(ctx, team, group, True)
-def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
+def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[typing.Tuple[int, int]]:
    return ctx.locations.get_remaining(ctx.location_checks, team, slot)
@ -1005,21 +1078,37 @@ 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(ctx.locations[slot])  # ignore location IDs unknown to this multidata
+    new_locations.intersection_update(slot_locations)  # 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:
-            item_id, target_player, flags = ctx.locations[slot][location]
+            # 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):
            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]))
-            info_text = json_format_send_event(new_item, target_player)
+            if len(info_texts) >= 140:
-            ctx.broadcast_team(team, [info_text])
+                # 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
        ctx.location_checks[team, slot] |= new_locations
        send_new_items(ctx)
@ -1028,14 +1117,15 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
            "hint_points": get_slot_points(ctx, team, slot),
            "checked_locations": new_locations,  # send back new checks only
        }])
-        old_hints = ctx.hints[team, slot].copy()
+        updated_slots: typing.Set[tuple[int, int]] = set()
-        ctx.recheck_hints(team, slot)
+        ctx.recheck_hints(team, slot, updated_slots)
-        if old_hints != ctx.hints[team, slot]:
+        for hint_team, hint_slot in updated_slots:
-            ctx.on_changed_hints(team, slot)
+            ctx.on_changed_hints(hint_team, hint_slot)
        ctx.save()
-def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str]) -> typing.List[NetUtils.Hint]:
+def collect_hints(ctx: Context, team: int, slot: int, item: typing.Union[int, str], auto_status: HintStatus) \
        -> typing.List[Hint]:
    hints = []
    slots: typing.Set[int] = {slot}
    for group_id, group in ctx.groups.items():
@ -1045,31 +1135,58 @@ 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):
-        found = location_id in ctx.location_checks[team, finding_player]
+        prev_hint = ctx.get_hint(team, slot, location_id)
-        entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
+        if prev_hint:
-        hints.append(NetUtils.Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
+            hints.append(prev_hint)
-                                   item_flags))
+        else:
            found = location_id in ctx.location_checks[team, finding_player]
            entrance = ctx.er_hint_data.get(finding_player, {}).get(location_id, "")
            new_status = auto_status
            if found:
                new_status = HintStatus.HINT_FOUND
            elif item_flags & ItemClassification.trap:
                new_status = HintStatus.HINT_AVOID
            hints.append(Hint(receiving_player, finding_player, location_id, item_id, found, entrance,
                                       item_flags, new_status))
    return hints
-def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str) -> typing.List[NetUtils.Hint]:
+def collect_hint_location_name(ctx: Context, team: int, slot: int, location: str, auto_status: HintStatus) \
        -> typing.List[Hint]:
    seeked_location: int = ctx.location_names_for_game(ctx.games[slot])[location]
-    return collect_hint_location_id(ctx, team, slot, seeked_location)
+    return collect_hint_location_id(ctx, team, slot, seeked_location, auto_status)
-def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int) -> typing.List[NetUtils.Hint]:
+def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location: int, auto_status: HintStatus) \
        -> typing.List[Hint]:
    prev_hint = ctx.get_hint(team, slot, seeked_location)
    if prev_hint:
        return [prev_hint]
    result = ctx.locations[slot].get(seeked_location, (None, None, None))
    if any(result):
        item_id, receiving_player, item_flags = result
        found = seeked_location in ctx.location_checks[team, slot]
        entrance = ctx.er_hint_data.get(slot, {}).get(seeked_location, "")
-        return [NetUtils.Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags)]
+        new_status = auto_status
        if found:
            new_status = HintStatus.HINT_FOUND
        elif item_flags & ItemClassification.trap:
            new_status = HintStatus.HINT_AVOID
        return [Hint(receiving_player, slot, seeked_location, item_id, found, entrance, item_flags,
                              new_status)]
    return []
-def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
+status_names: typing.Dict[HintStatus, str] = {
    HintStatus.HINT_FOUND: "(found)",
    HintStatus.HINT_UNSPECIFIED: "(unspecified)",
    HintStatus.HINT_NO_PRIORITY: "(no priority)",
    HintStatus.HINT_AVOID: "(avoid)",
    HintStatus.HINT_PRIORITY: "(priority)",
 }
 def format_hint(ctx: Context, team: int, hint: Hint) -> str:
    text = f"[Hint]: {ctx.player_names[team, hint.receiving_player]}'s " \
           f"{ctx.item_names[ctx.slot_info[hint.receiving_player].game][hint.item]} is " \
           f"at {ctx.location_names[ctx.slot_info[hint.finding_player].game][hint.location]} " \
@ -1077,7 +1194,8 @@ def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
    if hint.entrance:
        text += f" at {hint.entrance}"
-    return text + (". (found)" if hint.found else ".")
+    
    return text + ". " + status_names.get(hint.status, "(unknown)")
 def json_format_send_event(net_item: NetworkItem, receiving_player: int):
@ -1132,7 +1250,10 @@ class CommandProcessor(metaclass=CommandMeta):
        if not raw:
            return
        try:
-            command = raw.split()
+            try:
                command = shlex.split(raw, comments=False)
            except ValueError:  # most likely: "ValueError: No closing quotation"
                command = raw.split()
            basecommand = command[0]
            if basecommand[0] == self.marker:
                method = self.commands.get(basecommand[1:].lower(), None)
@ -1203,6 +1324,10 @@ class CommonCommandProcessor(CommandProcessor):
            timer = int(seconds, 10)
        except ValueError:
            timer = 10
        else:
            if timer > 60 * 60:
                raise ValueError(f"{timer} is invalid. Maximum is 1 hour.")
        async_start(countdown(self.ctx, timer))
        return True
@ -1350,10 +1475,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
    def _cmd_remaining(self) -> bool:
        """List remaining items in your game, but not their location or recipient"""
        if self.ctx.remaining_mode == "enabled":
-            remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
+            rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
-            if remaining_item_ids:
+            if rest_locations:
-                self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.client.slot.game][item_id]
+                self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
-                                                            for item_id in remaining_item_ids))
+                                                            for slot, item_id in rest_locations))
            else:
                self.output("No remaining items found.")
            return True
@ -1363,10 +1488,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
            return False
        else:  # is goal
            if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
-                remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
+                rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
-                if remaining_item_ids:
+                if rest_locations:
-                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.client.slot.game][item_id]
+                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
-                                                                for item_id in remaining_item_ids))
+                                                                for slot, item_id in rest_locations))
                else:
                    self.output("No remaining items found.")
                return True
@ -1474,7 +1599,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
    def get_hints(self, input_text: str, for_location: bool = False) -> bool:
        points_available = get_client_points(self.ctx, self.client)
        cost = self.ctx.get_hint_cost(self.client.slot)
-
+        auto_status = HintStatus.HINT_UNSPECIFIED if for_location else HintStatus.HINT_PRIORITY
        if not input_text:
            hints = {hint.re_check(self.ctx, self.client.team) for hint in
                     self.ctx.hints[self.client.team, self.client.slot]}
@ -1500,9 +1625,9 @@ class ClientMessageProcessor(CommonCommandProcessor):
                self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
                hints = []
            elif not for_location:
-                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id)
+                hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)
            else:
-                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id)
+                hints = collect_hint_location_id(self.ctx, self.client.team, self.client.slot, hint_id, auto_status)
        else:
            game = self.ctx.games[self.client.slot]
@ -1522,16 +1647,16 @@ class ClientMessageProcessor(CommonCommandProcessor):
                    hints = []
                    for item_name in self.ctx.item_name_groups[game][hint_name]:
                        if item_name in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name))
+                            hints.extend(collect_hints(self.ctx, self.client.team, self.client.slot, item_name, auto_status))
                elif not for_location and hint_name in self.ctx.item_names_for_game(game):  # item name
-                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name)
+                    hints = collect_hints(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)
                elif hint_name in self.ctx.location_name_groups[game]:  # location group name
                    hints = []
                    for loc_name in self.ctx.location_name_groups[game][hint_name]:
                        if loc_name in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name))
+                            hints.extend(collect_hint_location_name(self.ctx, self.client.team, self.client.slot, loc_name, auto_status))
                else:  # location name
-                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name)
+                    hints = collect_hint_location_name(self.ctx, self.client.team, self.client.slot, hint_name, auto_status)
            else:
                self.output(response)
@ -1696,7 +1821,9 @@ 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 = 'TextOnly' in client.tags or 'Tracker' in client.tags
+            client.no_locations = "TextOnly" in client.tags or "Tracker" in client.tags
            # 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))
            connected_packet = {
                "cmd": "Connected",
                "team": client.team, "slot": client.slot,
@ -1769,6 +1896,9 @@ async def process_client_cmd(ctx: Context, client: Client, args: dict):
                client.tags = args["tags"]
                if set(old_tags) != set(client.tags):
                    client.no_locations = 'TextOnly' in client.tags or 'Tracker' in client.tags
                    client.no_text = "NoText" in client.tags or (
                        "PopTracker" in client.tags and client.version < (0, 5, 1)
                    )
                    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}.",
@ -1797,19 +1927,63 @@ 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": 'LocationScouts',
+                                        [{'cmd': 'InvalidPacket', "type": "arguments",
                                          "text": 'Locations has to be a list of integers',
                                          "original_cmd": cmd}])
                    return
                target_item, target_player, flags = ctx.locations[client.slot][location]
                if create_as_hint:
-                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location))
+                    hints.extend(collect_hint_location_id(ctx, client.team, client.slot, location,
                                                          HintStatus.HINT_UNSPECIFIED))
                locs.append(NetworkItem(target_item, location, target_player, flags))
            ctx.notify_hints(client.team, hints, only_new=create_as_hint == 2)
            if locs and create_as_hint:
                ctx.save()
            await ctx.send_msgs(client, [{'cmd': 'LocationInfo', 'locations': locs}])
        elif cmd == 'UpdateHint':
            location = args["location"]
            player = args["player"]
            status = args["status"]
            if not isinstance(player, int) or not isinstance(location, int) \
                    or (status is not None and not isinstance(status, int)):
                await ctx.send_msgs(client,
                                    [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'UpdateHint',
                                      "original_cmd": cmd}])
                return
            hint = ctx.get_hint(client.team, player, location)
            if not hint:
                return  # Ignored safely
            if client.slot not in ctx.slot_set(hint.receiving_player):
                await ctx.send_msgs(client,
                                    [{'cmd': 'InvalidPacket', "type": "arguments", "text": 'UpdateHint: No Permission',
                                      "original_cmd": cmd}])
                return
            new_hint = hint
            if status is None:
                return
            try:
                status = HintStatus(status)
            except ValueError:
                await ctx.send_msgs(client,
                                    [{'cmd': 'InvalidPacket', "type": "arguments",
                                      "text": 'UpdateHint: Invalid Status', "original_cmd": cmd}])
                return
            if status == HintStatus.HINT_FOUND:
                await ctx.send_msgs(client,
                                    [{'cmd': 'InvalidPacket', "type": "arguments",
                                      "text": 'UpdateHint: Cannot manually update status to "HINT_FOUND"', "original_cmd": cmd}])
                return
            new_hint = new_hint.re_prioritize(ctx, status)
            if hint == new_hint:
                return
            ctx.replace_hint(client.team, hint.finding_player, hint, new_hint)
            ctx.replace_hint(client.team, hint.receiving_player, hint, new_hint)
            ctx.save()
            ctx.on_changed_hints(client.team, hint.finding_player)
            ctx.on_changed_hints(client.team, hint.receiving_player)
        elif cmd == 'StatusUpdate':
            update_client_status(ctx, client, args["status"])
@ -1857,6 +2031,7 @@ 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"])
@ -1931,8 +2106,10 @@ class ServerCommandProcessor(CommonCommandProcessor):
    def _cmd_exit(self) -> bool:
        """Shutdown the server"""
-        self.ctx.server.ws_server.close()
+        try:
-        self.ctx.exit_event.set()
+            self.ctx.server.ws_server.close()
        finally:
            self.ctx.exit_event.set()
        return True
    @mark_raw
@ -2039,6 +2216,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
            item_name, usable, response = get_intended_text(item_name, names)
            if usable:
                amount: int = int(amount)
                if amount > 100:
                    raise ValueError(f"{amount} is invalid. Maximum is 100.")
                new_items = [NetworkItem(names[item_name], -1, 0) for _ in range(int(amount))]
                send_items_to(self.ctx, team, slot, *new_items)
@ -2110,9 +2289,9 @@ class ServerCommandProcessor(CommonCommandProcessor):
                    hints = []
                    for item_name_from_group in self.ctx.item_name_groups[game][item]:
                        if item_name_from_group in self.ctx.item_names_for_game(game):  # ensure item has an ID
-                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group))
+                            hints.extend(collect_hints(self.ctx, team, slot, item_name_from_group, HintStatus.HINT_PRIORITY))
                else:  # item name or id
-                    hints = collect_hints(self.ctx, team, slot, item)
+                    hints = collect_hints(self.ctx, team, slot, item, HintStatus.HINT_PRIORITY)
                if hints:
                    self.ctx.notify_hints(team, hints)
@ -2146,14 +2325,17 @@ class ServerCommandProcessor(CommonCommandProcessor):
            if usable:
                if isinstance(location, int):
-                    hints = collect_hint_location_id(self.ctx, team, slot, location)
+                    hints = collect_hint_location_id(self.ctx, team, slot, location,
                                                     HintStatus.HINT_UNSPECIFIED)
                elif game in self.ctx.location_name_groups and location in self.ctx.location_name_groups[game]:
                    hints = []
                    for loc_name_from_group in self.ctx.location_name_groups[game][location]:
                        if loc_name_from_group in self.ctx.location_names_for_game(game):
-                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group))
+                            hints.extend(collect_hint_location_name(self.ctx, team, slot, loc_name_from_group,
                                                                    HintStatus.HINT_UNSPECIFIED))
                else:
-                    hints = collect_hint_location_name(self.ctx, team, slot, location)
+                    hints = collect_hint_location_name(self.ctx, team, slot, location,
                                                       HintStatus.HINT_UNSPECIFIED)
                if hints:
                    self.ctx.notify_hints(team, hints)
                else:
@ -2243,6 +2425,8 @@ def parse_args() -> argparse.Namespace:
    parser.add_argument('--cert_key', help="Path to SSL Certificate Key file")
    parser.add_argument('--loglevel', default=defaults["loglevel"],
                        choices=['debug', 'info', 'warning', 'error', 'critical'])
    parser.add_argument('--logtime', help="Add timestamps to STDOUT",
                        default=defaults["logtime"], action='store_true')
    parser.add_argument('--location_check_points', default=defaults["location_check_points"], type=int)
    parser.add_argument('--hint_cost', default=defaults["hint_cost"], type=int)
    parser.add_argument('--disable_item_cheat', default=defaults["disable_item_cheat"], action='store_true')
@ -2323,7 +2507,9 @@ def load_server_cert(path: str, cert_key: typing.Optional[str]) -> "ssl.SSLConte
 async def main(args: argparse.Namespace):
-    Utils.init_logging("Server", loglevel=args.loglevel.lower())
+    Utils.init_logging(name="Server",
                       loglevel=args.loglevel.lower(),
                       add_timestamp=args.logtime)
    ctx = Context(args.host, args.port, args.server_password, args.password, args.location_check_points,
                  args.hint_cost, not args.disable_item_cheat, args.release_mode, args.collect_mode,
--- a/NetUtils.py
+++ b/NetUtils.py
@ -5,11 +5,20 @@ import enum
 import warnings
 from json import JSONEncoder, JSONDecoder
-import websockets
+if typing.TYPE_CHECKING:
    from websockets import WebSocketServerProtocol as ServerConnection
 from Utils import ByValue, Version
 class HintStatus(ByValue, enum.IntEnum):
    HINT_FOUND = 0
    HINT_UNSPECIFIED = 1
    HINT_NO_PRIORITY = 10
    HINT_AVOID = 20
    HINT_PRIORITY = 30
 class JSONMessagePart(typing.TypedDict, total=False):
    text: str
    # optional
@ -19,6 +28,8 @@ class JSONMessagePart(typing.TypedDict, total=False):
    player: int
    # if type == item indicates item flags
    flags: int
    # if type == hint_status
    hint_status: HintStatus
 class ClientStatus(ByValue, enum.IntEnum):
@ -79,6 +90,7 @@ class NetworkItem(typing.NamedTuple):
    item: int
    location: int
    player: int
    """ Sending player, except in LocationInfo (from LocationScouts), where it is the receiving player. """
    flags: int = 0
@ -140,7 +152,7 @@ decode = JSONDecoder(object_hook=_object_hook).decode
 class Endpoint:
-    socket: websockets.WebSocketServerProtocol
+    socket: "ServerConnection"
    def __init__(self, socket):
        self.socket = socket
@ -183,6 +195,7 @@ class JSONTypes(str, enum.Enum):
    location_name = "location_name"
    location_id = "location_id"
    entrance_name = "entrance_name"
    hint_status = "hint_status"
 class JSONtoTextParser(metaclass=HandlerMeta):
@ -223,7 +236,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
    def _handle_player_id(self, node: JSONMessagePart):
        player = int(node["text"])
-        node["color"] = 'magenta' if player == self.ctx.slot else 'yellow'
+        node["color"] = 'magenta' if self.ctx.slot_concerns_self(player) else 'yellow'
        node["text"] = self.ctx.player_names[player]
        return self._handle_color(node)
@ -264,6 +277,10 @@ class JSONtoTextParser(metaclass=HandlerMeta):
        node["color"] = 'blue'
        return self._handle_color(node)
    def _handle_hint_status(self, node: JSONMessagePart):
        node["color"] = status_colors.get(node["hint_status"], "red")
        return self._handle_color(node)
 class RawJSONtoTextParser(JSONtoTextParser):
    def _handle_color(self, node: JSONMessagePart):
@ -272,7 +289,8 @@ class RawJSONtoTextParser(JSONtoTextParser):
 color_codes = {'reset': 0, 'bold': 1, 'underline': 4, 'black': 30, 'red': 31, 'green': 32, 'yellow': 33, 'blue': 34,
               'magenta': 35, 'cyan': 36, 'white': 37, 'black_bg': 40, 'red_bg': 41, 'green_bg': 42, 'yellow_bg': 43,
-               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
+               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47,
               'plum': 35, 'slateblue': 34, 'salmon': 31,}  # convert ui colors to terminal colors
 def color_code(*args):
@ -295,6 +313,27 @@ def add_json_location(parts: list, location_id: int, player: int = 0, **kwargs)
    parts.append({"text": str(location_id), "player": player, "type": JSONTypes.location_id, **kwargs})
 status_names: typing.Dict[HintStatus, str] = {
    HintStatus.HINT_FOUND: "(found)",
    HintStatus.HINT_UNSPECIFIED: "(unspecified)",
    HintStatus.HINT_NO_PRIORITY: "(no priority)",
    HintStatus.HINT_AVOID: "(avoid)",
    HintStatus.HINT_PRIORITY: "(priority)",
 }
 status_colors: typing.Dict[HintStatus, str] = {
    HintStatus.HINT_FOUND: "green",
    HintStatus.HINT_UNSPECIFIED: "white",
    HintStatus.HINT_NO_PRIORITY: "slateblue",
    HintStatus.HINT_AVOID: "salmon",
    HintStatus.HINT_PRIORITY: "plum",
 }
 def add_json_hint_status(parts: list, hint_status: HintStatus, text: typing.Optional[str] = None, **kwargs):
    parts.append({"text": text if text != None else status_names.get(hint_status, "(unknown)"),
                  "hint_status": hint_status, "type": JSONTypes.hint_status, **kwargs})
 class Hint(typing.NamedTuple):
    receiving_player: int
    finding_player: int
@ -303,14 +342,21 @@ class Hint(typing.NamedTuple):
    found: bool
    entrance: str = ""
    item_flags: int = 0
    status: HintStatus = HintStatus.HINT_UNSPECIFIED
    def re_check(self, ctx, team) -> Hint:
-        if self.found:
+        if self.found and self.status == HintStatus.HINT_FOUND:
            return self
        found = self.location in ctx.location_checks[team, self.finding_player]
        if found:
-            return Hint(self.receiving_player, self.finding_player, self.location, self.item, found, self.entrance,
+            return self._replace(found=found, status=HintStatus.HINT_FOUND)
-                        self.item_flags)
+        return self
    def re_prioritize(self, ctx, status: HintStatus) -> Hint:
        if self.found and status != HintStatus.HINT_FOUND:
            status = HintStatus.HINT_FOUND
        if status != self.status:
            return self._replace(status=status)
        return self
    def __hash__(self):
@ -332,10 +378,7 @@ class Hint(typing.NamedTuple):
        else:
            add_json_text(parts, "'s World")
        add_json_text(parts, ". ")
-        if self.found:
+        add_json_hint_status(parts, self.status)
            add_json_text(parts, "(found)", type="color", color="green")
        else:
            add_json_text(parts, "(not found)", type="color", color="red")
        return {"cmd": "PrintJSON", "data": parts, "type": "Hint",
                "receiving": self.receiving_player,
@ -381,6 +424,8 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
        checked = state[team, slot]
        if not checked:
            # This optimizes the case where everyone connects to a fresh game at the same time.
            if slot not in self:
                raise KeyError(slot)
            return []
        return [location_id for
                location_id in self[slot] if
@ -397,12 +442,12 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
                location_id not in checked]
    def get_remaining(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
-                      ) -> typing.List[int]:
+                      ) -> typing.List[typing.Tuple[int, int]]:
        checked = state[team, slot]
        player_locations = self[slot]
-        return sorted([player_locations[location_id][0] for
+        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
-                       location_id in player_locations if
+                        location_id in player_locations if
-                       location_id not in checked])
+                        location_id not in checked])
 if typing.TYPE_CHECKING:  # type-check with pure python implementation until we have a typing stub
--- a/OoTAdjuster.py
+++ b/OoTAdjuster.py
@ -1,7 +1,6 @@
 import tkinter as tk
 import argparse
 import logging
 import random
 import os
 import zipfile
 from itertools import chain
@ -197,7 +196,6 @@ 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()):
--- a/Options.py
+++ b/Options.py
@ -8,16 +8,17 @@ import numbers
 import random
 import typing
 import enum
 from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass
 from schema import And, Optional, Or, Schema
 from typing_extensions import Self
-from Utils import get_fuzzy_results, is_iterable_except_str
+from Utils import get_file_safe_name, get_fuzzy_results, is_iterable_except_str, output_path
 if typing.TYPE_CHECKING:
-    from BaseClasses import PlandoOptions
+    from BaseClasses import MultiWorld, PlandoOptions
    from worlds.AutoWorld import World
    import pathlib
@ -53,8 +54,8 @@ class AssembleOptions(abc.ABCMeta):
        attrs["name_lookup"].update({option_id: name for name, option_id in new_options.items()})
        options.update(new_options)
        # apply aliases, without name_lookup
-        aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
+        aliases = attrs["aliases"] = {name[6:].lower(): option_id for name, option_id in attrs.items() if
-                   name.startswith("alias_")}
+                                      name.startswith("alias_")}
        assert (
            name in {"Option", "VerifyKeys"} or  # base abstract classes don't need default
@ -126,10 +127,28 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
    # can be weighted between selections
    supports_weighting = True
    rich_text_doc: typing.Optional[bool] = None
    """Whether the WebHost should render the Option's docstring as rich text.
    If this is True, the Option's docstring is interpreted as reStructuredText_,
    the standard Python markup format. In the WebHost, it's rendered to HTML so
    that lists, emphasis, and other rich text features are displayed properly.
    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
    backwards compatibility, this defaults to False, but worlds are encouraged to
    set it to True and use reStructuredText for their Option documentation.
    .. _reStructuredText: https://docutils.sourceforge.io/rst.html
    """
    # filled by AssembleOptions:
    name_lookup: typing.ClassVar[typing.Dict[T, str]]  # type: ignore
    # https://github.com/python/typing/discussions/1460 the reason for this type: ignore
    options: typing.ClassVar[typing.Dict[str, int]]
    aliases: typing.ClassVar[typing.Dict[str, int]]
    def __repr__(self) -> str:
        return f"{self.__class__.__name__}({self.current_option_name})"
@ -477,7 +496,7 @@ class TextChoice(Choice):
    def __init__(self, value: typing.Union[str, int]):
        assert isinstance(value, str) or isinstance(value, int), \
-            f"{value} is not a valid option for {self.__class__.__name__}"
+            f"'{value}' is not a valid option for '{self.__class__.__name__}'"
        self.value = value
    @property
@ -598,17 +617,17 @@ class PlandoBosses(TextChoice, metaclass=BossMeta):
                used_locations.append(location)
                used_bosses.append(boss)
                if not cls.valid_boss_name(boss):
-                    raise ValueError(f"{boss.title()} is not a valid boss name.")
+                    raise ValueError(f"'{boss.title()}' is not a valid boss name.")
                if not cls.valid_location_name(location):
-                    raise ValueError(f"{location.title()} is not a valid boss location name.")
+                    raise ValueError(f"'{location.title()}' is not a valid boss location name.")
                if not cls.can_place_boss(boss, location):
-                    raise ValueError(f"{location.title()} is not a valid location for {boss.title()} to be placed.")
+                    raise ValueError(f"'{location.title()}' is not a valid location for {boss.title()} to be placed.")
            else:
                if cls.duplicate_bosses:
                    if not cls.valid_boss_name(option):
-                        raise ValueError(f"{option} is not a valid boss name.")
+                        raise ValueError(f"'{option}' is not a valid boss name.")
                else:
-                    raise ValueError(f"{option.title()} is not formatted correctly.")
+                    raise ValueError(f"'{option.title()}' is not formatted correctly.")
    @classmethod
    def can_place_boss(cls, boss: str, location: str) -> bool:
@ -670,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, cls.range_start))
+            return cls(cls.triangular(cls.range_start, cls.range_end, 0.0))
        elif text == "random-high":
-            return cls(cls.triangular(cls.range_start, cls.range_end, cls.range_end))
+            return cls(cls.triangular(cls.range_start, cls.range_end, 1.0))
        elif text == "random-middle":
            return cls(cls.triangular(cls.range_start, cls.range_end))
        elif text.startswith("random-range-"):
@ -698,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], random_range[0]))
+            return cls(cls.triangular(random_range[0], random_range[1], 0.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], random_range[1]))
+            return cls(cls.triangular(random_range[0], random_range[1], 1.0))
        else:
            return cls(random.randint(random_range[0], random_range[1]))
@ -720,8 +739,16 @@ class Range(NumericOption):
        return str(self.value)
    @staticmethod
-    def triangular(lower: int, end: int, tri: typing.Optional[int] = None) -> int:
+    def triangular(lower: int, end: int, tri: float = 0.5) -> int:
-        return int(round(random.triangular(lower, end, tri), 0))
+        """
        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))
 class NamedRange(Range):
@ -735,6 +762,12 @@ class NamedRange(Range):
        elif value > self.range_end and value not in self.special_range_names.values():
            raise Exception(f"{value} is higher than maximum {self.range_end} for option {self.__class__.__name__} " +
                            f"and is also not one of the supported named special values: {self.special_range_names}")
        # See docstring
        for key in self.special_range_names:
            if key != key.lower():
                raise Exception(f"{self.__class__.__name__} has an invalid special_range_names key: {key}. "
                                f"NamedRange keys must use only lowercase letters, and ideally should be snake_case.")
        self.value = value
    @classmethod
@ -762,17 +795,22 @@ class VerifyKeys(metaclass=FreezeValidKeys):
    verify_location_name: bool = False
    value: typing.Any
-    @classmethod
+    def verify_keys(self) -> None:
-    def verify_keys(cls, data: typing.Iterable[str]) -> None:
+        if self.valid_keys:
-        if cls.valid_keys:
+            data = set(self.value)
-            data = set(data)
+            dataset = set(word.casefold() for word in data) if self.valid_keys_casefold else set(data)
-            dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
+            extra = dataset - self._valid_keys
            extra = dataset - cls._valid_keys
            if extra:
-                raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
+                raise OptionError(
-                                f"Allowed keys: {cls._valid_keys}.")
+                    f"Found unexpected key {', '.join(extra)} in {getattr(self, 'display_name', self)}. "
                    f"Allowed keys: {self._valid_keys}."
                )
    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
        try:
            self.verify_keys()
        except OptionError as validation_error:
            raise OptionError(f"Player {player_name} has invalid option keys:\n{validation_error}")
        if self.convert_name_groups and self.verify_item_name:
            new_value = type(self.value)()  # empty container of whatever value is
            for item_name in self.value:
@ -787,17 +825,20 @@ class VerifyKeys(metaclass=FreezeValidKeys):
            for item_name in self.value:
                if item_name not in world.item_names:
                    picks = get_fuzzy_results(item_name, world.item_names, limit=1)
-                    raise Exception(f"Item {item_name} from option {self} "
+                    raise Exception(f"Item '{item_name}' from option '{self}' "
-                                    f"is not a valid item name from {world.game}. "
+                                    f"is not a valid item name from '{world.game}'. "
                                    f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure)")
        elif self.verify_location_name:
            for location_name in self.value:
                if location_name not in world.location_names:
                    picks = get_fuzzy_results(location_name, world.location_names, limit=1)
-                    raise Exception(f"Location {location_name} from option {self} "
+                    raise Exception(f"Location '{location_name}' from option '{self}' "
-                                    f"is not a valid location name from {world.game}. "
+                                    f"is not a valid location name from '{world.game}'. "
                                    f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure)")
    def __iter__(self) -> typing.Iterator[typing.Any]:
        return self.value.__iter__()
 class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mapping[str, typing.Any]):
    default = {}
@ -809,7 +850,6 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
    @classmethod
    def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
        if type(data) == dict:
            cls.verify_keys(data)
            return cls(data)
        else:
            raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
@ -831,6 +871,8 @@ class ItemDict(OptionDict):
    verify_item_name = True
    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)
@ -855,7 +897,6 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
    @classmethod
    def from_any(cls, data: typing.Any):
        if is_iterable_except_str(data):
            cls.verify_keys(data)
            return cls(data)
        return cls.from_text(str(data))
@ -881,7 +922,6 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
    @classmethod
    def from_any(cls, data: typing.Any):
        if is_iterable_except_str(data):
            cls.verify_keys(data)
            return cls(data)
        return cls.from_text(str(data))
@ -924,6 +964,19 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
            self.value = []
            logging.warning(f"The plando texts module is turned off, "
                            f"so text for {player_name} will be ignored.")
        else:
            super().verify(world, player_name, plando_options)
    def verify_keys(self) -> None:
        if self.valid_keys:
            data = set(text.at for text in self)
            dataset = set(word.casefold() for word in data) if self.valid_keys_casefold else set(data)
            extra = dataset - self._valid_keys
            if extra:
                raise OptionError(
                    f"Invalid \"at\" placement {', '.join(extra)} in {getattr(self, 'display_name', self)}. "
                    f"Allowed placements: {self._valid_keys}."
                )
    @classmethod
    def from_any(cls, data: PlandoTextsFromAnyType) -> Self:
@ -934,7 +987,19 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                    if random.random() < float(text.get("percentage", 100)/100):
                        at = text.get("at", None)
                        if at is not None:
                            if isinstance(at, dict):
                                if at:
                                    at = random.choices(list(at.keys()),
                                                        weights=list(at.values()), k=1)[0]
                                else:
                                    raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                            given_text = text.get("text", [])
                            if isinstance(given_text, dict):
                                if not given_text:
                                    given_text = []
                                else:
                                    given_text = random.choices(list(given_text.keys()),
                                                                weights=list(given_text.values()), k=1)
                            if isinstance(given_text, str):
                                given_text = [given_text]
                            texts.append(PlandoText(
@ -942,12 +1007,13 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                                given_text,
                                text.get("percentage", 100)
                            ))
                        else:
                            raise OptionError("\"at\" must be a valid string or weighted list of strings!")
                elif isinstance(text, PlandoText):
                    if random.random() < float(text.percentage/100):
                        texts.append(text)
                else:
                    raise Exception(f"Cannot create plando text from non-dictionary type, got {type(text)}")
            cls.verify_keys([text.at for text in texts])
            return cls(texts)
        else:
            raise NotImplementedError(f"Cannot Convert from non-list, got {type(data)}")
@ -1053,11 +1119,11 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
            used_entrances.append(entrance)
            used_exits.append(exit)
            if not cls.validate_entrance_name(entrance):
-                raise ValueError(f"{entrance.title()} is not a valid entrance.")
+                raise ValueError(f"'{entrance.title()}' is not a valid entrance.")
            if not cls.validate_exit_name(exit):
-                raise ValueError(f"{exit.title()} is not a valid exit.")
+                raise ValueError(f"'{exit.title()}' is not a valid exit.")
            if not cls.can_connect(entrance, exit):
-                raise ValueError(f"Connection between {entrance.title()} and {exit.title()} is invalid.")
+                raise ValueError(f"Connection between '{entrance.title()}' and '{exit.title()}' is invalid.")
    @classmethod
    def from_any(cls, data: PlandoConFromAnyType) -> Self:
@ -1120,27 +1186,48 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
 class Accessibility(Choice):
-    """Set rules for reachability of your items/locations.
+    """
-    Locations: ensure everything can be reached and acquired.
+    Set rules for reachability of your items/locations.
-    Items: ensure all logically relevant items can be acquired.
+
-    Minimal: ensure what is needed to reach your goal can be acquired."""
+    **Full:** ensure everything can be reached and acquired.
    **Minimal:** ensure what is needed to reach your goal can be acquired.
    """
    display_name = "Accessibility"
-    option_locations = 0
+    rich_text_doc = True
-    option_items = 1
+    option_full = 0
    option_minimal = 2
    alias_none = 2
    alias_locations = 0
    alias_items = 0
    default = 0
 class ItemsAccessibility(Accessibility):
    """
    Set rules for reachability of your items/locations.
    **Full:** ensure everything can be reached and acquired.
    **Minimal:** ensure what is needed to reach your goal can be acquired.
    **Items:** ensure all logically relevant items can be acquired. Some items, such as keys, may be self-locking, and
    some locations may be inaccessible.
    """
    option_items = 1
    default = 1
 class ProgressionBalancing(NamedRange):
-    """
+    """A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
-    A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
+
    A lower setting means more getting stuck. A higher setting means less getting stuck.
    """
    default = 50
    range_start = 0
    range_end = 99
    display_name = "Progression Balancing"
    rich_text_doc = True
    special_range_names = {
        "disabled": 0,
        "normal": 50,
@ -1170,13 +1257,18 @@ class CommonOptions(metaclass=OptionsMetaProperty):
    progression_balancing: ProgressionBalancing
    accessibility: Accessibility
-    def as_dict(self, *option_names: str, casing: str = "snake") -> typing.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 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 in type(self).type_hints:
@ -1196,6 +1288,8 @@ class CommonOptions(metaclass=OptionsMetaProperty):
                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"{option_name} not found in {tuple(type(self).type_hints)}")
@ -1205,29 +1299,36 @@ class CommonOptions(metaclass=OptionsMetaProperty):
 class LocalItems(ItemSet):
    """Forces these items to be in their native world."""
    display_name = "Local Items"
    rich_text_doc = True
 class NonLocalItems(ItemSet):
    """Forces these items to be outside their native world."""
    display_name = "Non-local Items"
    rich_text_doc = True
 class StartInventory(ItemDict):
    """Start with these items."""
    verify_item_name = True
    display_name = "Start Inventory"
    rich_text_doc = True
 class StartInventoryPool(StartInventory):
    """Start with these items and don't place them in the world.
-    The game decides what the replacement items will be."""
+
    The game decides what the replacement items will be.
    """
    verify_item_name = True
    display_name = "Start Inventory from Pool"
    rich_text_doc = True
 class StartHints(ItemSet):
-    """Start with these item's locations prefilled into the !hint command."""
+    """Start with these item's locations prefilled into the ``!hint`` command."""
    display_name = "Start Hints"
    rich_text_doc = True
 class LocationSet(OptionSet):
@ -1236,28 +1337,33 @@ class LocationSet(OptionSet):
 class StartLocationHints(LocationSet):
-    """Start with these locations and their item prefilled into the !hint command"""
+    """Start with these locations and their item prefilled into the ``!hint`` command."""
    display_name = "Start Location Hints"
    rich_text_doc = True
 class ExcludeLocations(LocationSet):
-    """Prevent these locations from having an important item"""
+    """Prevent these locations from having an important item."""
    display_name = "Excluded Locations"
    rich_text_doc = True
 class PriorityLocations(LocationSet):
-    """Prevent these locations from having an unimportant item"""
+    """Prevent these locations from having an unimportant item."""
    display_name = "Priority Locations"
    rich_text_doc = True
 class DeathLink(Toggle):
-    """When you die, everyone dies. Of course the reverse is true too."""
+    """When you die, everyone who enabled death link dies. Of course, the reverse is true too."""
    display_name = "Death Link"
    rich_text_doc = True
 class ItemLinks(OptionList):
    """Share part of your item pool with other players."""
    display_name = "Item Links"
    rich_text_doc = True
    default = []
    schema = Schema([
        {
@ -1281,8 +1387,8 @@ class ItemLinks(OptionList):
                picks_group = get_fuzzy_results(item_name, world.item_name_groups.keys(), limit=1)
                picks_group = f" or '{picks_group[0][0]}' ({picks_group[0][1]}% sure)" if allow_item_groups else ""
-                raise Exception(f"Item {item_name} from item link {item_link} "
+                raise Exception(f"Item '{item_name}' from item link '{item_link}' "
-                                f"is not a valid item from {world.game} for {pool_name}. "
+                                f"is not a valid item from '{world.game}' for '{pool_name}'. "
                                f"Did you mean '{picks[0][0]}' ({picks[0][1]}% sure){picks_group}")
            if allow_item_groups:
                pool |= world.item_name_groups.get(item_name, {item_name})
@ -1324,6 +1430,7 @@ class ItemLinks(OptionList):
 class Removed(FreeText):
    """This Option has been Removed."""
    rich_text_doc = True
    default = ""
    visibility = Visibility.none
@ -1372,22 +1479,26 @@ it.
 def get_option_groups(world: typing.Type[World], visibility_level: Visibility = Visibility.template) -> typing.Dict[
        str, typing.Dict[str, typing.Type[Option[typing.Any]]]]:
    """Generates and returns a dictionary for the option groups of a specified world."""
-    option_groups = {option: option_group.name
+    option_to_name = {option: option_name for option_name, option in world.options_dataclass.type_hints.items()}
-                     for option_group in world.web.option_groups
+
-                     for option in option_group.options}
+    ordered_groups = {group.name: group.options for group in world.web.option_groups}
    # add a default option group for uncategorized options to get thrown into
-    ordered_groups = ["Game Options"]
+    if "Game Options" not in ordered_groups:
-    [ordered_groups.append(group) for group in option_groups.values() if group not in ordered_groups]
+        grouped_options = set(option for group in ordered_groups.values() for option in group)
-    grouped_options = {group: {} for group in ordered_groups}
+        ungrouped_options = [option for option in option_to_name if option not in grouped_options]
-    for option_name, option in world.options_dataclass.type_hints.items():
+        # only add the game options group if we have ungrouped options
-        if visibility_level & option.visibility:
+        if ungrouped_options:
-            grouped_options[option_groups.get(option, "Game Options")][option_name] = option
+            ordered_groups = {**{"Game Options": ungrouped_options}, **ordered_groups}
-    # if the world doesn't have any ungrouped options, this group will be empty so just remove it
+    return {
-    if not grouped_options["Game Options"]:
+        group: {
-        del grouped_options["Game Options"]
+            option_to_name[option]: option
-
+            for option in group_options
-    return grouped_options
+            if (visibility_level in option.visibility and option in option_to_name)
        }
        for group, group_options in ordered_groups.items()
    }
 def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], generate_hidden: bool = True) -> None:
@ -1426,46 +1537,61 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
        return data, notes
    def yaml_dump_scalar(scalar) -> str:
        # yaml dump may add end of document marker and newlines.
        return yaml.dump(scalar).replace("...\n", "").strip()
    for game_name, world in AutoWorldRegister.world_types.items():
        if not world.hidden or generate_hidden:
-            grouped_options = get_option_groups(world)
+            option_groups = get_option_groups(world)
            with open(local_path("data", "options.yaml")) as f:
                file_data = f.read()
            res = Template(file_data).render(
-                option_groups=grouped_options,
+                option_groups=option_groups,
-                __version__=__version__, game=game_name, yaml_dump=yaml.dump,
+                __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
                dictify_range=dictify_range,
            )
            del file_data
-            with open(os.path.join(target_folder, game_name + ".yaml"), "w", encoding="utf-8-sig") as f:
+            with open(os.path.join(target_folder, get_file_safe_name(game_name) + ".yaml"), "w", encoding="utf-8-sig") as f:
                f.write(res)
-if __name__ == "__main__":
+def dump_player_options(multiworld: MultiWorld) -> None:
    from csv import DictWriter
-    from worlds.alttp.Options import Logic
+    game_players = defaultdict(list)
-    import argparse
+    for player, game in multiworld.game.items():
        game_players[game].append(player)
    game_players = dict(sorted(game_players.items()))
-    map_shuffle = Toggle
+    output = []
-    compass_shuffle = Toggle
+    per_game_option_names = [
-    key_shuffle = Toggle
+        getattr(option, "display_name", option_key)
-    big_key_shuffle = Toggle
+        for option_key, option in PerGameCommonOptions.type_hints.items()
-    hints = Toggle
+    ]
-    test = argparse.Namespace()
+    all_option_names = per_game_option_names.copy()
-    test.logic = Logic.from_text("no_logic")
+    for game, players in game_players.items():
-    test.map_shuffle = map_shuffle.from_text("ON")
+        game_option_names = per_game_option_names.copy()
-    test.hints = hints.from_text('OFF')
+        for player in players:
-    try:
+            world = multiworld.worlds[player]
-        test.logic = Logic.from_text("overworld_glitches_typo")
+            player_output = {
-    except KeyError as e:
+                "Game": multiworld.game[player],
-        print(e)
+                "Name": multiworld.get_player_name(player),
-    try:
+            }
-        test.logic_owg = Logic.from_text("owg")
+            output.append(player_output)
-    except KeyError as e:
+            for option_key, option in world.options_dataclass.type_hints.items():
-        print(e)
+                if option.visibility == Visibility.none:
-    if test.map_shuffle:
+                    continue
-        print("map_shuffle is on")
+                display_name = getattr(option, "display_name", option_key)
-    print(f"Hints are {bool(test.hints)}")
+                player_output[display_name] = getattr(world.options, option_key).current_option_name
-    print(test)
+                if display_name not in game_option_names:
                    all_option_names.append(display_name)
                    game_option_names.append(display_name)
    with open(output_path(f"generate_{multiworld.seed_name}.csv"), mode="w", newline="") as file:
        fields = ["Game", "Name", *all_option_names]
        writer = DictWriter(file, fields)
        writer.writeheader()
        writer.writerows(output)
--- a/README.md
+++ b/README.md
@ -72,6 +72,14 @@ Currently, the following games are supported:
 * Aquaria
 * Yu-Gi-Oh! Ultimate Masters: World Championship Tournament 2006
 * A Hat in Time
 * Old School Runescape
 * Kingdom Hearts 1
 * Mega Man 2
 * Yacht Dice
 * Faxanadu
 * Saving Princess
 * Castlevania: Circle of the Moon
 * Inscryption
 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
--- a/SNIClient.py
+++ b/SNIClient.py
@ -244,6 +244,9 @@ class SNIContext(CommonContext):
                # this will no longer be needed.
                async_start(self.send_msgs([{"cmd": "LocationScouts", "locations": list(new_locations)}]))
        if self.client_handler is not None:
            self.client_handler.on_package(self, cmd, args)
    def run_gui(self) -> None:
        from kvui import GameManager
@ -633,7 +636,13 @@ async def game_watcher(ctx: SNIContext) -> None:
        if not ctx.client_handler:
            continue
-        rom_validated = await ctx.client_handler.validate_rom(ctx)
+        try:
            rom_validated = await ctx.client_handler.validate_rom(ctx)
        except Exception as e:
            snes_logger.error(f"An error occurred, see logs for details: {e}")
            text_file_logger = logging.getLogger()
            text_file_logger.exception(e)
            rom_validated = False
        if not rom_validated or (ctx.auth and ctx.auth != ctx.rom):
            snes_logger.warning("ROM change detected, please reconnect to the multiworld server")
@ -649,7 +658,13 @@ async def game_watcher(ctx: SNIContext) -> None:
        perf_counter = time.perf_counter()
-        await ctx.client_handler.game_watcher(ctx)
+        try:
            await ctx.client_handler.game_watcher(ctx)
        except Exception as e:
            snes_logger.error(f"An error occurred, see logs for details: {e}")
            text_file_logger = logging.getLogger()
            text_file_logger.exception(e)
            await snes_disconnect(ctx)
 async def run_game(romfile: str) -> None:
--- a/UndertaleClient.py
+++ b/UndertaleClient.py
@ -29,7 +29,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
    def _cmd_patch(self):
        """Patch the game. Only use this command if /auto_patch fails."""
        if isinstance(self.ctx, UndertaleContext):
-            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=Utils.user_path("Undertale"), exist_ok=True)
            self.ctx.patch_game()
            self.output("Patched.")
@ -43,7 +43,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
    def _cmd_auto_patch(self, steaminstall: typing.Optional[str] = None):
        """Patch the game automatically."""
        if isinstance(self.ctx, UndertaleContext):
-            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=Utils.user_path("Undertale"), exist_ok=True)
            tempInstall = steaminstall
            if not os.path.isfile(os.path.join(tempInstall, "data.win")):
                tempInstall = None
@ -62,7 +62,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
                for file_name in os.listdir(tempInstall):
                    if file_name != "steam_api.dll":
                        shutil.copy(os.path.join(tempInstall, file_name),
-                               os.path.join(os.getcwd(), "Undertale", file_name))
+                               Utils.user_path("Undertale", file_name))
                self.ctx.patch_game()
                self.output("Patching successful!")
@ -111,12 +111,12 @@ class UndertaleContext(CommonContext):
        self.save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
    def patch_game(self):
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
+        with open(Utils.user_path("Undertale", "data.win"), "rb") as f:
            patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
+        with open(Utils.user_path("Undertale", "data.win"), "wb") as f:
            f.write(patchedFile)
-        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
+        os.makedirs(name=Utils.user_path("Undertale", "Custom Sprites"), exist_ok=True)
-        with open(os.path.expandvars(os.path.join(os.getcwd(), "Undertale", "Custom Sprites",
+        with open(os.path.expandvars(Utils.user_path("Undertale", "Custom Sprites",
                                     "Which Character.txt")), "w") as f:
            f.writelines(["// Put the folder name of the sprites you want to play as, make sure it is the only "
                          "line other than this one.\n", "frisk"])
@ -247,8 +247,8 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
            with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
                toDraw = ""
                for i in range(20):
-                    if i < len(str(ctx.item_names.lookup_in_slot(l.item))):
+                    if i < len(str(ctx.item_names.lookup_in_game(l.item))):
-                        toDraw += str(ctx.item_names.lookup_in_slot(l.item))[i]
+                        toDraw += str(ctx.item_names.lookup_in_game(l.item))[i]
                    else:
                        break
                f.write(toDraw)
--- a/Utils.py
+++ b/Utils.py
@ -18,8 +18,8 @@ import warnings
 from argparse import Namespace
 from settings import Settings, get_settings
-from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union
+from time import sleep
-from typing_extensions import TypeGuard
+from typing import BinaryIO, Coroutine, Optional, Set, Dict, Any, Union, TypeGuard
 from yaml import load, load_all, dump
 try:
@ -31,6 +31,7 @@ if typing.TYPE_CHECKING:
    import tkinter
    import pathlib
    from BaseClasses import Region
    import multiprocessing
 def tuplize_version(version: str) -> Version:
@ -46,7 +47,7 @@ class Version(typing.NamedTuple):
        return ".".join(str(item) for item in self)
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 version_tuple = tuplize_version(__version__)
 is_linux = sys.platform.startswith("linux")
@ -151,8 +152,15 @@ def home_path(*path: str) -> str:
    if hasattr(home_path, 'cached_path'):
        pass
    elif sys.platform.startswith('linux'):
-        home_path.cached_path = os.path.expanduser('~/Archipelago')
+        xdg_data_home = os.getenv('XDG_DATA_HOME', os.path.expanduser('~/.local/share'))
-        os.makedirs(home_path.cached_path, 0o700, exist_ok=True)
+        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)
    else:
        # not implemented
        home_path.cached_path = local_path()  # this will generate the same exceptions we got previously
@ -420,10 +428,11 @@ class RestrictedUnpickler(pickle.Unpickler):
        if module == "builtins" and name in safe_builtins:
            return getattr(builtins, name)
        # used by MultiServer -> savegame/multidata
-        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
+        if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint",
                                             "SlotType", "NetworkSlot", "HintStatus"}:
            return getattr(self.net_utils_module, name)
        # Options and Plando are unpickled by WebHost -> Generate
-        if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
+        if module == "worlds.generic" and name == "PlandoItem":
            if not self.generic_properties_module:
                self.generic_properties_module = importlib.import_module("worlds.generic")
            return getattr(self.generic_properties_module, name)
@ -434,7 +443,7 @@ class RestrictedUnpickler(pickle.Unpickler):
            else:
                mod = importlib.import_module(module)
            obj = getattr(mod, name)
-            if issubclass(obj, self.options_module.Option):
+            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")
@ -483,9 +492,9 @@ def get_text_after(text: str, start: str) -> str:
 loglevel_mapping = {'error': logging.ERROR, 'info': logging.INFO, 'warning': logging.WARNING, 'debug': logging.DEBUG}
-def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, write_mode: str = "w",
+def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO,
-                 log_format: str = "[%(name)s at %(asctime)s]: %(message)s",
+                 write_mode: str = "w", log_format: str = "[%(name)s at %(asctime)s]: %(message)s",
-                 exception_logger: typing.Optional[str] = None):
+                 add_timestamp: bool = False, exception_logger: typing.Optional[str] = None):
    import datetime
    loglevel: int = loglevel_mapping.get(loglevel, loglevel)
    log_folder = user_path("logs")
@ -512,11 +521,15 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
        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("NoStream", lambda record: not getattr(record, "NoFile", False)))
    file_handler.addFilter(Filter("NoCarriageReturn", lambda record: '\r' not in record.getMessage()))
    root_logger.addHandler(file_handler)
    if sys.stdout:
        formatter = logging.Formatter(fmt='[%(asctime)s] %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
        stream_handler = logging.StreamHandler(sys.stdout)
        stream_handler.addFilter(Filter("NoFile", lambda record: not getattr(record, "NoStream", False)))
        if add_timestamp:
            stream_handler.setFormatter(formatter)
        root_logger.addHandler(stream_handler)
    # Relay unhandled exceptions to logger.
@ -528,7 +541,8 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
                sys.__excepthook__(exc_type, exc_value, exc_traceback)
                return
            logging.getLogger(exception_logger).exception("Uncaught exception",
-                                                          exc_info=(exc_type, exc_value, exc_traceback))
+                                                          exc_info=(exc_type, exc_value, exc_traceback),
                                                          extra={"NoStream": exception_logger is None})
            return orig_hook(exc_type, exc_value, exc_traceback)
        handle_exception._wrapped = True
@ -551,7 +565,7 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
    import platform
    logging.info(
        f"Archipelago ({__version__}) logging initialized"
-        f" on {platform.platform()}"
+        f" on {platform.platform()} process {os.getpid()}"
        f" running Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
        f"{' (frozen)' if is_frozen() else ''}"
    )
@ -567,6 +581,8 @@ def stream_input(stream: typing.TextIO, queue: "asyncio.Queue[str]"):
            else:
                if text:
                    queue.put_nowait(text)
                else:
                    sleep(0.01)  # non-blocking stream
    from threading import Thread
    thread = Thread(target=queuer, name=f"Stream handler for {stream.name}", daemon=True)
@ -664,6 +680,19 @@ def get_input_text_from_response(text: str, command: str) -> typing.Optional[str
    return None
 def is_kivy_running() -> bool:
    if "kivy" in sys.modules:
        from kivy.app import App
        return App.get_running_app() is not None
    return False
 def _mp_open_filename(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
    if is_kivy_running():
        raise RuntimeError("kivy should not be running in multiprocess")
    res.put(open_filename(*args))
 def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
        -> typing.Optional[str]:
    logging.info(f"Opening file input dialog for {title}.")
@ -693,6 +722,13 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
                      f'This attempt was made because open_filename was used for "{title}".')
        raise e
    else:
        if is_macos and is_kivy_running():
            # on macOS, mixing kivy and tk does not work, so spawn a new process
            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
            from multiprocessing import Process, Queue
            res: "Queue[typing.Optional[str]]" = Queue()
            Process(target=_mp_open_filename, args=(res, title, filetypes, suggest)).start()
            return res.get()
        try:
            root = tkinter.Tk()
        except tkinter.TclError:
@ -702,6 +738,12 @@ def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typin
                                                  initialfile=suggest or None)
 def _mp_open_directory(res: "multiprocessing.Queue[typing.Optional[str]]", *args: Any) -> None:
    if is_kivy_running():
        raise RuntimeError("kivy should not be running in multiprocess")
    res.put(open_directory(*args))
 def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
    def run(*args: str):
        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
@ -725,9 +767,16 @@ def open_directory(title: str, suggest: str = "") -> typing.Optional[str]:
        import tkinter.filedialog
    except Exception as e:
        logging.error('Could not load tkinter, which is likely not installed. '
-                      f'This attempt was made because open_filename was used for "{title}".')
+                      f'This attempt was made because open_directory was used for "{title}".')
        raise e
    else:
        if is_macos and is_kivy_running():
            # on macOS, mixing kivy and tk does not work, so spawn a new process
            # FIXME: performance of this is pretty bad, and we should (also) look into alternatives
            from multiprocessing import Process, Queue
            res: "Queue[typing.Optional[str]]" = Queue()
            Process(target=_mp_open_directory, args=(res, title, suggest)).start()
            return res.get()
        try:
            root = tkinter.Tk()
        except tkinter.TclError:
@ -740,12 +789,6 @@ def messagebox(title: str, text: str, error: bool = False) -> None:
    def run(*args: str):
        return subprocess.run(args, capture_output=True, text=True).stdout.split("\n", 1)[0] or None
    def is_kivy_running():
        if "kivy" in sys.modules:
            from kivy.app import App
            return App.get_running_app() is not None
        return False
    if is_kivy_running():
        from kvui import MessageBox
        MessageBox(title, text, error).open()
@ -824,11 +867,10 @@ def async_start(co: Coroutine[None, None, typing.Any], name: Optional[str] = Non
    task.add_done_callback(_faf_tasks.discard)
-def deprecate(message: str):
+def deprecate(message: str, add_stacklevels: int = 0):
    if __debug__:
        raise Exception(message)
-    import warnings
+    warnings.warn(message, stacklevel=2 + add_stacklevels)
    warnings.warn(message)
 class DeprecateDict(dict):
@ -842,10 +884,9 @@ class DeprecateDict(dict):
    def __getitem__(self, item: Any) -> Any:
        if self.should_error:
-            deprecate(self.log_message)
+            deprecate(self.log_message, add_stacklevels=1)
        elif __debug__:
-            import warnings
+            warnings.warn(self.log_message, stacklevel=2)
            warnings.warn(self.log_message)
        return super().__getitem__(item)
@ -899,7 +940,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) -> None:
+                      linetype_ortho: bool = True, regions_to_highlight: set[Region] | None = None) -> 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.)
@ -915,16 +956,22 @@ 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
-    visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
+    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])
    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
@ -977,7 +1024,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)}\"")
+        uml.append(f"class \"{fmt(region)}\" {'#00FF00' if region in regions_to_highlight else ''}")
        if show_locations:
            visualize_locations(region)
        visualize_exits(region)
--- a/WargrooveClient.py
+++ b/WargrooveClient.py
@ -176,7 +176,7 @@ class WargrooveContext(CommonContext):
                if not os.path.isfile(path):
                    open(path, 'w').close()
                    # Announcing commander unlocks
-                    item_name = self.item_names.lookup_in_slot(network_item.item)
+                    item_name = self.item_names.lookup_in_game(network_item.item)
                    if item_name in faction_table.keys():
                        for commander in faction_table[item_name]:
                            logger.info(f"{commander.name} has been unlocked!")
@ -197,7 +197,7 @@ class WargrooveContext(CommonContext):
                    open(print_path, 'w').close()
                    with open(print_path, 'w') as f:
                        f.write("Received " +
-                                self.item_names.lookup_in_slot(network_item.item) +
+                                self.item_names.lookup_in_game(network_item.item) +
                                " from " +
                                self.player_names[network_item.player])
                        f.close()
@ -267,9 +267,7 @@ class WargrooveContext(CommonContext):
            def build(self):
                container = super().build()
-                panel = TabbedPanelItem(text="Wargroove")
+                self.add_client_tab("Wargroove", self.build_tracker())
                panel.content = self.build_tracker()
                self.tabs.add_widget(panel)
                return container
            def build_tracker(self) -> TrackerLayout:
@ -342,7 +340,7 @@ class WargrooveContext(CommonContext):
            faction_items = 0
            faction_item_names = [faction + ' Commanders' for faction in faction_table.keys()]
            for network_item in self.items_received:
-                if self.item_names.lookup_in_slot(network_item.item) in faction_item_names:
+                if self.item_names.lookup_in_game(network_item.item) in faction_item_names:
                    faction_items += 1
            starting_groove = (faction_items - 1) * self.starting_groove_multiplier
            # Must be an integer larger than 0
--- a/WebHost.py
+++ b/WebHost.py
@ -1,5 +1,6 @@
 #!/usr/bin/env python3
 import argparse
 import os
 import multiprocessing
 import logging
@ -13,11 +14,12 @@ ModuleUpdate.update()
 # in case app gets imported by something like gunicorn
 import Utils
 import settings
 from Utils import get_file_safe_name
 if typing.TYPE_CHECKING:
    from flask import Flask
-Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
+Utils.local_path.cached_path = os.path.dirname(__file__)
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
 if not os.path.exists(configpath):  # fall back to config.yaml in home
@ -33,6 +35,15 @@ def get_app() -> "Flask":
        import yaml
        app.config.from_file(configpath, yaml.safe_load)
        logging.info(f"Updated config from {configpath}")
    # inside get_app() so it's usable in systems like gunicorn, which do not run WebHost.py, but import it.
    parser = argparse.ArgumentParser(allow_abbrev=False)
    parser.add_argument('--config_override', default=None,
                        help="Path to yaml config file that overrules config.yaml.")
    args = parser.parse_known_args()[0]
    if args.config_override:
        import yaml
        app.config.from_file(os.path.abspath(args.config_override), yaml.safe_load)
        logging.info(f"Updated config from {args.config_override}")
    if not app.config["HOST_ADDRESS"]:
        logging.info("Getting public IP, as HOST_ADDRESS is empty.")
        app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
@ -60,9 +71,10 @@ def create_ordered_tutorials_file() -> typing.List[typing.Dict[str, typing.Any]]
            worlds[game] = world
    base_target_path = Utils.local_path("WebHostLib", "static", "generated", "docs")
    shutil.rmtree(base_target_path, ignore_errors=True)
    for game, world in worlds.items():
        # copy files from world's docs folder to the generated folder
-        target_path = os.path.join(base_target_path, game)
+        target_path = os.path.join(base_target_path, get_file_safe_name(game))
        os.makedirs(target_path, exist_ok=True)
        if world.zip_path:
--- a/WebHostLib/init.py
+++ b/WebHostLib/init.py
@ -9,7 +9,7 @@ from flask_compress import Compress
 from pony.flask import Pony
 from werkzeug.routing import BaseConverter
-from Utils import title_sorted
+from Utils import title_sorted, get_file_safe_name
 UPLOAD_FOLDER = os.path.relpath('uploads')
 LOGS_FOLDER = os.path.relpath('logs')
@ -20,6 +20,7 @@ Pony(app)
 app.jinja_env.filters['any'] = any
 app.jinja_env.filters['all'] = all
 app.jinja_env.filters['get_file_safe_name'] = get_file_safe_name
 app.config["SELFHOST"] = True  # application process is in charge of running the websites
 app.config["GENERATORS"] = 8  # maximum concurrent world gens
@ -38,6 +39,8 @@ app.config["SECRET_KEY"] = bytes(socket.gethostname(), encoding="utf-8")
 app.config["JOB_THRESHOLD"] = 1
 # after what time in seconds should generation be aborted, freeing the queue slot. Can be set to None to disable.
 app.config["JOB_TIME"] = 600
 # memory limit for generator processes in bytes
 app.config["GENERATOR_MEMORY_LIMIT"] = 4294967296
 app.config['SESSION_PERMANENT'] = True
 # waitress uses one thread for I/O, these are for processing of views that then get sent
@ -84,6 +87,6 @@ def register():
    from WebHostLib.customserver import run_server_process
    # to trigger app routing picking up on it
-    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc, robots, options
+    from . import tracker, upload, landing, check, generate, downloads, api, stats, misc, robots, options, session
    app.register_blueprint(api.api_endpoints)
--- a/WebHostLib/api/init.py
+++ b/WebHostLib/api/init.py
@ -1,51 +1,15 @@
 """API endpoints package."""
 from typing import List, Tuple
 from uuid import UUID
-from flask import Blueprint, abort, url_for
+from flask import Blueprint
-import worlds.Files
+from ..models import Seed, Slot
 from ..models import Room, Seed
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
 # unsorted/misc endpoints
 def get_players(seed: Seed) -> List[Tuple[str, str]]:
-    return [(slot.player_name, slot.game) for slot in seed.slots]
+    return [(slot.player_name, slot.game) for slot in seed.slots.order_by(Slot.player_id)]
-@api_endpoints.route('/room_status/<suuid:room>')
+from . import datapackage, generate, room, user  # trigger registration
 def room_info(room: UUID):
    room = Room.get(id=room)
    if room is None:
        return abort(404)
    def supports_apdeltapatch(game: str):
        return game in worlds.Files.AutoPatchRegister.patch_types
    downloads = []
    for slot in sorted(room.seed.slots):
        if slot.data and not supports_apdeltapatch(slot.game):
            slot_download = {
                "slot": slot.player_id,
                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
            }
            downloads.append(slot_download)
        elif slot.data:
            slot_download = {
                "slot": slot.player_id,
                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
            }
            downloads.append(slot_download)
    return {
        "tracker": room.tracker,
        "players": get_players(room.seed),
        "last_port": room.last_port,
        "last_activity": room.last_activity,
        "timeout": room.timeout,
        "downloads": downloads,
    }
 from . import generate, user, datapackage  # trigger registration
--- a/WebHostLib/api/room.py
+++ b/WebHostLib/api/room.py
@ -0,0 +1,42 @@
 from typing import Any, Dict
 from uuid import UUID
 from flask import abort, url_for
 import worlds.Files
 from . import api_endpoints, get_players
 from ..models import Room
@api_endpoints.route('/room_status/<suuid:room_id>')
 def room_info(room_id: UUID) -> Dict[str, Any]:
    room = Room.get(id=room_id)
    if room is None:
        return abort(404)
    def supports_apdeltapatch(game: str) -> bool:
        return game in worlds.Files.AutoPatchRegister.patch_types
    downloads = []
    for slot in sorted(room.seed.slots):
        if slot.data and not supports_apdeltapatch(slot.game):
            slot_download = {
                "slot": slot.player_id,
                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
            }
            downloads.append(slot_download)
        elif slot.data:
            slot_download = {
                "slot": slot.player_id,
                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
            }
            downloads.append(slot_download)
    return {
        "tracker": room.tracker,
        "players": get_players(room.seed),
        "last_port": room.last_port,
        "last_activity": room.last_activity,
        "timeout": room.timeout,
        "downloads": downloads,
    }
--- a/WebHostLib/autolauncher.py
+++ b/WebHostLib/autolauncher.py
@ -6,6 +6,7 @@ import multiprocessing
 import typing
 from datetime import timedelta, datetime
 from threading import Event, Thread
 from typing import Any
 from uuid import UUID
 from pony.orm import db_session, select, commit
@ -53,7 +54,21 @@ def launch_generator(pool: multiprocessing.pool.Pool, generation: Generation):
        generation.state = STATE_STARTED
-def init_db(pony_config: dict):
+def init_generator(config: dict[str, Any]) -> None:
    try:
        import resource
    except ModuleNotFoundError:
        pass  # unix only module
    else:
        # set soft limit for memory to from config (default 4GiB)
        soft_limit = config["GENERATOR_MEMORY_LIMIT"]
        old_limit, hard_limit = resource.getrlimit(resource.RLIMIT_AS)
        if soft_limit != old_limit:
            resource.setrlimit(resource.RLIMIT_AS, (soft_limit, hard_limit))
            logging.debug(f"Changed AS mem limit {old_limit} -> {soft_limit}")
        del resource, soft_limit, hard_limit
    pony_config = config["PONY"]
    db.bind(**pony_config)
    db.generate_mapping()
@ -105,8 +120,8 @@ def autogen(config: dict):
        try:
            with Locker("autogen"):
-                with multiprocessing.Pool(config["GENERATORS"], initializer=init_db,
+                with multiprocessing.Pool(config["GENERATORS"], initializer=init_generator,
-                                          initargs=(config["PONY"],), maxtasksperchild=10) as generator_pool:
+                                          initargs=(config,), maxtasksperchild=10) as generator_pool:
                    with db_session:
                        to_start = select(generation for generation in Generation if generation.state == STATE_STARTED)
--- a/WebHostLib/check.py
+++ b/WebHostLib/check.py
@ -105,8 +105,9 @@ def roll_options(options: Dict[str, Union[dict, str]],
                                                             plando_options=plando_options)
                else:
                    for i, yaml_data in enumerate(yaml_datas):
-                        rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
+                        if yaml_data is not None:
-                                                                              plando_options=plando_options)
+                            rolled_results[f"{filename}/{i + 1}"] = roll_settings(yaml_data,
                                                                                  plando_options=plando_options)
            except Exception as e:
                if e.__cause__:
                    results[filename] = f"Failed to generate options in {filename}: {e} - {e.__cause__}"
--- a/WebHostLib/customserver.py
+++ b/WebHostLib/customserver.py
@ -72,6 +72,14 @@ class WebHostContext(Context):
        self.video = {}
        self.tags = ["AP", "WebHost"]
    def __del__(self):
        try:
            import psutil
            from Utils import format_SI_prefix
            self.logger.debug(f"Context destroyed, Mem: {format_SI_prefix(psutil.Process().memory_info().rss, 1024)}iB")
        except ImportError:
            self.logger.debug("Context destroyed")
    def _load_game_data(self):
        for key, value in self.static_server_data.items():
            # NOTE: attributes are mutable and shared, so they will have to be copied before being modified
@ -249,6 +257,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                ctx = WebHostContext(static_server_data, logger)
                ctx.load(room_id)
                ctx.init_save()
                assert ctx.server is None
                try:
                    ctx.server = websockets.serve(
                        functools.partial(server, ctx=ctx), ctx.host, ctx.port, ssl=ssl_context)
@ -279,6 +288,7 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                    ctx.auto_shutdown = Room.get(id=room_id).timeout
                if ctx.saving:
                    setattr(asyncio.current_task(), "save", lambda: ctx._save(True))
                assert ctx.shutdown_task is None
                ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
                await ctx.shutdown_task
@ -325,10 +335,12 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
        def run(self):
            while 1:
                next_room = rooms_to_run.get(block=True,  timeout=None)
                gc.collect()
                task = asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
                self._tasks.append(task)
                task.add_done_callback(self._done)
                logging.info(f"Starting room {next_room} on {name}.")
                del task  # delete reference to task object
    starter = Starter()
    starter.daemon = True
--- a/WebHostLib/generate.py
+++ b/WebHostLib/generate.py
@ -31,11 +31,11 @@ def get_meta(options_source: dict, race: bool = False) -> Dict[str, Union[List[s
    server_options = {
        "hint_cost": int(options_source.get("hint_cost", ServerOptions.hint_cost)),
-        "release_mode": options_source.get("release_mode", ServerOptions.release_mode),
+        "release_mode": str(options_source.get("release_mode", ServerOptions.release_mode)),
-        "remaining_mode": options_source.get("remaining_mode", ServerOptions.remaining_mode),
+        "remaining_mode": str(options_source.get("remaining_mode", ServerOptions.remaining_mode)),
-        "collect_mode": options_source.get("collect_mode", ServerOptions.collect_mode),
+        "collect_mode": str(options_source.get("collect_mode", ServerOptions.collect_mode)),
        "item_cheat": bool(int(options_source.get("item_cheat", not ServerOptions.disable_item_cheat))),
-        "server_password": options_source.get("server_password", None),
+        "server_password": str(options_source.get("server_password", None)),
    }
    generator_options = {
        "spoiler": int(options_source.get("spoiler", GeneratorOptions.spoiler)),
@ -81,6 +81,7 @@ def start_generation(options: Dict[str, Union[dict, str]], meta: Dict[str, Any])
    elif len(gen_options) > app.config["MAX_ROLL"]:
        flash(f"Sorry, generating of multiworlds is limited to {app.config['MAX_ROLL']} players. "
              f"If you have a larger group, please generate it yourself and upload it.")
        return redirect(url_for(request.endpoint, **(request.view_args or {})))
    elif len(gen_options) >= app.config["JOB_THRESHOLD"]:
        gen = Generation(
            options=pickle.dumps({name: vars(options) for name, options in gen_options.items()}),
@ -134,6 +135,7 @@ def gen_game(gen_options: dict, meta: Optional[Dict[str, Any]] = None, owner=Non
                                                                       {"bosses", "items", "connections", "texts"}))
        erargs.skip_prog_balancing = False
        erargs.skip_output = False
        erargs.csv_output = False
        name_counter = Counter()
        for player, (playerfile, settings) in enumerate(gen_options.items(), 1):
--- a/WebHostLib/misc.py
+++ b/WebHostLib/misc.py
@ -1,10 +1,11 @@
 import datetime
 import os
-from typing import List, Dict, Union
+from typing import Any, IO, Dict, Iterator, List, Tuple, Union
 import jinja2.exceptions
 from flask import request, redirect, url_for, render_template, Response, session, abort, send_from_directory
 from pony.orm import count, commit, db_session
 from werkzeug.utils import secure_filename
 from worlds.AutoWorld import AutoWorldRegister
 from . import app, cache
@ -17,13 +18,6 @@ def get_world_theme(game_name: str):
    return 'grass'
@app.before_request
 def register_session():
    session.permanent = True  # technically 31 days after the last visit
    if not session.get("_id", None):
        session["_id"] = uuid4()  # uniquely identify each session without needing a login
@app.errorhandler(404)
@app.errorhandler(jinja2.exceptions.TemplateNotFound)
 def page_not_found(err):
@ -69,14 +63,40 @@ def tutorial_landing():
@app.route('/faq/<string:lang>/')
@cache.cached()
-def faq(lang):
+def faq(lang: str):
-    return render_template("faq.html", lang=lang)
+    import markdown
    with open(os.path.join(app.static_folder, "assets", "faq", secure_filename(lang)+".md")) as f:
        document = f.read()
    return render_template(
        "markdown_document.html",
        title="Frequently Asked Questions",
        html_from_markdown=markdown.markdown(
            document,
            extensions=["toc", "mdx_breakless_lists"],
            extension_configs={
                "toc": {"anchorlink": True}
            }
        ),
    )
@app.route('/glossary/<string:lang>/')
@cache.cached()
-def terms(lang):
+def glossary(lang: str):
-    return render_template("glossary.html", lang=lang)
+    import markdown
    with open(os.path.join(app.static_folder, "assets", "glossary", secure_filename(lang)+".md")) as f:
        document = f.read()
    return render_template(
        "markdown_document.html",
        title="Glossary",
        html_from_markdown=markdown.markdown(
            document,
            extensions=["toc", "mdx_breakless_lists"],
            extension_configs={
                "toc": {"anchorlink": True}
            }
        ),
    )
@app.route('/seed/<suuid:seed>')
@ -97,49 +117,91 @@ def new_room(seed: UUID):
    return redirect(url_for("host_room", room=room.id))
-def _read_log(path: str):
+def _read_log(log: IO[Any], offset: int = 0) -> Iterator[bytes]:
-    if os.path.exists(path):
+    marker = log.read(3)  # skip optional BOM
-        with open(path, encoding="utf-8-sig") as log:
+    if marker != b'\xEF\xBB\xBF':
-            yield from log
+        log.seek(0, os.SEEK_SET)
-    else:
+    log.seek(offset, os.SEEK_CUR)
-        yield f"Logfile {path} does not exist. " \
+    yield from log
-              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
+    log.close()  # free file handle as soon as possible
@app.route('/log/<suuid:room>')
-def display_log(room: UUID):
+def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
    room = Room.get(id=room)
    if room is None:
        return abort(404)
    if room.owner == session["_id"]:
        file_path = os.path.join("logs", str(room.id) + ".txt")
-        if os.path.exists(file_path):
+        try:
-            return Response(_read_log(file_path), mimetype="text/plain;charset=UTF-8")
+            log = open(file_path, "rb")
-        return "Log File does not exist."
+            range_header = request.headers.get("Range")
            if range_header:
                range_type, range_values = range_header.split('=')
                start, end = map(str.strip, range_values.split('-', 1))
                if range_type != "bytes" or end != "":
                    return "Unsupported range", 500
                # NOTE: we skip Content-Range in the response here, which isn't great but works for our JS
                return Response(_read_log(log, int(start)), mimetype="text/plain", status=206)
            return Response(_read_log(log), mimetype="text/plain")
        except FileNotFoundError:
            return Response(f"Logfile {file_path} does not exist. "
                            f"Likely a crash during spinup of multiworld instance or it is still spinning up.",
                            mimetype="text/plain")
    return "Access Denied", 403
-@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
+@app.post("/room/<suuid:room>")
 def host_room_command(room: UUID):
    room: Room = Room.get(id=room)
    if room is None:
        return abort(404)
    if room.owner == session["_id"]:
        cmd = request.form["cmd"]
        if cmd:
            Command(room=room, commandtext=cmd)
            commit()
    return redirect(url_for("host_room", room=room.id))
@app.get("/room/<suuid:room>")
 def host_room(room: UUID):
    room: Room = Room.get(id=room)
    if room is None:
        return abort(404)
    if request.method == "POST":
        if room.owner == session["_id"]:
            cmd = request.form["cmd"]
            if cmd:
                Command(room=room, commandtext=cmd)
                commit()
        return redirect(url_for("host_room", room=room.id))
    now = datetime.datetime.utcnow()
    # indicate that the page should reload to get the assigned port
-    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
+    should_refresh = ((not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3))
                      or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
    with db_session:
        room.last_activity = now  # will trigger a spinup, if it's not already running
-    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
+    browser_tokens = "Mozilla", "Chrome", "Safari"
    automated = ("update" in request.args
                 or "Discordbot" in request.user_agent.string
                 or not any(browser_token in request.user_agent.string for browser_token in browser_tokens))
    def get_log(max_size: int = 0 if automated else 1024000) -> str:
        if max_size == 0:
            return "…"
        try:
            with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
                raw_size = 0
                fragments: List[str] = []
                for block in _read_log(log):
                    if raw_size + len(block) > max_size:
                        fragments.append("…")
                        break
                    raw_size += len(block)
                    fragments.append(block.decode("utf-8"))
                return "".join(fragments)
        except FileNotFoundError:
            return ""
    return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)
@app.route('/favicon.ico')
--- a/WebHostLib/options.py
+++ b/WebHostLib/options.py
@ -3,6 +3,7 @@ import json
 import os
 from textwrap import dedent
 from typing import Dict, Union
 from docutils.core import publish_parts
 import yaml
 from flask import redirect, render_template, request, Response
@ -66,6 +67,22 @@ def filter_dedent(text: str) -> str:
    return dedent(text).strip("\n ")
@app.template_filter("rst_to_html")
 def filter_rst_to_html(text: str) -> str:
    """Converts reStructuredText (such as a Python docstring) to HTML."""
    if text.startswith(" ") or text.startswith("\t"):
        text = dedent(text)
    elif "\n" in text:
        lines = text.splitlines()
        text = lines[0] + "\n" + dedent("\n".join(lines[1:]))
    return publish_parts(text, writer_name='html', settings=None, settings_overrides={
        'raw_enable': False,
        'file_insertion_enabled': False,
        'output_encoding': 'unicode'
    })['body']
@app.template_test("ordered")
 def test_ordered(obj):
    return isinstance(obj, collections.abc.Sequence)
@ -214,6 +231,13 @@ def generate_yaml(game: str):
                del options[key]
            # Detect keys which end with -range, indicating a NamedRange with a possible custom value
            elif key_parts[-1].endswith("-range"):
                if options[key_parts[-1][:-6]] == "custom":
                    options[key_parts[-1][:-6]] = val
                del options[key]
        # Detect random-* keys and set their options accordingly
        for key, val in options.copy().items():
            if key.startswith("random-"):
--- a/WebHostLib/requirements.txt
+++ b/WebHostLib/requirements.txt
@ -1,10 +1,11 @@
 flask>=3.0.3
-werkzeug>=3.0.3
+werkzeug>=3.0.6
-pony>=0.7.17
+pony>=0.7.19
 waitress>=3.0.0
 Flask-Caching>=2.3.0
 Flask-Compress>=1.15
-Flask-Limiter>=3.7.0
+Flask-Limiter>=3.8.0
-bokeh>=3.1.1; python_version <= '3.8'
+bokeh>=3.5.2
 bokeh>=3.4.1; python_version >= '3.9'
 markupsafe>=2.1.5
 Markdown>=3.7
 mdx-breakless-lists>=1.0.1
--- a/WebHostLib/robots.py
+++ b/WebHostLib/robots.py
@ -8,7 +8,8 @@ from . import cache
 def robots():
    # If this host is not official, do not allow search engine crawling
    if not app.config["ASSET_RIGHTS"]:
-        return app.send_static_file('robots.txt')
+        # filename changed in case the path is intercepted and served by an outside service
        return app.send_static_file('robots_file.txt')
    # Send 404 if the host has affirmed this to be the official WebHost
    abort(404)
--- a/WebHostLib/session.py
+++ b/WebHostLib/session.py
@ -0,0 +1,31 @@
 from uuid import uuid4, UUID
 from flask import session, render_template
 from WebHostLib import app
@app.before_request
 def register_session():
    session.permanent = True  # technically 31 days after the last visit
    if not session.get("_id", None):
        session["_id"] = uuid4()  # uniquely identify each session without needing a login
@app.route('/session')
 def show_session():
    return render_template(
        "session.html",
    )
@app.route('/session/<string:_id>')
 def set_session(_id: str):
    new_id: UUID = UUID(_id, version=4)
    old_id: UUID = session["_id"]
    if old_id != new_id:
        session["_id"] = new_id
    return render_template(
        "session.html",
        old_id=old_id,
    )
--- a/WebHostLib/static/assets/faq.js
+++ b/WebHostLib/static/assets/faq.js
@ -1,51 +0,0 @@
 window.addEventListener('load', () => {
    const tutorialWrapper = document.getElementById('faq-wrapper');
    new Promise((resolve, reject) => {
        const ajax = new XMLHttpRequest();
        ajax.onreadystatechange = () => {
            if (ajax.readyState !== 4) { return; }
            if (ajax.status === 404) {
                reject("Sorry, the tutorial is not available in that language yet.");
                return;
            }
            if (ajax.status !== 200) {
                reject("Something went wrong while loading the tutorial.");
                return;
            }
            resolve(ajax.responseText);
        };
        ajax.open('GET', `${window.location.origin}/static/assets/faq/` +
          `faq_${tutorialWrapper.getAttribute('data-lang')}.md`, true);
        ajax.send();
    }).then((results) => {
        // Populate page with HTML generated from markdown
        showdown.setOption('tables', true);
        showdown.setOption('strikethrough', true);
        showdown.setOption('literalMidWordUnderscores', true);
        tutorialWrapper.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')) {
            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
            header.setAttribute('id', headerId);
            header.addEventListener('click', () => {
                window.location.hash = `#${headerId}`;
                header.scrollIntoView();
            });
        }
        // Manually scroll the user to the appropriate header if anchor navigation is used
        document.fonts.ready.finally(() => {
            if (window.location.hash) {
                const scrollTarget = document.getElementById(window.location.hash.substring(1));
                scrollTarget?.scrollIntoView();
            }
        });
    }).catch((error) => {
        console.error(error);
        tutorialWrapper.innerHTML =
            `<h2>This page is out of logic!</h2>
            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
    });
 });
--- a/WebHostLib/static/assets/faq/faq_en.md
+++ b/WebHostLib/static/assets/faq/faq_en.md
@ -77,4 +77,4 @@ There, you will find examples of games in the `worlds` folder:
 You may also find developer documentation in the `docs` folder:  
 [/docs Folder in Archipelago Code](https://github.com/ArchipelagoMW/Archipelago/tree/main/docs).
-If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.
+If you have more questions, feel free to ask in the **#ap-world-dev** channel on our Discord.
--- a/WebHostLib/static/assets/glossary.js
+++ b/WebHostLib/static/assets/glossary.js
@ -1,51 +0,0 @@
 window.addEventListener('load', () => {
    const tutorialWrapper = document.getElementById('glossary-wrapper');
    new Promise((resolve, reject) => {
        const ajax = new XMLHttpRequest();
        ajax.onreadystatechange = () => {
            if (ajax.readyState !== 4) { return; }
            if (ajax.status === 404) {
                reject("Sorry, the glossary page is not available in that language yet.");
                return;
            }
            if (ajax.status !== 200) {
                reject("Something went wrong while loading the glossary.");
                return;
            }
            resolve(ajax.responseText);
        };
        ajax.open('GET', `${window.location.origin}/static/assets/faq/` +
          `glossary_${tutorialWrapper.getAttribute('data-lang')}.md`, true);
        ajax.send();
    }).then((results) => {
        // Populate page with HTML generated from markdown
        showdown.setOption('tables', true);
        showdown.setOption('strikethrough', true);
        showdown.setOption('literalMidWordUnderscores', true);
        tutorialWrapper.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')) {
            const headerId = header.innerText.replace(/\s+/g, '-').toLowerCase();
            header.setAttribute('id', headerId);
            header.addEventListener('click', () => {
                window.location.hash = `#${headerId}`;
                header.scrollIntoView();
            });
        }
        // Manually scroll the user to the appropriate header if anchor navigation is used
        document.fonts.ready.finally(() => {
            if (window.location.hash) {
                const scrollTarget = document.getElementById(window.location.hash.substring(1));
                scrollTarget?.scrollIntoView();
            }
        });
    }).catch((error) => {
        console.error(error);
        tutorialWrapper.innerHTML =
            `<h2>This page is out of logic!</h2>
            <h3>Click <a href="${window.location.origin}">here</a> to return to safety.</h3>`;
    });
 });
--- a/WebHostLib/static/assets/faq/glossary_en.md
+++ b/WebHostLib/static/assets/faq/glossary_en.md
--- a/WebHostLib/static/assets/playerOptions.js
+++ b/WebHostLib/static/assets/playerOptions.js
@ -288,6 +288,11 @@ const applyPresets = (presetName) => {
        }
      });
      namedRangeSelect.value = trueValue;
      // It is also possible for a preset to use an unnamed value. If this happens, set the dropdown to "Custom"
      if (namedRangeSelect.selectedIndex == -1)
      {
        namedRangeSelect.value = "custom";
      }
    }
    // Handle options whose presets are "random"
--- a/WebHostLib/static/robots_file.txt
+++ b/WebHostLib/static/robots_file.txt
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-atlas.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-atlas.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-atlas.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-atlas.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-left-corner.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-left-corner.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-left-corner.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-left-corner.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-right-corner.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-right-corner.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-right-corner.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom-right-corner.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-bottom.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-left.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-left.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-left.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-left.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-right.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-right.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-right.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-right.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-left-corner.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-left-corner.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-left-corner.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-left-corner.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-right-corner.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-right-corner.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-right-corner.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top-right-corner.webp
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top.png
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top.png
--- a/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top.webp
+++ b/WebHostLib/static/static/backgrounds/cliffs/grass/cliff-top.webp
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0001.png
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0001.png
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0001.webp
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0001.webp
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0002.png
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0002.png
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0002.webp
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0002.webp
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0003.png
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0003.png
--- a/WebHostLib/static/static/backgrounds/clouds/cloud-0003.webp
+++ b/WebHostLib/static/static/backgrounds/clouds/cloud-0003.webp
--- a/WebHostLib/static/static/backgrounds/dirt.png
+++ b/WebHostLib/static/static/backgrounds/dirt.png
--- a/WebHostLib/static/static/backgrounds/dirt.webp
+++ b/WebHostLib/static/static/backgrounds/dirt.webp
--- a/WebHostLib/static/static/backgrounds/footer/footer-0001.png
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0001.png
--- a/WebHostLib/static/static/backgrounds/footer/footer-0001.webp
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0001.webp
--- a/WebHostLib/static/static/backgrounds/footer/footer-0002.png
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0002.png
--- a/WebHostLib/static/static/backgrounds/footer/footer-0002.webp
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0002.webp
--- a/WebHostLib/static/static/backgrounds/footer/footer-0003.png
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0003.png
--- a/WebHostLib/static/static/backgrounds/footer/footer-0003.webp
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0003.webp
--- a/WebHostLib/static/static/backgrounds/footer/footer-0004.png
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0004.png
--- a/WebHostLib/static/static/backgrounds/footer/footer-0004.webp
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0004.webp
--- a/WebHostLib/static/static/backgrounds/footer/footer-0005.png
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0005.png
--- a/WebHostLib/static/static/backgrounds/footer/footer-0005.webp
+++ b/WebHostLib/static/static/backgrounds/footer/footer-0005.webp
--- a/WebHostLib/static/static/backgrounds/grass-flowers.png
+++ b/WebHostLib/static/static/backgrounds/grass-flowers.png
--- a/WebHostLib/static/static/backgrounds/grass-flowers.webp
+++ b/WebHostLib/static/static/backgrounds/grass-flowers.webp
--- a/WebHostLib/static/static/backgrounds/grass.png
+++ b/WebHostLib/static/static/backgrounds/grass.png
--- a/WebHostLib/static/static/backgrounds/grass.webp
+++ b/WebHostLib/static/static/backgrounds/grass.webp
--- a/WebHostLib/static/static/backgrounds/header/dirt-header.png
+++ b/WebHostLib/static/static/backgrounds/header/dirt-header.png
--- a/WebHostLib/static/static/backgrounds/header/dirt-header.webp
+++ b/WebHostLib/static/static/backgrounds/header/dirt-header.webp
--- a/WebHostLib/static/static/backgrounds/header/grass-header.png
+++ b/WebHostLib/static/static/backgrounds/header/grass-header.png
--- a/WebHostLib/static/static/backgrounds/header/grass-header.webp
+++ b/WebHostLib/static/static/backgrounds/header/grass-header.webp
--- a/WebHostLib/static/static/backgrounds/header/ocean-header.png
+++ b/WebHostLib/static/static/backgrounds/header/ocean-header.png
--- a/WebHostLib/static/static/backgrounds/header/ocean-header.webp
+++ b/WebHostLib/static/static/backgrounds/header/ocean-header.webp
--- a/WebHostLib/static/static/backgrounds/header/party-time-header.png
+++ b/WebHostLib/static/static/backgrounds/header/party-time-header.png
--- a/WebHostLib/static/static/backgrounds/header/party-time-header.webp
+++ b/WebHostLib/static/static/backgrounds/header/party-time-header.webp
--- a/Show More
+++ b/Show More
		`@ -0,0 +1,2 @@`
							`worlds/blasphemous/region_data.py linguist-generated=true`
							`worlds/yachtdice/YachtWeights.py linguist-generated=true`