Merge branch 'main' into fix-text-choice

Co-authored-by: Fabian Dill <Berserker66@users.noreply.github.com>

.gitattributes

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

.github/workflows/build.yml

@@ -36,15 +36,10 @@ jobs:
         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"
@@ -54,6 +49,12 @@ 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
@@ -64,38 +65,11 @@ 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:
@@ -136,7 +110,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 -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
@@ -144,36 +118,15 @@ 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

.github/workflows/ctest.yml

@@ -1,54 +0,0 @@
-# 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

.github/workflows/release.yml

@@ -69,7 +69,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 -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - code above copied from build.yml -

.github/workflows/unittests.yml

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

.gitignore

@@ -62,7 +62,6 @@ Output Logs/
 /installdelete.iss
 /data/user.kv
 /datapackage
-/custom_worlds
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -150,7 +149,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-*.code-workspace
+.code-workspace
 shell.nix
 
 # Spyder project settings
@@ -178,7 +177,6 @@ dmypy.json
 cython_debug/
 
 # Cython intermediates
-_speedups.c
 _speedups.cpp
 _speedups.html
 

AdventureClient.py

@@ -80,7 +80,7 @@ class AdventureContext(CommonContext):
         self.local_item_locations = {}
         self.dragon_speed_info = {}
 
-        options = Utils.get_settings()
+        options = Utils.get_options()
         self.display_msgs = options["adventure_options"]["display_msgs"]
 
     async def server_auth(self, password_requested: bool = False):
@@ -102,7 +102,7 @@ class AdventureContext(CommonContext):
     def on_package(self, cmd: str, args: dict):
         if cmd == 'Connected':
             self.locations_array = None
-            if Utils.get_settings()["adventure_options"].get("death_link", False):
+            if Utils.get_options()["adventure_options"].get("death_link", False):
                 self.set_deathlink = True
             async_start(self.get_freeincarnates_used())
         elif cmd == "RoomInfo":
@@ -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_game(item.item) for item in args['items']])}"
+            msg = f"Received {', '.join([self.item_names[item.item] for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
             if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
@@ -415,8 +415,8 @@ async def atari_sync_task(ctx: AdventureContext):
 
 
 async def run_game(romfile):
-    auto_start = Utils.get_settings()["adventure_options"].get("rom_start", True)
-    rom_args = Utils.get_settings()["adventure_options"].get("rom_args")
+    auto_start = Utils.get_options()["adventure_options"].get("rom_start", True)
+    rom_args = Utils.get_options()["adventure_options"].get("rom_args")
     if auto_start is True:
         import webbrowser
         webbrowser.open(romfile)

BaseClasses.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import collections
+import copy
 import itertools
 import functools
 import logging
@@ -11,10 +11,8 @@ from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
-                    Optional, Protocol, Set, Tuple, Union, Type)
-
-from typing_extensions import NotRequired, TypedDict
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, NamedTuple, Optional, Set, Tuple, \
+                   TypedDict, Union, Type, ClassVar
 
 import NetUtils
 import Options
@@ -24,16 +22,16 @@ if typing.TYPE_CHECKING:
     from worlds import AutoWorld
 
 
-class Group(TypedDict):
+class Group(TypedDict, total=False):
     name: str
     game: str
     world: "AutoWorld.World"
-    players: AbstractSet[int]
-    item_pool: NotRequired[Set[str]]
-    replacement_items: NotRequired[Dict[int, Optional[str]]]
-    local_items: NotRequired[Set[str]]
-    non_local_items: NotRequired[Set[str]]
-    link_replacement: NotRequired[bool]
+    players: Set[int]
+    item_pool: Set[str]
+    replacement_items: Dict[int, Optional[str]]
+    local_items: Set[str]
+    non_local_items: Set[str]
+    link_replacement: bool
 
 
 class ThreadBarrierProxy:
@@ -50,11 +48,6 @@ 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]
@@ -70,6 +63,7 @@ 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]
@@ -163,7 +157,7 @@ class MultiWorld():
         self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
 
         for player in range(1, players + 1):
-            def set_player_attr(attr: str, val) -> None:
+            def set_player_attr(attr, val):
                 self.__dict__.setdefault(attr, {})[player] = val
             set_player_attr('plando_items', [])
             set_player_attr('plando_texts', {})
@@ -172,13 +166,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: AbstractSet[int] = frozenset()) -> Tuple[int, Group]:
+    def add_group(self, name: str, game: str, players: Set[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
@@ -194,9 +188,7 @@ 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 = 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.worlds[new_id].collect_item = classmethod(AutoWorld.World.collect_item).__get__(self.worlds[new_id])
         self.player_name[new_id] = name
 
         new_group = self.groups[new_id] = Group(name=name, game=game, players=players,
@@ -204,7 +196,7 @@ class MultiWorld():
 
         return new_id, new_group
 
-    def get_player_groups(self, player: int) -> Set[int]:
+    def get_player_groups(self, player) -> 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):
@@ -267,7 +259,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()
@@ -296,88 +288,6 @@ 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("Menu", group_id, self, "ItemLink")
-            self.regions.append(region)
-            locations = region.locations
-            # ensure that progression items are linked first, then non-progression
-            self.itempool.sort(key=lambda item: item.advancement)
-            for item in self.itempool:
-                count = common_item_count.get(item.player, {}).get(item.name, 0)
-                if count:
-                    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
@@ -399,7 +309,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: HasNameAndPlayer) -> str:
+    def get_name_string_for_object(self, obj) -> 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:
@@ -441,7 +351,7 @@ class MultiWorld():
             subworld = self.worlds[player]
             for item in subworld.get_pre_fill_items():
                 subworld.collect(ret, item)
-        ret.sweep_for_advancements()
+        ret.sweep_for_events()
 
         if use_cache:
             self._all_state = ret
@@ -450,7 +360,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: str, player: int, resolve_group_locations: bool = False) -> List[Location]:
+    def find_item_locations(self, item, 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
@@ -459,7 +369,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: str, player: int) -> Location:
+    def find_item(self, item, 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)
 
@@ -552,9 +462,9 @@ class MultiWorld():
                 return True
             state = starting_state.copy()
         else:
-            state = CollectionState(self)
-            if self.has_beaten_game(state):
+            if self.has_beaten_game(self.state):
                 return True
+            state = CollectionState(self)
         prog_locations = {location for location in self.get_locations() if location.item
                           and location.item.advancement and location not in state.locations_checked}
 
@@ -613,21 +523,26 @@ class MultiWorld():
         players: Dict[str, Set[int]] = {
             "minimal": set(),
             "items": set(),
-            "full": set()
+            "locations": set()
         }
-        for player, world in self.worlds.items():
-            players[world.options.accessibility.current_key].add(player)
+        for player, access in self.accessibility.items():
+            players[access.current_key].add(player)
 
         beatable_fulfilled = False
 
-        def location_condition(location: Location) -> bool:
+        def location_condition(location: Location):
             """Determine if this location has to be accessible, location is already filtered by location_relevant"""
-            return location.player in players["full"] or \
-                (location.item and location.item.player not in players["minimal"])
+            if location.player in players["locations"] or (location.item and location.item.player not in
+                                                           players["minimal"]):
+                return True
+            return False
 
-        def location_relevant(location: Location) -> bool:
+        def location_relevant(location: Location):
             """Determine if this location is relevant to sweep."""
-            return location.player in players["full"] or location.advancement
+            if location.progress_type != LocationProgressType.EXCLUDED \
+               and (location.player in players["locations"] or location.advancement):
+                return True
+            return False
 
         def all_done() -> bool:
             """Check if all access rules are fulfilled"""
@@ -672,7 +587,7 @@ class CollectionState():
     multiworld: MultiWorld
     reachable_regions: Dict[int, Set[Region]]
     blocked_connections: Dict[int, Set[Entrance]]
-    advancements: Set[Location]
+    events: Set[Location]
     path: Dict[Union[Region, Entrance], PathValue]
     locations_checked: Set[Location]
     stale: Dict[int, bool]
@@ -684,7 +599,7 @@ class CollectionState():
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
         self.blocked_connections = {player: set() for player in parent.get_all_ids()}
-        self.advancements = set()
+        self.events = set()
         self.path = {}
         self.locations_checked = set()
         self.stale = {player: True for player in parent.get_all_ids()}
@@ -696,25 +611,17 @@ 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: Region = world.get_region(world.origin_region_name)
+        start = self.multiworld.get_region("Menu", player)
 
         # 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)
-            self.blocked_connections[player].update(start.exits)
+            blocked_connections.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()
@@ -722,7 +629,7 @@ 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 connected Region"
+                assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
                 reachable_regions.add(new_region)
                 blocked_connections.remove(connection)
                 blocked_connections.update(new_region.exits)
@@ -734,39 +641,16 @@ class CollectionState():
                     if new_entrance in blocked_connections and new_entrance not in queue:
                         queue.append(new_entrance)
 
-    def _update_reachable_regions_auto_indirect_conditions(self, player: int, queue: deque):
-        reachable_regions = self.reachable_regions[player]
-        blocked_connections = self.blocked_connections[player]
-        new_connection: bool = True
-        # run BFS on all connections, and keep track of those blocked by missing items
-        while new_connection:
-            new_connection = False
-            while queue:
-                connection = queue.popleft()
-                new_region = connection.connected_region
-                if new_region in reachable_regions:
-                    blocked_connections.remove(connection)
-                elif connection.can_reach(self):
-                    assert new_region, f"tried to search through an Entrance \"{connection}\" with no Region"
-                    reachable_regions.add(new_region)
-                    blocked_connections.remove(connection)
-                    blocked_connections.update(new_region.exits)
-                    queue.extend(new_region.exits)
-                    self.path[new_region] = (new_region.name, self.path.get(connection, None))
-                    new_connection = True
-            # sweep for indirect connections, mostly Entrance.can_reach(unrelated_Region)
-            queue.extend(blocked_connections)
-
     def copy(self) -> CollectionState:
         ret = CollectionState(self.multiworld)
-        ret.prog_items = {player: counter.copy() for player, counter in self.prog_items.items()}
-        ret.reachable_regions = {player: region_set.copy() for player, region_set in
-                                 self.reachable_regions.items()}
-        ret.blocked_connections = {player: entrance_set.copy() for player, entrance_set in
-                                   self.blocked_connections.items()}
-        ret.advancements = self.advancements.copy()
-        ret.path = self.path.copy()
-        ret.locations_checked = self.locations_checked.copy()
+        ret.prog_items = copy.deepcopy(self.prog_items)
+        ret.reachable_regions = {player: copy.copy(self.reachable_regions[player]) for player in
+                                 self.reachable_regions}
+        ret.blocked_connections = {player: copy.copy(self.blocked_connections[player]) for player in
+                                   self.blocked_connections}
+        ret.events = copy.copy(self.events)
+        ret.path = copy.copy(self.path)
+        ret.locations_checked = copy.copy(self.locations_checked)
         for function in self.additional_copy_functions:
             ret = function(self, ret)
         return ret
@@ -796,25 +680,20 @@ 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, 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:
+    def sweep_for_events(self, key_only: bool = False, locations: Optional[Iterable[Location]] = None) -> None:
         if locations is None:
             locations = self.multiworld.get_filled_locations()
-        reachable_advancements = True
-        # since the loop has a good chance to run more than once, only filter the advancements once
-        locations = {location for location in locations if location.advancement and location not in self.advancements}
-
-        while reachable_advancements:
-            reachable_advancements = {location for location in locations if location.can_reach(self)}
-            locations -= reachable_advancements
-            for advancement in reachable_advancements:
-                self.advancements.add(advancement)
-                assert isinstance(advancement.item, Item), "tried to collect Event with no Item"
-                self.collect(advancement.item, True, advancement)
+        reachable_events = True
+        # since the loop has a good chance to run more than once, only filter the events once
+        locations = {location for location in locations if location.advancement and location not in self.events and
+                     not key_only or getattr(location.item, "locked_dungeon_item", False)}
+        while reachable_events:
+            reachable_events = {location for location in locations if location.can_reach(self)}
+            locations -= reachable_events
+            for event in reachable_events:
+                self.events.add(event)
+                assert isinstance(event.item, Item), "tried to collect Event with no Item"
+                self.collect(event.item, True, event)
 
     # item name related
     def has(self, item: str, player: int, count: int = 1) -> bool:
@@ -848,7 +727,7 @@ class CollectionState():
             if found >= count:
                 return True
         return False
-
+    
     def has_from_list_unique(self, items: Iterable[str], player: int, count: int) -> bool:
         """Returns True if the state contains at least `count` items matching any of the item names from a list.
         Ignores duplicates of the same item."""
@@ -863,7 +742,7 @@ class CollectionState():
     def count_from_list(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state."""
         return sum(self.prog_items[player][item_name] for item_name in items)
-
+    
     def count_from_list_unique(self, items: Iterable[str], player: int) -> int:
         """Returns the cumulative count of items from a list present in state. Ignores duplicates of the same item."""
         return sum(self.prog_items[player][item_name] > 0 for item_name in items)
@@ -909,16 +788,20 @@ class CollectionState():
         )
 
     # Item related
-    def collect(self, item: Item, prevent_sweep: bool = False, location: Optional[Location] = None) -> bool:
+    def collect(self, item: Item, event: 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 prevent_sweep:
-            self.sweep_for_advancements()
+        if changed and not event:
+            self.sweep_for_events()
 
         return changed
 
@@ -942,13 +825,12 @@ class Entrance:
     addresses = None
     target = None
 
-    def __init__(self, player: int, name: str = "", parent: Optional[Region] = None) -> None:
+    def __init__(self, player: int, name: str = '', parent: Region = None):
         self.name = name
         self.parent_region = parent
         self.player = player
 
     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:
                 state.path[self] = (self.name, state.path.get(self.parent_region, (self.parent_region.name, None)))
@@ -963,6 +845,9 @@ class Entrance:
         region.entrances.append(self)
 
     def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
         multiworld = self.parent_region.multiworld if self.parent_region else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
@@ -1088,7 +973,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:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> entrance_type:
         """
         Connects this Region to another Region, placing the provided rule on the connection.
 
@@ -1128,6 +1013,9 @@ class Region:
                          rules[connecting_region] if rules and connecting_region in rules else None)
 
     def __repr__(self):
+        return self.__str__()
+
+    def __str__(self):
         return self.multiworld.get_name_string_for_object(self) if self.multiworld else f'{self.name} (Player {self.player})'
 
 
@@ -1146,9 +1034,9 @@ class Location:
     locked: bool = False
     show_in_spoiler: bool = True
     progress_type: LocationProgressType = LocationProgressType.DEFAULT
-    always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
+    always_allow = staticmethod(lambda state, item: False)
     access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
-    item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
+    item_rule = staticmethod(lambda item: True)
     item: Optional[Item] = None
 
     def __init__(self, player: int, name: str = '', address: Optional[int] = None, parent: Optional[Region] = None):
@@ -1157,20 +1045,16 @@ class Location:
         self.address = address
         self.parent_region = parent
 
-    def can_fill(self, state: CollectionState, item: Item, check_access: bool = True) -> bool:
-        return ((
-            self.always_allow(state, item)
-            and item.name not in state.multiworld.worlds[item.player].options.non_local_items
-        ) or (
-            (self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
-            and self.item_rule(item)
-            and (not check_access or self.can_reach(state))
-        ))
+    def can_fill(self, state: CollectionState, item: Item, check_access=True) -> bool:
+        return ((self.always_allow(state, item) and item.name not in state.multiworld.worlds[item.player].options.non_local_items)
+                or ((self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
+                    and self.item_rule(item)
+                    and (not check_access or self.can_reach(state))))
 
     def can_reach(self, state: CollectionState) -> bool:
-        # Region.can_reach is just a cache lookup, so placing it first for faster abort on average
-        assert self.parent_region, f"called can_reach on a Location \"{self}\" with no parent_region"
-        return self.parent_region.can_reach(state) and self.access_rule(state)
+        # self.access_rule computes faster on average, so placing it first for faster abort
+        assert self.parent_region, "Can't reach location without region"
+        return self.access_rule(state) and self.parent_region.can_reach(state)
 
     def place_locked_item(self, item: Item):
         if self.item:
@@ -1180,6 +1064,9 @@ 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})'
 
@@ -1201,7 +1088,7 @@ class Location:
     @property
     def native_item(self) -> bool:
         """Returns True if the item in this location matches game."""
-        return self.item is not None and self.item.game == self.game
+        return self.item and self.item.game == self.game
 
     @property
     def hint_text(self) -> str:
@@ -1212,7 +1099,7 @@ class ItemClassification(IntFlag):
     filler = 0b0000  # aka trash, as in filler items like ammo, currency etc,
     progression = 0b0001  # Item that is logically relevant
     useful = 0b0010  # Item that is generally quite useful, but not required for anything logical
-    trap = 0b0100  # detrimental item
+    trap = 0b0100  # detrimental or entirely useless (nothing) item
     skip_balancing = 0b1000  # should technically never occur on its own
     # Item that is logically relevant, but progression balancing should not touch.
     # Typically currency or other counted items.
@@ -1284,6 +1171,9 @@ 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})"
@@ -1361,9 +1251,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: Dict[Location, Item] = {}
+        restore_later = {}
         for num, sphere in reversed(tuple(enumerate(collection_spheres))):
-            to_delete: Set[Location] = set()
+            to_delete = 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,
@@ -1381,7 +1271,7 @@ class Spoiler:
             sphere -= to_delete
 
         # second phase, sphere 0
-        removed_precollected: List[Item] = []
+        removed_precollected = []
         for item in (i for i in chain.from_iterable(multiworld.precollected_items.values()) if i.advancement):
             logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
             multiworld.precollected_items[item.player].remove(item)
@@ -1401,6 +1291,8 @@ 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:
@@ -1462,7 +1354,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.worlds[player].options.mode != 'inverted':
+                    if multiworld.mode[player] != 'inverted':
                         self.paths[str(multiworld.get_region('Big Bomb Shop', player))] = \
                             get_path(state, multiworld.get_region('Big Bomb Shop', player))
                     else:
@@ -1534,9 +1426,9 @@ class Spoiler:
 
             if self.paths:
                 outfile.write('\n\nPaths:\n\n')
-                path_listings: List[str] = []
+                path_listings = []
                 for location, path in sorted(self.paths.items()):
-                    path_lines: List[str] = []
+                    path_lines = []
                     for region, exit in path:
                         if exit is not None:
                             path_lines.append("{} -> {}".format(region, exit))

BizHawkClient.py

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

CommonClient.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import collections
 import copy
 import logging
 import asyncio
@@ -9,7 +8,6 @@ import sys
 import typing
 import time
 import functools
-import warnings
 
 import ModuleUpdate
 ModuleUpdate.update()
@@ -23,7 +21,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, SlotType)
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
@@ -45,21 +43,10 @@ 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:
@@ -72,7 +59,6 @@ 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
@@ -175,96 +161,28 @@ 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:
-    # The following attributes are used to Connect and should be adjusted as needed in subclasses
+    # Should be adjusted as needed in subclasses
     tags: typing.Set[str] = {"AP"}
     game: typing.Optional[str] = None
     items_handling: typing.Optional[int] = None
     want_slot_data: bool = True  # should slot_data be retrieved via Connect
 
-    class NameLookupDict:
-        """A specialized dict, with helper methods, for id -> name item/location data package lookups by game."""
-        def __init__(self, ctx: CommonContext, lookup_type: typing.Literal["item", "location"]):
-            self.ctx: CommonContext = ctx
-            self.lookup_type: typing.Literal["item", "location"] = lookup_type
-            self._unknown_item: typing.Callable[[int], str] = lambda key: f"Unknown {lookup_type} (ID: {key})"
-            self._archipelago_lookup: typing.Dict[int, str] = {}
-            self._flat_store: typing.Dict[int, str] = Utils.KeyedDefaultDict(self._unknown_item)
-            self._game_store: typing.Dict[str, typing.ChainMap[int, str]] = collections.defaultdict(
-                lambda: collections.ChainMap(self._archipelago_lookup, Utils.KeyedDefaultDict(self._unknown_item)))
-            self.warned: bool = False
-
-        # noinspection PyTypeChecker
-        def __getitem__(self, key: str) -> typing.Mapping[int, str]:
-            # TODO: In a future version (0.6.0?) this should be simplified by removing implicit id lookups support.
-            if isinstance(key, int):
-                if not self.warned:
-                    # Use warnings instead of logger to avoid deprecation message from appearing on user side.
-                    self.warned = True
-                    warnings.warn(f"Implicit name lookup by id only is deprecated and only supported to maintain "
-                                  f"backwards compatibility for now. If multiple games share the same id for a "
-                                  f"{self.lookup_type}, name could be incorrect. Please use "
-                                  f"`{self.lookup_type}_names.lookup_in_game()` or "
-                                  f"`{self.lookup_type}_names.lookup_in_slot()` instead.")
-                return self._flat_store[key]  # type: ignore
-
-            return self._game_store[key]
-
-        def __len__(self) -> int:
-            return len(self._game_store)
-
-        def __iter__(self) -> typing.Iterator[str]:
-            return iter(self._game_store)
-
-        def __repr__(self) -> str:
-            return self._game_store.__repr__()
-
-        def lookup_in_game(self, code: int, game_name: typing.Optional[str] = None) -> str:
-            """Returns the name for an item/location id in the context of a specific game or own game if `game` is
-            omitted.
-            """
-            if game_name is None:
-                game_name = self.ctx.game
-                assert game_name is not None, f"Attempted to lookup {self.lookup_type} with no game name available."
-
-            return self._game_store[game_name][code]
-
-        def lookup_in_slot(self, code: int, slot: typing.Optional[int] = None) -> str:
-            """Returns the name for an item/location id in the context of a specific slot or own slot if `slot` is
-            omitted.
-
-            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
-                assert slot is not None, f"Attempted to lookup {self.lookup_type} with no slot info available."
-
-            return self.lookup_in_game(code, self.ctx.slot_info[slot].game)
-
-        def update_game(self, game: str, name_to_id_lookup_table: typing.Dict[str, int]) -> None:
-            """Overrides existing lookup tables for a particular game."""
-            id_to_name_lookup_table = Utils.KeyedDefaultDict(self._unknown_item)
-            id_to_name_lookup_table.update({code: name for name, code in name_to_id_lookup_table.items()})
-            self._game_store[game] = collections.ChainMap(self._archipelago_lookup, id_to_name_lookup_table)
-            self._flat_store.update(id_to_name_lookup_table)  # Only needed for legacy lookup method.
-            if game == "Archipelago":
-                # Keep track of the Archipelago data package separately so if it gets updated in a custom datapackage,
-                # it updates in all chain maps automatically.
-                self._archipelago_lookup.clear()
-                self._archipelago_lookup.update(id_to_name_lookup_table)
+    # data package
+    # Contents in flux until connection to server is made, to download correct data for this multiworld.
+    item_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
 
     # defaults
     starting_reconnect_delay: int = 5
     current_reconnect_delay: int = starting_reconnect_delay
     command_processor: typing.Type[CommandProcessor] = ClientCommandProcessor
-    ui: typing.Optional["kvui.GameManager"] = None
+    ui = 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
@@ -313,7 +231,7 @@ class CommonContext:
     # message box reporting a loss of connection
     _messagebox_connection_loss: typing.Optional["kvui.MessageBox"] = None
 
-    def __init__(self, server_address: typing.Optional[str] = None, password: typing.Optional[str] = None) -> None:
+    def __init__(self, server_address: typing.Optional[str], password: typing.Optional[str]) -> None:
         # server state
         self.server_address = server_address
         self.username = None
@@ -353,11 +271,6 @@ class CommonContext:
         self.exit_event = asyncio.Event()
         self.watcher_event = asyncio.Event()
 
-        self.item_names = self.NameLookupDict(self, "item")
-        self.location_names = self.NameLookupDict(self, "location")
-        self.versions = {}
-        self.checksums = {}
-
         self.jsontotextparser = JSONtoTextParser(self)
         self.rawjsontotextparser = RawJSONtoTextParser(self)
         self.update_data_package(network_data_package)
@@ -443,10 +356,7 @@ class CommonContext:
                 self.auth = await self.console_input()
 
     async def send_connect(self, **kwargs: typing.Any) -> None:
-        """
-        Send a `Connect` packet to log in to the server,
-        additional keyword args can override any value in the connection packet
-        """
+        """ send `Connect` packet to log in to server """
         payload = {
             'cmd': 'Connect',
             'password': self.password, 'name': self.auth, 'version': Utils.version_tuple,
@@ -456,7 +366,6 @@ class CommonContext:
         if kwargs:
             payload.update(kwargs)
         await self.send_msgs([payload])
-        await self.send_msgs([{"cmd": "Get", "keys": ["_read_race_mode"]}])
 
     async def console_input(self) -> str:
         if self.ui:
@@ -477,7 +386,6 @@ 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:
@@ -485,7 +393,6 @@ 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
@@ -518,13 +425,7 @@ class CommonContext:
         Returned text is sent, or sending is aborted if None is returned."""
         return text
 
-    def on_ui_command(self, text: str) -> None:
-        """Gets called by kivy when the user executes a command starting with `/` or `!`.
-        The command processor is still called; this is just intended for command echoing."""
-        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)
@@ -536,7 +437,6 @@ 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()
@@ -573,38 +473,32 @@ class CommonContext:
                 needed_updates.add(game)
                 continue
 
-            cached_version: int = self.versions.get(game, 0)
-            cached_checksum: typing.Optional[str] = self.checksums.get(game)
-            # no action required if cached version is new enough
-            if (not remote_checksum and (remote_version > cached_version or remote_version == 0)) \
-                    or remote_checksum != cached_checksum:
-                local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
-                local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
-                if ((remote_checksum or remote_version <= local_version and remote_version != 0)
-                        and remote_checksum == local_checksum):
-                    self.update_game(network_data_package["games"][game], game)
+            local_version: int = network_data_package["games"].get(game, {}).get("version", 0)
+            local_checksum: typing.Optional[str] = network_data_package["games"].get(game, {}).get("checksum")
+            # no action required if local version is new enough
+            if (not remote_checksum and (remote_version > local_version or remote_version == 0)) \
+                    or remote_checksum != local_checksum:
+                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:
-                    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)
+                    self.update_game(cached_game)
         if needed_updates:
             await self.send_msgs([{"cmd": "GetDataPackage", "games": [game_name]} for game_name in needed_updates])
 
-    def update_game(self, game_package: dict, game: str):
-        self.item_names.update_game(game, game_package["item_name_to_id"])
-        self.location_names.update_game(game, game_package["location_name_to_id"])
-        self.versions[game] = game_package.get("version", 0)
-        self.checksums[game] = game_package.get("checksum")
+    def update_game(self, game_package: dict):
+        for item_name, item_id in game_package["item_name_to_id"].items():
+            self.item_names[item_id] = item_name
+        for location_name, location_id in game_package["location_name_to_id"].items():
+            self.location_names[location_id] = location_name
 
     def update_data_package(self, data_package: dict):
         for game, game_data in data_package["games"].items():
-            self.update_game(game_data, game)
+            self.update_game(game_data)
 
     def consume_network_data_package(self, data_package: dict):
         self.update_data_package(data_package)
@@ -642,7 +536,6 @@ 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()
@@ -656,7 +549,6 @@ 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")
@@ -666,7 +558,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 in the loaded Kivy UI. Override if using a different UI framework"""
+        """Displays an error messagebox"""
         if not self.ui:
             return None
         title = title or "Error"
@@ -693,19 +585,17 @@ class CommonContext:
         logger.exception(msg, exc_info=exc_info, extra={'compact_gui': True})
         self._messagebox_connection_loss = self.gui_error(msg, exc_info[1])
 
-    def make_gui(self) -> typing.Type["kvui.GameManager"]:
-        """To return the Kivy App class needed for run_gui so it can be overridden before being built"""
+    def run_gui(self):
+        """Import kivy UI system and start running it as self.ui_task."""
         from kvui import GameManager
 
         class TextManager(GameManager):
+            logging_pairs = [
+                ("Client", "Archipelago")
+            ]
             base_title = "Archipelago Text Client"
 
-        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 = TextManager(self)
         self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
 
     def run_cli(self):
@@ -897,8 +787,7 @@ 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 = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
-        ctx.slot_info.update({int(pid): data for pid, data in args["slot_info"].items()})
+        ctx.slot_info = {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}")
@@ -1018,7 +907,6 @@ 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.')
@@ -1028,7 +916,7 @@ def get_base_parser(description: typing.Optional[str] = None):
     return parser
 
 
-def run_as_textclient(*args):
+def run_as_textclient():
     class TextContext(CommonContext):
         # Text Mode to use !hint and such with games that have no text entry
         tags = CommonContext.tags | {"TextOnly"}
@@ -1067,21 +955,16 @@ def run_as_textclient(*args):
     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)
+    args = parser.parse_args()
 
-    # handle if text client is launched using the "archipelago://name:pass@host:port" url from webhost
     if args.url:
         url = urllib.parse.urlparse(args.url)
-        if url.scheme == "archipelago":
-            args.connect = url.netloc
-            if url.username:
-                args.name = urllib.parse.unquote(url.username)
-            if url.password:
-                args.password = urllib.parse.unquote(url.password)
-        else:
-            parser.error(f"bad url, found {args.url}, expected url in form of archipelago://archipelago.gg:38281")
+        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))
@@ -1090,4 +973,4 @@ def run_as_textclient(*args):
 
 if __name__ == '__main__':
     logging.getLogger().setLevel(logging.INFO)  # force log-level to work around log level resetting to WARNING
-    run_as_textclient(*sys.argv[1:])  # default value for parse_args
+    run_as_textclient()

Fill.py

@@ -12,12 +12,7 @@ from worlds.generic.Rules import add_item_rule
 
 
 class FillError(RuntimeError):
-    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)
+    pass
 
 
 def _log_fill_progress(name: str, placed: int, total_items: int) -> None:
@@ -29,7 +24,7 @@ def sweep_from_pool(base_state: CollectionState, itempool: typing.Sequence[Item]
     new_state = base_state.copy()
     for item in itempool:
         new_state.collect(item, True)
-    new_state.sweep_for_advancements(locations=locations)
+    new_state.sweep_for_events(locations=locations)
     return new_state
 
 
@@ -217,7 +212,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)}", multiworld=multiworld)
+                            f"{', '.join(str(place) for place in placements)}")
 
     item_pool.extend(unplaced_items)
 
@@ -304,7 +299,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)}", multiworld=multiworld)
+                            f"{', '.join(str(place) for place in placements)}")
 
     itempool.extend(unplaced_items)
 
@@ -329,8 +324,8 @@ def accessibility_corrections(multiworld: MultiWorld, state: CollectionState, lo
             pool.append(location.item)
             state.remove(location.item)
             location.item = None
-            if location in state.advancements:
-                state.advancements.remove(location)
+            if location in state.events:
+                state.events.remove(location)
             locations.append(location)
     if pool and locations:
         locations.sort(key=lambda loc: loc.progress_type != LocationProgressType.PRIORITY)
@@ -363,7 +358,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_advancements(locations=(loc for loc in multiworld.get_filled_locations() if loc.address is None))
+        base_state.sweep_for_events(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:
@@ -475,26 +470,28 @@ 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=single_player, swap=False, on_place=mark_for_locking, name="Priority")
+                         single_player_placement=multiworld.players == 1, swap=False, on_place=mark_for_locking,
+                         name="Priority")
         accessibility_corrections(multiworld, multiworld.state, prioritylocations, progitempool)
         defaultlocations = prioritylocations + defaultlocations
 
     if progitempool:
         # "advancement/progression fill"
         if panic_method == "swap":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=True,
-                             name="Progression", single_player_placement=single_player)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+                             swap=True,
+                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
         elif panic_method == "raise":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
-                             name="Progression", single_player_placement=single_player)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+                             swap=False,
+                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
         elif panic_method == "start_inventory":
-            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool, swap=False,
-                             allow_partial=True, name="Progression", single_player_placement=single_player)
+            fill_restrictive(multiworld, multiworld.state, defaultlocations, progitempool,
+                             swap=False, allow_partial=True,
+                             on_place=mark_for_locking, name="Progression", single_player_placement=multiworld.players == 1)
             if progitempool:
                 for item in progitempool:
                     logging.debug(f"Moved {item} to start_inventory to prevent fill failure.")
@@ -509,8 +506,7 @@ 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.",
-                multiworld=multiworld,
+                f"There are {len(progitempool)} more progression items than there are available locations."
             )
         accessibility_corrections(multiworld, multiworld.state, defaultlocations)
 
@@ -527,8 +523,7 @@ 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.",
-            multiworld=multiworld,
+            f"There are {len(excludedlocations)} more excluded locations than filler or trap items."
         )
 
     restitempool = filleritempool + usefulitempool
@@ -556,7 +551,7 @@ def flood_items(multiworld: MultiWorld) -> None:
     progress_done = False
 
     # sweep once to pick up preplaced items
-    multiworld.state.sweep_for_advancements()
+    multiworld.state.sweep_for_events()
 
     # fill multiworld from top of itempool while we can
     while not progress_done:
@@ -594,7 +589,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.', multiworld=multiworld)
+                raise FillError('No more progress items left to place.')
 
         # find item to replace with progress item
         location_list = multiworld.get_reachable_locations()
@@ -651,6 +646,7 @@ 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:
@@ -744,7 +740,7 @@ def balance_multiworld_progression(multiworld: MultiWorld) -> None:
                             ), items_to_test):
                                 reducing_state.collect(location.item, True, location)
 
-                            reducing_state.sweep_for_advancements(locations=locations_to_test)
+                            reducing_state.sweep_for_events(locations=locations_to_test)
 
                             if multiworld.has_beaten_game(balancing_state):
                                 if not multiworld.has_beaten_game(reducing_state):
@@ -827,7 +823,7 @@ def distribute_planned(multiworld: MultiWorld) -> None:
             warn(warning, force)
 
     swept_state = multiworld.state.copy()
-    swept_state.sweep_for_advancements()
+    swept_state.sweep_for_events()
     reachable = frozenset(multiworld.get_reachable_locations(swept_state))
     early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)
     non_early_locations: typing.Dict[int, typing.List[str]] = collections.defaultdict(list)

Generate.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
 import argparse
-import copy
 import logging
 import os
 import random
 import string
-import sys
 import urllib.parse
 import urllib.request
 from collections import Counter
@@ -17,16 +15,23 @@ import ModuleUpdate
 
 ModuleUpdate.update()
 
+import copy
 import Utils
 import Options
 from BaseClasses import seeddigits, get_seed, PlandoOptions
+from Main import main as ERmain
+from settings import get_settings
 from Utils import parse_yamls, version_tuple, __version__, tuplize_version
+from worlds.alttp.EntranceRandomizer import parse_arguments
+from worlds.alttp.Text import TextTable
+from worlds.AutoWorld import AutoWorldRegister
+from worlds.generic import PlandoConnection
+from worlds import failed_world_loads
 
 
 def mystery_argparse():
-    from settings import get_settings
-    settings = get_settings()
-    defaults = settings.generator
+    options = get_settings()
+    defaults = options.generator
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
     parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
@@ -38,15 +43,15 @@ def mystery_argparse():
     parser.add_argument('--seed', help='Define seed number to generate.', type=int)
     parser.add_argument('--multi', default=defaults.players, type=lambda value: max(int(value), 1))
     parser.add_argument('--spoiler', type=int, default=defaults.spoiler)
-    parser.add_argument('--outputpath', default=settings.general_options.output_path,
+    parser.add_argument('--outputpath', default=options.general_options.output_path,
                         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("--csv_output", action="store_true",
-                        help="Output rolled player options to csv (made for async multiworld).")
-    parser.add_argument("--plando", default=defaults.plando_options,
-                        help="List of options that can be set manually. Can be combined, for example \"bosses, items\"")
+    parser.add_argument('--yaml_output', default=0, type=lambda value: max(int(value), 0),
+                        help='Output rolled mystery results to yaml up to specified number (made for async multiworld)')
+    parser.add_argument('--plando', default=defaults.plando_options,
+                        help='List of options that can be set manually. Can be combined, for example "bosses, items"')
     parser.add_argument("--skip_prog_balancing", action="store_true",
                         help="Skip progression balancing step during generation.")
     parser.add_argument("--skip_output", action="store_true",
@@ -58,23 +63,20 @@ def mystery_argparse():
     if not os.path.isabs(args.meta_file_path):
         args.meta_file_path = os.path.join(args.player_files_path, args.meta_file_path)
     args.plando: PlandoOptions = PlandoOptions.from_option_string(args.plando)
-    return args
+    return args, options
 
 
 def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None) -> Tuple[argparse.Namespace, int]:
-    # __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.")
-
+def main(args=None, callback=ERmain):
     if not args:
-        args = mystery_argparse()
+        args, options = mystery_argparse()
+    else:
+        options = get_settings()
 
     seed = get_seed(args.seed)
-
     Utils.init_logging(f"Generate_{seed}", loglevel=args.log_level)
     random.seed(seed)
     seed_name = get_seed_name(random)
@@ -143,9 +145,6 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
         raise Exception(f"No weights found. "
                         f"Provide a general weights file ({args.weights_file_path}) or individual player files. "
                         f"A mix is also permitted.")
-
-    from worlds.AutoWorld import AutoWorldRegister
-    from worlds.alttp.EntranceRandomizer import parse_arguments
     erargs = parse_arguments(['--multi', str(args.multi)])
     erargs.seed = seed
     erargs.plando_options = args.plando
@@ -155,8 +154,6 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
     erargs.outputpath = args.outputpath
     erargs.skip_prog_balancing = args.skip_prog_balancing
     erargs.skip_output = args.skip_output
-    erargs.name = {}
-    erargs.csv_output = args.csv_output
 
     settings_cache: Dict[str, Tuple[argparse.Namespace, ...]] = \
         {fname: (tuple(roll_settings(yaml, args.plando) for yaml in yamls) if args.sameoptions else None)
@@ -204,7 +201,7 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
 
                     if path == args.weights_file_path:  # if name came from the weights file, just use base player name
                         erargs.name[player] = f"Player{player}"
-                    elif player not in erargs.name:  # if name was not specified, generate it from filename
+                    elif not erargs.name[player]:  # 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)
 
@@ -217,7 +214,29 @@ def main(args=None) -> Tuple[argparse.Namespace, int]:
     if len(set(name.lower() for name in erargs.name.values())) != len(erargs.name):
         raise Exception(f"Names have to be unique. Names: {Counter(name.lower() for name in erargs.name.values())}")
 
-    return erargs, seed
+    if args.yaml_output:
+        import yaml
+        important = {}
+        for option, player_settings in vars(erargs).items():
+            if type(player_settings) == dict:
+                if all(type(value) != list for value in player_settings.values()):
+                    if len(player_settings.values()) > 1:
+                        important[option] = {player: value for player, value in player_settings.items() if
+                                             player <= args.yaml_output}
+                    else:
+                        logging.debug(f"No player settings defined for option '{option}'")
+
+            else:
+                if player_settings != "":  # is not empty name
+                    important[option] = player_settings
+                else:
+                    logging.debug(f"No player settings defined for option '{option}'")
+        if args.outputpath:
+            os.makedirs(args.outputpath, exist_ok=True)
+        with open(os.path.join(args.outputpath if args.outputpath else ".", f"generate_{seed_name}.yaml"), "wt") as f:
+            yaml.dump(important, f)
+
+    return callback(erargs, seed)
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -342,8 +361,6 @@ def update_weights(weights: dict, new_weights: dict, update_type: str, name: str
 
 
 def roll_meta_option(option_key, game: str, category_dict: Dict) -> Any:
-    from worlds import AutoWorldRegister
-
     if not game:
         return get_choice(option_key, category_dict)
     if game in AutoWorldRegister.world_types:
@@ -421,13 +438,10 @@ def handle_option(ret: argparse.Namespace, game_weights: dict, option_key: str,
     except Exception as e:
         raise Options.OptionError(f"Error generating option {option_key} in {ret.game}") from e
     else:
-        from worlds import AutoWorldRegister
         player_option.verify(AutoWorldRegister.world_types[ret.game], ret.name, plando_options)
 
 
 def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.bosses):
-    from worlds import AutoWorldRegister
-
     if "linked_options" in weights:
         weights = roll_linked_options(weights)
 
@@ -454,7 +468,6 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
 
     ret.game = get_choice("game", weights)
     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]
         if picks[0] in failed_world_loads:
             raise Exception(f"No functional world found to handle game {ret.game}. "
@@ -491,14 +504,37 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
             continue
         logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers.")
     if PlandoOptions.items in plando_options:
-        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
+        ret.plando_items = game_weights.get("plando_items", [])
     if ret.game == "A Link to the Past":
-        roll_alttp_settings(ret, game_weights)
+        roll_alttp_settings(ret, game_weights, plando_options)
+    if PlandoOptions.connections in plando_options:
+        ret.plando_connections = []
+        options = game_weights.get("plando_connections", [])
+        for placement in options:
+            if roll_percentage(get_choice("percentage", placement, 100)):
+                ret.plando_connections.append(PlandoConnection(
+                    get_choice("entrance", placement),
+                    get_choice("exit", placement),
+                    get_choice("direction", placement, "both")
+                ))
 
     return ret
 
 
-def roll_alttp_settings(ret: argparse.Namespace, weights):
+def roll_alttp_settings(ret: argparse.Namespace, weights, plando_options):
+
+    ret.plando_texts = {}
+    if PlandoOptions.texts in plando_options:
+        tt = TextTable()
+        tt.removeUnwantedText()
+        options = weights.get("plando_texts", [])
+        for placement in options:
+            if roll_percentage(get_choice_legacy("percentage", placement, 100)):
+                at = str(get_choice_legacy("at", placement))
+                if at not in tt:
+                    raise Exception(f"No text target \"{at}\" found.")
+                ret.plando_texts[at] = str(get_choice_legacy("text", placement))
+
     ret.sprite_pool = weights.get('sprite_pool', [])
     ret.sprite = get_choice_legacy('sprite', weights, "Link")
     if 'random_sprite_on_event' in weights:
@@ -526,9 +562,7 @@ def roll_alttp_settings(ret: argparse.Namespace, weights):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    erargs, seed = main()
-    from Main import main as ERmain
-    multiworld = ERmain(erargs, seed)
+    multiworld = main()
     if __debug__:
         import gc
         import sys

KH1Client.py

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

Launcher.py

@@ -16,11 +16,10 @@ 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, Optional, Sequence, Tuple, Union
+from typing import Sequence, Union, Optional
 
 import Utils
 import settings
@@ -35,9 +34,7 @@ from Utils import is_frozen, user_path, local_path, init_logging, open_filename,
 
 
 def open_host_yaml():
-    s = settings.get_settings()
-    file = s.filename
-    s.save()
+    file = settings.get_settings().filename
     assert file, "host.yaml missing"
     if is_linux:
         exe = which('sensible-editor') or which('gedit') or \
@@ -110,81 +107,7 @@ components.extend([
 ])
 
 
-def handle_uri(path: str, launch_args: Tuple[str, ...]) -> None:
-    url = urllib.parse.urlparse(path)
-    queries = urllib.parse.parse_qs(url.query)
-    launch_args = (path, *launch_args)
-    client_component = None
-    text_client_component = None
-    if "game" in queries:
-        game = queries["game"][0]
-    else:  # TODO around 0.6.0 - this is for pre this change webhost uri's
-        game = "Archipelago"
-    for component in components:
-        if component.supports_uri and component.game_name == game:
-            client_component = component
-        elif component.display_name == "Text Client":
-            text_client_component = component
-
-    from kvui import App, Button, BoxLayout, Label, Clock, Window
-
-    class Popup(App):
-        timer_label: Label
-        remaining_time: Optional[int]
-
-        def __init__(self):
-            self.title = "Connect to Multiworld"
-            self.icon = r"data/icon.png"
-            super().__init__()
-
-        def build(self):
-            layout = BoxLayout(orientation="vertical")
-
-            if client_component is None:
-                self.remaining_time = 7
-                label_text = (f"A game client able to parse URIs was not detected for {game}.\n"
-                              f"Launching Text Client in 7 seconds...")
-                self.timer_label = Label(text=label_text)
-                layout.add_widget(self.timer_label)
-                Clock.schedule_interval(self.update_label, 1)
-            else:
-                layout.add_widget(Label(text="Select client to open and connect with."))
-                button_row = BoxLayout(orientation="horizontal", size_hint=(1, 0.4))
-
-                text_client_button = Button(
-                    text=text_client_component.display_name,
-                    on_release=lambda *args: run_component(text_client_component, *launch_args)
-                )
-                button_row.add_widget(text_client_button)
-
-                game_client_button = Button(
-                    text=client_component.display_name,
-                    on_release=lambda *args: run_component(client_component, *launch_args)
-                )
-                button_row.add_widget(game_client_button)
-
-                layout.add_widget(button_row)
-
-            return layout
-
-        def update_label(self, dt):
-            if self.remaining_time > 1:
-                # countdown the timer and string replace the number
-                self.remaining_time -= 1
-                self.timer_label.text = self.timer_label.text.replace(
-                    str(self.remaining_time + 1), str(self.remaining_time)
-                )
-            else:
-                # our timer is finished so launch text client and close down
-                run_component(text_client_component, *launch_args)
-                Clock.unschedule(self.update_label)
-                App.get_running_app().stop()
-                Window.close()
-
-    Popup().run()
-
-
-def identify(path: Union[None, str]) -> Tuple[Union[None, str], Union[None, Component]]:
+def identify(path: Union[None, str]):
     if path is None:
         return None, None
     for component in components:
@@ -237,12 +160,8 @@ def launch(exe, in_terminal=False):
     subprocess.Popen(exe)
 
 
-refresh_components: Optional[Callable[[], None]] = None
-
-
 def run_gui():
     from kvui import App, ContainerLayout, GridLayout, Button, Label, ScrollBox, Widget
-    from kivy.core.window import Window
     from kivy.uix.image import AsyncImage
     from kivy.uix.relativelayout import RelativeLayout
 
@@ -250,8 +169,11 @@ def run_gui():
         base_title: str = "Archipelago Launcher"
         container: ContainerLayout
         grid: GridLayout
-        _tool_layout: Optional[ScrollBox] = None
-        _client_layout: Optional[ScrollBox] = None
+
+        _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
+        _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
+        _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
+        _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
 
         def __init__(self, ctx=None):
             self.title = self.base_title
@@ -259,7 +181,18 @@ def run_gui():
             self.icon = r"data/icon.png"
             super().__init__()
 
-        def _refresh_components(self) -> None:
+        def build(self):
+            self.container = ContainerLayout()
+            self.grid = GridLayout(cols=2)
+            self.container.add_widget(self.grid)
+            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
+            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
+            tool_layout = ScrollBox()
+            tool_layout.layout.orientation = "vertical"
+            self.grid.add_widget(tool_layout)
+            client_layout = ScrollBox()
+            client_layout.layout.orientation = "vertical"
+            self.grid.add_widget(client_layout)
 
             def build_button(component: Component) -> Widget:
                 """
@@ -284,49 +217,14 @@ def run_gui():
                     return box_layout
                 return button
 
-            # clear before repopulating
-            assert self._tool_layout and self._client_layout, "must call `build` first"
-            tool_children = reversed(self._tool_layout.layout.children)
-            for child in tool_children:
-                self._tool_layout.layout.remove_widget(child)
-            client_children = reversed(self._client_layout.layout.children)
-            for child in client_children:
-                self._client_layout.layout.remove_widget(child)
-
-            _tools = {c.display_name: c for c in components if c.type == Type.TOOL}
-            _clients = {c.display_name: c for c in components if c.type == Type.CLIENT}
-            _adjusters = {c.display_name: c for c in components if c.type == Type.ADJUSTER}
-            _miscs = {c.display_name: c for c in components if c.type == Type.MISC}
-
             for (tool, client) in itertools.zip_longest(itertools.chain(
-                _tools.items(), _miscs.items(), _adjusters.items()
-            ), _clients.items()):
+                    self._tools.items(), self._miscs.items(), self._adjusters.items()), self._clients.items()):
                 # column 1
                 if tool:
-                    self._tool_layout.layout.add_widget(build_button(tool[1]))
+                    tool_layout.layout.add_widget(build_button(tool[1]))
                 # column 2
                 if client:
-                    self._client_layout.layout.add_widget(build_button(client[1]))
-
-        def build(self):
-            self.container = ContainerLayout()
-            self.grid = GridLayout(cols=2)
-            self.container.add_widget(self.grid)
-            self.grid.add_widget(Label(text="General", size_hint_y=None, height=40))
-            self.grid.add_widget(Label(text="Clients", size_hint_y=None, height=40))
-            self._tool_layout = ScrollBox()
-            self._tool_layout.layout.orientation = "vertical"
-            self.grid.add_widget(self._tool_layout)
-            self._client_layout = ScrollBox()
-            self._client_layout.layout.orientation = "vertical"
-            self.grid.add_widget(self._client_layout)
-
-            self._refresh_components()
-
-            global refresh_components
-            refresh_components = self._refresh_components
-
-            Window.bind(on_drop_file=self._on_drop_file)
+                    client_layout.layout.add_widget(build_button(client[1]))
 
             return self.container
 
@@ -337,14 +235,6 @@ def run_gui():
             else:
                 launch(get_exe(button.component), button.component.cli)
 
-        def _on_drop_file(self, window: Window, filename: bytes, x: int, y: int) -> None:
-            """ When a patch file is dropped into the window, run the associated component. """
-            file, component = identify(filename.decode())
-            if file and component:
-                run_component(component, file)
-            else:
-                logging.warning(f"unable to identify component for {file}")
-
         def _stop(self, *largs):
             # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.
             # Closing the window explicitly cleans it up.
@@ -353,17 +243,10 @@ def run_gui():
 
     Launcher().run()
 
-    # avoiding Launcher reference leak
-    # and don't try to do something with widgets after window closed
-    global refresh_components
-    refresh_components = None
-
 
 def run_component(component: Component, *args):
     if component.func:
         component.func(*args)
-        if refresh_components:
-            refresh_components()
     elif component.script_name:
         subprocess.run([*get_exe(component.script_name), *args])
     else:
@@ -376,24 +259,20 @@ def main(args: Optional[Union[argparse.Namespace, dict]] = None):
     elif not args:
         args = {}
 
-    path = args.get("Patch|Game|Component|url", None)
-    if path is not None:
-        if path.startswith("archipelago://"):
-            handle_uri(path, args.get("args", ()))
-            return
-        file, component = identify(path)
+    if args.get("Patch|Game|Component", None) is not None:
+        file, component = identify(args["Patch|Game|Component"])
         if file:
             args['file'] = file
         if component:
             args['component'] = component
         if not component:
-            logging.warning(f"Could not identify Component responsible for {path}")
+            logging.warning(f"Could not identify Component responsible for {args['Patch|Game|Component']}")
 
     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()
@@ -403,16 +282,12 @@ 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',
-        usage="[-h] [--update_settings] [Patch|Game|Component] [-- component args here]"
-    )
+    parser = argparse.ArgumentParser(description='Archipelago Launcher')
     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|url", type=str, nargs="?",
-                           help="Pass either a patch file, a generated game, the component name to run, or a url to "
-                                "connect with.")
+    run_group.add_argument("Patch|Game|Component", type=str, nargs="?",
+                           help="Pass either a patch file, a generated game or the name of a component to run.")
     run_group.add_argument("args", nargs="*",
                            help="Arguments to pass to component.")
     main(parser.parse_args())

LinksAwakeningClient.py

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

LttPAdjuster.py

@@ -14,7 +14,7 @@ import tkinter as tk
 from argparse import Namespace
 from concurrent.futures import as_completed, ThreadPoolExecutor
 from glob import glob
-from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, BOTH, TOP, LabelFrame, \
+from tkinter import Tk, Frame, Label, StringVar, Entry, filedialog, messagebox, Button, Radiobutton, LEFT, X, 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,8 +29,7 @@ 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):
@@ -243,17 +242,16 @@ 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, padx=8, pady=2)
+    bottomFrame2 = Frame(adjustWindow)
 
     romFrame, romVar = get_rom_frame(adjustWindow)
 
-    romDialogFrame = Frame(adjustWindow, padx=8, pady=2)
+    romDialogFrame = Frame(adjustWindow)
     baseRomLabel2 = Label(romDialogFrame, text='Rom to adjust')
     romVar2 = StringVar()
     romEntry2 = Entry(romDialogFrame, textvariable=romVar2)
@@ -263,9 +261,9 @@ def adjustGUI():
         romVar2.set(rom)
 
     romSelectButton2 = Button(romDialogFrame, text='Select Rom', command=RomSelect2)
-    romDialogFrame.pack(side=TOP, expand=False, fill=X)
-    baseRomLabel2.pack(side=LEFT, expand=False, fill=X, padx=(0, 8))
-    romEntry2.pack(side=LEFT, expand=True, fill=BOTH, pady=1)
+    romDialogFrame.pack(side=TOP, expand=True, fill=X)
+    baseRomLabel2.pack(side=LEFT)
+    romEntry2.pack(side=LEFT, expand=True, fill=X)
     romSelectButton2.pack(side=LEFT)
 
     def adjustRom():
@@ -333,11 +331,12 @@ 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, padx=8, pady=8, fill=BOTH, expand=True)
+    rom_options_frame.pack(side=TOP)
     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)
@@ -577,7 +576,7 @@ class AttachTooltip(object):
 def get_rom_frame(parent=None):
     adjuster_settings = get_adjuster_settings(GAME_ALTTP)
 
-    romFrame = Frame(parent, padx=8, pady=8)
+    romFrame = Frame(parent)
     baseRomLabel = Label(romFrame, text='LttP Base Rom: ')
     romVar = StringVar(value=adjuster_settings.baserom)
     romEntry = Entry(romFrame, textvariable=romVar)
@@ -597,19 +596,20 @@ 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=BOTH, pady=1)
+    romEntry.pack(side=LEFT, expand=True, fill=X)
     romSelectButton.pack(side=LEFT)
-    romFrame.pack(side=TOP, fill=X)
+    romFrame.pack(side=TOP, expand=True, 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", padx=8, pady=8)
-
+    romOptionsFrame = LabelFrame(parent, text="Rom options")
+    romOptionsFrame.columnconfigure(0, weight=1)
+    romOptionsFrame.columnconfigure(1, weight=1)
     for i in range(5):
-        romOptionsFrame.rowconfigure(i, weight=0, pad=4)
+        romOptionsFrame.rowconfigure(i, weight=1)
     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, expand=True, fill=X)
+    spriteEntry.pack(side=LEFT)
     spriteSelectButton.pack(side=LEFT)
 
     oofDialogFrame = Frame(romOptionsFrame)

Main.py

@@ -11,8 +11,7 @@ from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
 from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
-from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
-    flood_items
+from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, flood_items
 from Options import StartInventoryPool
 from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
@@ -46,9 +45,6 @@ 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)
@@ -104,7 +100,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.local_early_items[player].get(item_name, 0)
+                    local_early = multiworld.early_local_items[player].get(item_name, 0)
                     if local_early:
                         multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
                     del local_early
@@ -128,19 +124,14 @@ 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:
-                continue
-
-            if location.progress_type != LocationProgressType.EXCLUDED:
-                location.progress_type = LocationProgressType.PRIORITY
+            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
+                if location_name not in multiworld.worlds[player].location_name_to_id:
+                    raise Exception(f"Unable to prioritize location {location_name} in player {player}'s world.") from e
             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
+                location.progress_type = LocationProgressType.PRIORITY
 
     # Set local and non-local item rules.
     if multiworld.players > 1:
@@ -155,7 +146,6 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     # 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):
         new_items: List[Item] = []
-        old_items: List[Item] = []
         depletion_pool: Dict[int, Dict[str, int]] = {
             player: getattr(multiworld.worlds[player].options,
                             "start_inventory_from_pool",
@@ -174,26 +164,97 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 depletion_pool[item.player][item.name] -= 1
                 # quick abort if we have found all items
                 if not target:
-                    old_items.extend(multiworld.itempool[i+1:])
+                    new_items.extend(multiworld.itempool[i+1:])
                     break
             else:
-                old_items.append(item)
+                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:
-                    logger.warning(f"{multiworld.get_player_name(player)}"
+                    raise Exception(f"{multiworld.get_player_name(player)}"
                                     f" is trying to remove items from their pool that don't exist: {remaining_items}")
-                    # find all filler we generated for the current player and remove until it matches 
-                    removables = [item for item in new_items if item.player == player]
-                    for _ in range(sum(remaining_items.values())):
-                        new_items.remove(removables.pop())
-        assert len(multiworld.itempool) == len(new_items + old_items), "Item Pool amounts should not change."
-        multiworld.itempool[:] = new_items + old_items
+        assert len(multiworld.itempool) == len(new_items), "Item Pool amounts should not change."
+        multiworld.itempool[:] = new_items
 
-    multiworld.link_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
+
+        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")
+        multiworld.regions.append(region)
+        locations = region.locations
+        for item in multiworld.itempool:
+            count = common_item_count.get(item.player, {}).get(item.name, 0)
+            if count:
+                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)
+        multiworld.itempool = new_itempool
+
+        while itemcount > len(multiworld.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(multiworld, "create_item", item_player,
+                                                                group["replacement_items"][player]))
+                else:
+                    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
@@ -338,7 +399,6 @@ 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)
 
@@ -351,7 +411,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 FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
+                    raise Exception("Game appears as unbeatable. Aborting.")
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 

ModuleUpdate.py

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

MultiServer.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import argparse
 import asyncio
 import collections
-import contextlib
 import copy
 import datetime
 import functools
@@ -15,7 +14,6 @@ import math
 import operator
 import pickle
 import random
-import shlex
 import threading
 import time
 import typing
@@ -39,7 +37,7 @@ except ImportError:
 
 import NetUtils
 import Utils
-from Utils import version_tuple, restricted_loads, Version, async_start, get_intended_text
+from Utils import version_tuple, restricted_loads, Version, async_start
 from NetUtils import Endpoint, ClientStatus, NetworkItem, decode, encode, NetworkPlayer, Permission, NetworkSlot, \
     SlotType, LocationStore
 
@@ -68,21 +66,6 @@ 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:
@@ -185,17 +168,18 @@ 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[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown item (ID:{code})')
     item_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
-    location_names: typing.Dict[str, typing.Dict[int, str]]
+    location_names: typing.Dict[int, str] = Utils.KeyedDefaultDict(lambda code: f'Unknown location (ID:{code})')
     location_name_groups: typing.Dict[str, typing.Dict[str, typing.Set[str]]]
     all_item_and_group_names: typing.Dict[str, typing.Set[str]]
     all_location_and_group_names: typing.Dict[str, typing.Set[str]]
-    non_hintable_names: typing.Dict[str, typing.AbstractSet[str]]
+    non_hintable_names: typing.Dict[str, typing.Set[str]]
     spheres: typing.List[typing.Dict[int, typing.Set[int]]]
     """ 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,
@@ -245,7 +229,7 @@ class Context:
         self.embedded_blacklist = {"host", "port"}
         self.client_ids: typing.Dict[typing.Tuple[int, int], datetime.datetime] = {}
         self.auto_save_interval = 60  # in seconds
-        self.auto_saver_thread: typing.Optional[threading.Thread] = None
+        self.auto_saver_thread = None
         self.save_dirty = False
         self.tags = ['AP']
         self.games: typing.Dict[int, str] = {}
@@ -266,10 +250,6 @@ 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()
@@ -286,31 +266,19 @@ class Context:
         for world_name, world in worlds.AutoWorldRegister.world_types.items():
             self.non_hintable_names[world_name] = world.hint_blacklist
 
-        for game_package in self.gamespackage.values():
-            # remove groups from data sent to clients
-            del game_package["item_name_groups"]
-            del game_package["location_name_groups"]
-
     def _init_game_data(self):
         for game_name, game_package in self.gamespackage.items():
             if "checksum" in game_package:
                 self.checksums[game_name] = game_package["checksum"]
             for item_name, item_id in game_package["item_name_to_id"].items():
-                self.item_names[game_name][item_id] = item_name
+                self.item_names[item_id] = item_name
             for location_name, location_id in game_package["location_name_to_id"].items():
-                self.location_names[game_name][location_id] = location_name
+                self.location_names[location_id] = location_name
             self.all_item_and_group_names[game_name] = \
                 set(game_package["item_name_to_id"]) | set(self.item_name_groups[game_name])
             self.all_location_and_group_names[game_name] = \
                 set(game_package["location_name_to_id"]) | set(self.location_name_groups.get(game_name, []))
 
-        archipelago_item_names = self.item_names["Archipelago"]
-        archipelago_location_names = self.location_names["Archipelago"]
-        for game in [game_name for game_name in self.gamespackage if game_name != "Archipelago"]:
-            # Add Archipelago items and locations to each data package.
-            self.item_names[game].update(archipelago_item_names)
-            self.location_names[game].update(archipelago_location_names)
-
     def item_names_for_game(self, game: str) -> typing.Optional[typing.Dict[str, int]]:
         return self.gamespackage[game]["item_name_to_id"] if game in self.gamespackage else None
 
@@ -429,8 +397,6 @@ 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},"
@@ -570,9 +536,6 @@ 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()
 
@@ -820,7 +783,10 @@ async def on_client_connected(ctx: Context, client: Client):
         for slot, connected_clients in clients.items():
             if connected_clients:
                 name = ctx.player_names[team, slot]
-                players.append(NetworkPlayer(team, slot, ctx.name_aliases.get((team, slot), name), name))
+                players.append(
+                    NetworkPlayer(team, slot,
+                                  ctx.name_aliases.get((team, slot), name), name)
+                )
     games = {ctx.games[x] for x in range(1, len(ctx.games) + 1)}
     games.add("Archipelago")
     await ctx.send_msgs(client, [{
@@ -835,6 +801,8 @@ async def on_client_connected(ctx: Context, client: Client):
         'permissions': get_permissions(ctx),
         'hint_cost': ctx.hint_cost,
         'location_check_points': ctx.location_check_points,
+        'datapackage_versions': {game: game_data["version"] for game, game_data
+                                 in ctx.gamespackage.items() if game in games},
         'datapackage_checksums': {game: game_data["checksum"] for game, game_data
                                   in ctx.gamespackage.items() if game in games and "checksum" in game_data},
         'seed_name': ctx.seed_name,
@@ -1013,7 +981,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[typing.Tuple[int, int]]:
+def get_remaining(ctx: Context, team: int, slot: int) -> typing.List[int]:
     return ctx.locations.get_remaining(ctx.location_checks, team, slot)
 
 
@@ -1038,8 +1006,8 @@ def register_location_checks(ctx: Context, team: int, slot: int, locations: typi
             send_items_to(ctx, team, target_player, new_item)
 
             ctx.logger.info('(Team #%d) %s sent %s to %s (%s)' % (
-                team + 1, ctx.player_names[(team, slot)], ctx.item_names[ctx.slot_info[target_player].game][item_id],
-                ctx.player_names[(team, target_player)], ctx.location_names[ctx.slot_info[slot].game][location]))
+                team + 1, ctx.player_names[(team, slot)], ctx.item_names[item_id],
+                ctx.player_names[(team, target_player)], ctx.location_names[location]))
             info_text = json_format_send_event(new_item, target_player)
             ctx.broadcast_team(team, [info_text])
 
@@ -1093,8 +1061,8 @@ def collect_hint_location_id(ctx: Context, team: int, slot: int, seeked_location
 
 def format_hint(ctx: Context, team: int, hint: NetUtils.Hint) -> str:
     text = f"[Hint]: {ctx.player_names[team, hint.receiving_player]}'s " \
-           f"{ctx.item_names[ctx.slot_info[hint.receiving_player].game][hint.item]} is " \
-           f"at {ctx.location_names[ctx.slot_info[hint.finding_player].game][hint.location]} " \
+           f"{ctx.item_names[hint.item]} is " \
+           f"at {ctx.location_names[hint.location]} " \
            f"in {ctx.player_names[team, hint.finding_player]}'s World"
 
     if hint.entrance:
@@ -1123,6 +1091,28 @@ def json_format_send_event(net_item: NetworkItem, receiving_player: int):
             "item": net_item}
 
 
+def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bool, str]:
+    picks = Utils.get_fuzzy_results(input_text, possible_answers, limit=2)
+    if len(picks) > 1:
+        dif = picks[0][1] - picks[1][1]
+        if picks[0][1] == 100:
+            return picks[0][0], True, "Perfect Match"
+        elif picks[0][1] < 75:
+            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+        elif dif > 5:
+            return picks[0][0], True, "Close Match"
+        else:
+            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+    else:
+        if picks[0][1] > 90:
+            return picks[0][0], True, "Only Option Match"
+        else:
+            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
+                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
+
+
 class CommandMeta(type):
     def __new__(cls, name, bases, attrs):
         commands = attrs["commands"] = {}
@@ -1154,10 +1144,7 @@ class CommandProcessor(metaclass=CommandMeta):
         if not raw:
             return
         try:
-            try:
-                command = shlex.split(raw, comments=False)
-            except ValueError:  # most likely: "ValueError: No closing quotation"
-                command = raw.split()
+            command = raw.split()
             basecommand = command[0]
             if basecommand[0] == self.marker:
                 method = self.commands.get(basecommand[1:].lower(), None)
@@ -1228,10 +1215,6 @@ 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
 
@@ -1379,10 +1362,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":
-            rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
-            if rest_locations:
-                self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
-                                                            for slot, item_id in rest_locations))
+            remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
+            if remaining_item_ids:
+                self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
+                                                            for item_id in remaining_item_ids))
             else:
                 self.output("No remaining items found.")
             return True
@@ -1392,10 +1375,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
             return False
         else:  # is goal
             if self.ctx.client_game_state[self.client.team, self.client.slot] == ClientStatus.CLIENT_GOAL:
-                rest_locations = get_remaining(self.ctx, self.client.team, self.client.slot)
-                if rest_locations:
-                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[self.ctx.games[slot]][item_id]
-                                                                for slot, item_id in rest_locations))
+                remaining_item_ids = get_remaining(self.ctx, self.client.team, self.client.slot)
+                if remaining_item_ids:
+                    self.output("Remaining items: " + ", ".join(self.ctx.item_names[item_id]
+                                                                for item_id in remaining_item_ids))
                 else:
                     self.output("No remaining items found.")
                 return True
@@ -1412,8 +1395,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_missing_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            game = self.ctx.slot_info[self.client.slot].game
-            names = [self.ctx.location_names[game][location] for location in locations]
+            names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
                 location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
                 if filter_text in location_groups:  # location group name
@@ -1438,8 +1420,7 @@ class ClientMessageProcessor(CommonCommandProcessor):
         locations = get_checked_checks(self.ctx, self.client.team, self.client.slot)
 
         if locations:
-            game = self.ctx.slot_info[self.client.slot].game
-            names = [self.ctx.location_names[game][location] for location in locations]
+            names = [self.ctx.location_names[location] for location in locations]
             if filter_text:
                 location_groups = self.ctx.location_name_groups[self.ctx.games[self.client.slot]]
                 if filter_text in location_groups:  # location group name
@@ -1520,10 +1501,10 @@ class ClientMessageProcessor(CommonCommandProcessor):
         elif input_text.isnumeric():
             game = self.ctx.games[self.client.slot]
             hint_id = int(input_text)
-            hint_name = self.ctx.item_names[game][hint_id] \
-                if not for_location and hint_id in self.ctx.item_names[game] \
-                else self.ctx.location_names[game][hint_id] \
-                if for_location and hint_id in self.ctx.location_names[game] \
+            hint_name = self.ctx.item_names[hint_id] \
+                if not for_location and hint_id in self.ctx.item_names \
+                else self.ctx.location_names[hint_id] \
+                if for_location and hint_id in self.ctx.location_names \
                 else None
             if hint_name in self.ctx.non_hintable_names[game]:
                 self.output(f"Sorry, \"{hint_name}\" is marked as non-hintable.")
@@ -1961,6 +1942,8 @@ class ServerCommandProcessor(CommonCommandProcessor):
     def _cmd_exit(self) -> bool:
         """Shutdown the server"""
         self.ctx.server.ws_server.close()
+        if self.ctx.shutdown_task:
+            self.ctx.shutdown_task.cancel()
         self.ctx.exit_event.set()
         return True
 
@@ -2068,8 +2051,6 @@ 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)
 
@@ -2320,8 +2301,7 @@ def parse_args() -> argparse.Namespace:
 
 
 async def auto_shutdown(ctx, to_cancel=None):
-    with contextlib.suppress(asyncio.TimeoutError):
-        await asyncio.wait_for(ctx.exit_event.wait(), ctx.auto_shutdown)
+    await asyncio.sleep(ctx.auto_shutdown)
 
     def inactivity_shutdown():
         ctx.server.ws_server.close()
@@ -2341,8 +2321,7 @@ async def auto_shutdown(ctx, to_cancel=None):
             if seconds < 0:
                 inactivity_shutdown()
             else:
-                with contextlib.suppress(asyncio.TimeoutError):
-                    await asyncio.wait_for(ctx.exit_event.wait(), seconds)
+                await asyncio.sleep(seconds)
 
 
 def load_server_cert(path: str, cert_key: typing.Optional[str]) -> "ssl.SSLContext":

NetUtils.py

@@ -79,7 +79,6 @@ 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
 
 
@@ -199,8 +198,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         "slateblue": "6D8BE8",
         "plum": "AF99EF",
         "salmon": "FA8072",
-        "white": "FFFFFF",
-        "orange": "FF7700",
+        "white": "FFFFFF"
     }
 
     def __init__(self, ctx):
@@ -249,7 +247,7 @@ class JSONtoTextParser(metaclass=HandlerMeta):
 
     def _handle_item_id(self, node: JSONMessagePart):
         item_id = int(node["text"])
-        node["text"] = self.ctx.item_names.lookup_in_slot(item_id, node["player"])
+        node["text"] = self.ctx.item_names[item_id]
         return self._handle_item_name(node)
 
     def _handle_location_name(self, node: JSONMessagePart):
@@ -257,8 +255,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         return self._handle_color(node)
 
     def _handle_location_id(self, node: JSONMessagePart):
-        location_id = int(node["text"])
-        node["text"] = self.ctx.location_names.lookup_in_slot(location_id, node["player"])
+        item_id = int(node["text"])
+        node["text"] = self.ctx.location_names[item_id]
         return self._handle_location_name(node)
 
     def _handle_entrance_name(self, node: JSONMessagePart):
@@ -273,8 +271,7 @@ 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,
-               'plum': 35, 'slateblue': 34, 'salmon': 31,}  # convert ui colors to terminal colors
+               'blue_bg': 44, 'magenta_bg': 45, 'cyan_bg': 46, 'white_bg': 47}
 
 
 def color_code(*args):
@@ -399,12 +396,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[typing.Tuple[int, int]]:
+                      ) -> typing.List[int]:
         checked = state[team, slot]
         player_locations = self[slot]
-        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
-                        location_id in player_locations if
-                        location_id not in checked])
+        return sorted([player_locations[location_id][0] for
+                       location_id in player_locations if
+                       location_id not in checked])
 
 
 if typing.TYPE_CHECKING:  # type-check with pure python implementation until we have a typing stub

Options.py

@@ -8,17 +8,15 @@ 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, output_path
+from Utils import get_fuzzy_results, is_iterable_except_str
 
 if typing.TYPE_CHECKING:
-    from BaseClasses import MultiWorld, PlandoOptions
+    from BaseClasses import PlandoOptions
     from worlds.AutoWorld import World
     import pathlib
 
@@ -54,8 +52,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 = attrs["aliases"] = {name[6:].lower(): option_id for name, option_id in attrs.items() if
-                                      name.startswith("alias_")}
+        aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
+                   name.startswith("alias_")}
 
         assert (
             name in {"Option", "VerifyKeys"} or  # base abstract classes don't need default
@@ -127,28 +125,10 @@ 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 `World.rich_text_options_doc`. For
-    backwards compatibility, this defaults to False, but worlds are encouraged to
-    set it to True and use reStructuredText for their Option documentation.
-
-    .. _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})"
@@ -754,12 +734,6 @@ 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
@@ -787,22 +761,17 @@ class VerifyKeys(metaclass=FreezeValidKeys):
     verify_location_name: bool = False
     value: typing.Any
 
-    def verify_keys(self) -> None:
-        if self.valid_keys:
-            data = set(self.value)
-            dataset = set(word.casefold() for word in data) if self.valid_keys_casefold else set(data)
-            extra = dataset - self._valid_keys
+    @classmethod
+    def verify_keys(cls, data: typing.Iterable[str]) -> None:
+        if cls.valid_keys:
+            data = set(data)
+            dataset = set(word.casefold() for word in data) if cls.valid_keys_casefold else set(data)
+            extra = dataset - cls._valid_keys
             if extra:
-                raise OptionError(
-                    f"Found unexpected key {', '.join(extra)} in {getattr(self, 'display_name', self)}. "
-                    f"Allowed keys: {self._valid_keys}."
-                )
+                raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
+                                f"Allowed keys: {cls._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:
@@ -839,6 +808,7 @@ 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)}")
@@ -884,6 +854,7 @@ 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))
 
@@ -909,6 +880,7 @@ 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,297 +896,26 @@ class ItemSet(OptionSet):
     convert_name_groups = True
 
 
-class PlandoText(typing.NamedTuple):
-    at: str
-    text: typing.List[str]
-    percentage: int = 100
-
-
-PlandoTextsFromAnyType = typing.Union[
-    typing.Iterable[typing.Union[typing.Mapping[str, typing.Any], PlandoText, typing.Any]], typing.Any
-]
-
-
-class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
-    default = ()
-    supports_weighting = False
-    display_name = "Plando Texts"
-
-    def __init__(self, value: typing.Iterable[PlandoText]) -> None:
-        self.value = list(deepcopy(value))
-        super().__init__()
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        from BaseClasses import PlandoOptions
-        if self.value and not (PlandoOptions.texts & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando texts module is turned off, "
-                            f"so text for {player_name} will be ignored.")
-        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:
-        texts: typing.List[PlandoText] = []
-        if isinstance(data, typing.Iterable):
-            for text in data:
-                if isinstance(text, typing.Mapping):
-                    if random.random() < float(text.get("percentage", 100)/100):
-                        at = text.get("at", None)
-                        if at is not None:
-                            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(
-                                at,
-                                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)}")
-            return cls(texts)
-        else:
-            raise NotImplementedError(f"Cannot Convert from non-list, got {type(data)}")
-
-    @classmethod
-    def get_option_name(cls, value: typing.List[PlandoText]) -> str:
-        return str({text.at: " ".join(text.text) for text in value})
-
-    def __iter__(self) -> typing.Iterator[PlandoText]:
-        yield from self.value
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoText:
-        return self.value.__getitem__(index)
-
-    def __len__(self) -> int:
-        return self.value.__len__()
-
-
-class ConnectionsMeta(AssembleOptions):
-    def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, typing.Any]):
-        if name != "PlandoConnections":
-            assert "entrances" in attrs, f"Please define valid entrances for {name}"
-            attrs["entrances"] = frozenset((connection.lower() for connection in attrs["entrances"]))
-            assert "exits" in attrs, f"Please define valid exits for {name}"
-            attrs["exits"] = frozenset((connection.lower() for connection in attrs["exits"]))
-        if "__doc__" not in attrs:
-            attrs["__doc__"] = PlandoConnections.__doc__
-        cls = super().__new__(mcs, name, bases, attrs)
-        return cls
-
-
-class PlandoConnection(typing.NamedTuple):
-    class Direction:
-        entrance = "entrance"
-        exit = "exit"
-        both = "both"
-
-    entrance: str
-    exit: str
-    direction: typing.Literal["entrance", "exit", "both"]  # TODO: convert Direction to StrEnum once 3.8 is dropped
-    percentage: int = 100
-
-
-PlandoConFromAnyType = typing.Union[
-    typing.Iterable[typing.Union[typing.Mapping[str, typing.Any], PlandoConnection, typing.Any]], typing.Any
-]
-
-
-class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=ConnectionsMeta):
-    """Generic connections plando. Format is:
-    - entrance: "Entrance Name"
-      exit: "Exit Name"
-      direction: "Direction"
-      percentage: 100
-    Direction must be one of 'entrance', 'exit', or 'both', and defaults to 'both' if omitted.
-    Percentage is an integer from 1 to 100, and defaults to 100 when omitted."""
-
-    display_name = "Plando Connections"
-
-    default = ()
-    supports_weighting = False
-
-    entrances: typing.ClassVar[typing.AbstractSet[str]]
-    exits: typing.ClassVar[typing.AbstractSet[str]]
-
-    duplicate_exits: bool = False
-    """Whether or not exits should be allowed to be duplicate."""
-
-    def __init__(self, value: typing.Iterable[PlandoConnection]):
-        self.value = list(deepcopy(value))
-        super(PlandoConnections, self).__init__()
-
-    @classmethod
-    def validate_entrance_name(cls, entrance: str) -> bool:
-        return entrance.lower() in cls.entrances
-
-    @classmethod
-    def validate_exit_name(cls, exit: str) -> bool:
-        return exit.lower() in cls.exits
-
-    @classmethod
-    def can_connect(cls, entrance: str, exit: str) -> bool:
-        """Checks that a given entrance can connect to a given exit.
-        By default, this will always return true unless overridden."""
-        return True
-
-    @classmethod
-    def validate_plando_connections(cls, connections: typing.Iterable[PlandoConnection]) -> None:
-        used_entrances: typing.List[str] = []
-        used_exits: typing.List[str] = []
-        for connection in connections:
-            entrance = connection.entrance
-            exit = connection.exit
-            direction = connection.direction
-            if direction not in (PlandoConnection.Direction.entrance,
-                                 PlandoConnection.Direction.exit,
-                                 PlandoConnection.Direction.both):
-                raise ValueError(f"Unknown direction: {direction}")
-            if entrance in used_entrances:
-                raise ValueError(f"Duplicate Entrance {entrance} not allowed.")
-            if not cls.duplicate_exits and exit in used_exits:
-                raise ValueError(f"Duplicate Exit {exit} not allowed.")
-            used_entrances.append(entrance)
-            used_exits.append(exit)
-            if not cls.validate_entrance_name(entrance):
-                raise ValueError(f"{entrance.title()} is not a valid entrance.")
-            if not cls.validate_exit_name(exit):
-                raise ValueError(f"{exit.title()} is not a valid exit.")
-            if not cls.can_connect(entrance, exit):
-                raise ValueError(f"Connection between {entrance.title()} and {exit.title()} is invalid.")
-
-    @classmethod
-    def from_any(cls, data: PlandoConFromAnyType) -> Self:
-        if not isinstance(data, typing.Iterable):
-            raise Exception(f"Cannot create plando connections from non-List value, got {type(data)}.")
-
-        value: typing.List[PlandoConnection] = []
-        for connection in data:
-            if isinstance(connection, typing.Mapping):
-                percentage = connection.get("percentage", 100)
-                if random.random() < float(percentage / 100):
-                    entrance = connection.get("entrance", None)
-                    if is_iterable_except_str(entrance):
-                        entrance = random.choice(sorted(entrance))
-                    exit = connection.get("exit", None)
-                    if is_iterable_except_str(exit):
-                        exit = random.choice(sorted(exit))
-                    direction = connection.get("direction", "both")
-
-                    if not entrance or not exit:
-                        raise Exception("Plando connection must have an entrance and an exit.")
-                    value.append(PlandoConnection(
-                        entrance,
-                        exit,
-                        direction,
-                        percentage
-                    ))
-            elif isinstance(connection, PlandoConnection):
-                if random.random() < float(connection.percentage / 100):
-                    value.append(connection)
-            else:
-                raise Exception(f"Cannot create connection from non-Dict type, got {type(connection)}.")
-        cls.validate_plando_connections(value)
-        return cls(value)
-
-    def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
-        from BaseClasses import PlandoOptions
-        if self.value and not (PlandoOptions.connections & plando_options):
-            # plando is disabled but plando options were given so overwrite the options
-            self.value = []
-            logging.warning(f"The plando connections module is turned off, "
-                            f"so connections for {player_name} will be ignored.")
-
-    @classmethod
-    def get_option_name(cls, value: typing.List[PlandoConnection]) -> str:
-        return ", ".join(["%s %s %s" % (connection.entrance,
-                                        "<=>" if connection.direction == PlandoConnection.Direction.both else
-                                        "<=" if connection.direction == PlandoConnection.Direction.exit else
-                                        "=>",
-                                        connection.exit) for connection in value])
-
-    def __getitem__(self, index: typing.SupportsIndex) -> PlandoConnection:
-        return self.value.__getitem__(index)
-
-    def __iter__(self) -> typing.Iterator[PlandoConnection]:
-        yield from self.value
-
-    def __len__(self) -> int:
-        return len(self.value)
-
-
 class Accessibility(Choice):
-    """
-    Set rules for reachability of your items/locations.
-    
-    **Full:** ensure everything can be reached and acquired.
-
-    **Minimal:** ensure what is needed to reach your goal can be acquired.
-    """
+    """Set rules for reachability of your items/locations.
+    Locations: ensure everything can be reached and acquired.
+    Items: ensure all logically relevant items can be acquired.
+    Minimal: ensure what is needed to reach your goal can be acquired."""
     display_name = "Accessibility"
-    rich_text_doc = True
-    option_full = 0
+    option_locations = 0
+    option_items = 1
     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 lower setting means more getting stuck. A higher setting means less getting stuck.
-    """
+    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,
@@ -1251,7 +952,6 @@ class CommonOptions(metaclass=OptionsMetaProperty):
         :param option_names: names of the options to return
         :param casing: case of the keys to return. Supports `snake`, `camel`, `pascal`, `kebab`
         """
-        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:
@@ -1280,36 +980,29 @@ 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
+    display_name = "Not Local Items"
 
 
 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):
@@ -1318,33 +1011,28 @@ 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 who enabled death link dies. Of course, the reverse is true too."""
+    """When you die, everyone 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([
         {
@@ -1359,8 +1047,7 @@ class ItemLinks(OptionList):
     ])
 
     @staticmethod
-    def verify_items(items: typing.List[str], item_link: str, pool_name: str, world,
-                     allow_item_groups: bool = True) -> typing.Set:
+    def verify_items(items: typing.List[str], item_link: str, pool_name: str, world, allow_item_groups: bool = True) -> typing.Set:
         pool = set()
         for item_name in items:
             if item_name not in world.item_names and (not allow_item_groups or item_name not in world.item_name_groups):
@@ -1411,7 +1098,6 @@ class ItemLinks(OptionList):
 
 class Removed(FreeText):
     """This Option has been Removed."""
-    rich_text_doc = True
     default = ""
     visibility = Visibility.none
 
@@ -1514,18 +1200,14 @@ 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:
-            option_groups = get_option_groups(world)
+            grouped_options = get_option_groups(world)
             with open(local_path("data", "options.yaml")) as f:
                 file_data = f.read()
             res = Template(file_data).render(
-                option_groups=option_groups,
-                __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
+                option_groups=grouped_options,
+                __version__=__version__, game=game_name, yaml_dump=yaml.dump,
                 dictify_range=dictify_range,
             )
 
@@ -1535,40 +1217,29 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
                 f.write(res)
 
 
-def dump_player_options(multiworld: MultiWorld) -> None:
-    from csv import DictWriter
+if __name__ == "__main__":
 
-    game_players = defaultdict(list)
-    for player, game in multiworld.game.items():
-        game_players[game].append(player)
-    game_players = dict(sorted(game_players.items()))
+    from worlds.alttp.Options import Logic
+    import argparse
 
-    output = []
-    per_game_option_names = [
-        getattr(option, "display_name", option_key)
-        for option_key, option in PerGameCommonOptions.type_hints.items()
-    ]
-    all_option_names = per_game_option_names.copy()
-    for game, players in game_players.items():
-        game_option_names = per_game_option_names.copy()
-        for player in players:
-            world = multiworld.worlds[player]
-            player_output = {
-                "Game": multiworld.game[player],
-                "Name": multiworld.get_player_name(player),
-            }
-            output.append(player_output)
-            for option_key, option in world.options_dataclass.type_hints.items():
-                if issubclass(Removed, option):
-                    continue
-                display_name = getattr(option, "display_name", option_key)
-                player_output[display_name] = getattr(world.options, option_key).current_option_name
-                if display_name not in game_option_names:
-                    all_option_names.append(display_name)
-                    game_option_names.append(display_name)
-
-    with open(output_path(f"generate_{multiworld.seed_name}.csv"), mode="w", newline="") as file:
-        fields = ["Game", "Name", *all_option_names]
-        writer = DictWriter(file, fields)
-        writer.writeheader()
-        writer.writerows(output)
+    map_shuffle = Toggle
+    compass_shuffle = Toggle
+    key_shuffle = Toggle
+    big_key_shuffle = Toggle
+    hints = Toggle
+    test = argparse.Namespace()
+    test.logic = Logic.from_text("no_logic")
+    test.map_shuffle = map_shuffle.from_text("ON")
+    test.hints = hints.from_text('OFF')
+    try:
+        test.logic = Logic.from_text("overworld_glitches_typo")
+    except KeyError as e:
+        print(e)
+    try:
+        test.logic_owg = Logic.from_text("owg")
+    except KeyError as e:
+        print(e)
+    if test.map_shuffle:
+        print("map_shuffle is on")
+    print(f"Hints are {bool(test.hints)}")
+    print(test)

README.md

@@ -72,10 +72,6 @@ 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
 
 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

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=Utils.user_path("Undertale"), exist_ok=True)
+            os.makedirs(name=os.path.join(os.getcwd(), "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=Utils.user_path("Undertale"), exist_ok=True)
+            os.makedirs(name=os.path.join(os.getcwd(), "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),
-                               Utils.user_path("Undertale", file_name))
+                               os.path.join(os.getcwd(), "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(Utils.user_path("Undertale", "data.win"), "rb") as f:
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
             patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
-        with open(Utils.user_path("Undertale", "data.win"), "wb") as f:
+        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
             f.write(patchedFile)
-        os.makedirs(name=Utils.user_path("Undertale", "Custom Sprites"), exist_ok=True)
-        with open(os.path.expandvars(Utils.user_path("Undertale", "Custom Sprites",
+        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
+        with open(os.path.expandvars(os.path.join(os.getcwd(), "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_game(l.item))):
-                        toDraw += str(ctx.item_names.lookup_in_game(l.item))[i]
+                    if i < len(str(ctx.item_names[l.item])):
+                        toDraw += str(ctx.item_names[l.item])[i]
                     else:
                         break
                 f.write(toDraw)

Utils.py

@@ -46,7 +46,7 @@ class Version(typing.NamedTuple):
         return ".".join(str(item) for item in self)
 
 
-__version__ = "0.5.1"
+__version__ = "0.4.6"
 version_tuple = tuplize_version(__version__)
 
 is_linux = sys.platform.startswith("linux")
@@ -423,7 +423,7 @@ class RestrictedUnpickler(pickle.Unpickler):
         if module == "NetUtils" and name in {"NetworkItem", "ClientStatus", "Hint", "SlotType", "NetworkSlot"}:
             return getattr(self.net_utils_module, name)
         # Options and Plando are unpickled by WebHost -> Generate
-        if module == "worlds.generic" and name == "PlandoItem":
+        if module == "worlds.generic" and name in {"PlandoItem", "PlandoConnection"}:
             if not self.generic_properties_module:
                 self.generic_properties_module = importlib.import_module("worlds.generic")
             return getattr(self.generic_properties_module, name)
@@ -434,7 +434,7 @@ class RestrictedUnpickler(pickle.Unpickler):
             else:
                 mod = importlib.import_module(module)
             obj = getattr(mod, name)
-            if issubclass(obj, (self.options_module.Option, self.options_module.PlandoConnection)):
+            if issubclass(obj, self.options_module.Option):
                 return obj
         # Forbid everything else.
         raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
@@ -458,15 +458,6 @@ class KeyedDefaultDict(collections.defaultdict):
     """defaultdict variant that uses the missing key as argument to default_factory"""
     default_factory: typing.Callable[[typing.Any], typing.Any]
 
-    def __init__(self,
-                 default_factory: typing.Callable[[Any], Any] = None,
-                 seq: typing.Union[typing.Mapping, typing.Iterable, None] = None,
-                 **kwargs):
-        if seq is not None:
-            super().__init__(default_factory, seq, **kwargs)
-        else:
-            super().__init__(default_factory, **kwargs)
-
     def __missing__(self, key):
         self[key] = value = self.default_factory(key)
         return value
@@ -553,7 +544,6 @@ def init_logging(name: str, loglevel: typing.Union[str, int] = logging.INFO, wri
         f"Archipelago ({__version__}) logging initialized"
         f" on {platform.platform()}"
         f" running Python {sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
-        f"{' (frozen)' if is_frozen() else ''}"
     )
 
 
@@ -629,41 +619,6 @@ def get_fuzzy_results(input_word: str, word_list: typing.Collection[str], limit:
     )
 
 
-def get_intended_text(input_text: str, possible_answers) -> typing.Tuple[str, bool, str]:
-    picks = get_fuzzy_results(input_text, possible_answers, limit=2)
-    if len(picks) > 1:
-        dif = picks[0][1] - picks[1][1]
-        if picks[0][1] == 100:
-            return picks[0][0], True, "Perfect Match"
-        elif picks[0][1] < 75:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-        elif dif > 5:
-            return picks[0][0], True, "Close Match"
-        else:
-            return picks[0][0], False, f"Too many close matches for '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-    else:
-        if picks[0][1] > 90:
-            return picks[0][0], True, "Only Option Match"
-        else:
-            return picks[0][0], False, f"Didn't find something that closely matches '{input_text}', " \
-                                       f"did you mean '{picks[0][0]}'? ({picks[0][1]}% sure)"
-
-
-def get_input_text_from_response(text: str, command: str) -> typing.Optional[str]:
-    if "did you mean " in text:
-        for question in ("Didn't find something that closely matches",
-                         "Too many close matches"):
-            if text.startswith(question):
-                name = get_text_between(text, "did you mean '",
-                                        "'? (")
-                return f"!{command} {name}"
-    elif text.startswith("Missing: "):
-        return text.replace("Missing: ", "!hint_location ")
-    return None
-
-
 def open_filename(title: str, filetypes: typing.Iterable[typing.Tuple[str, typing.Iterable[str]]], suggest: str = "") \
         -> typing.Optional[str]:
     logging.info(f"Opening file input dialog for {title}.")

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_game(network_item.item)
+                    item_name = self.item_names[network_item.item]
                     if item_name in faction_table.keys():
                         for commander in faction_table[item_name]:
                             logger.info(f"{commander.name} has been unlocked!")
@@ -197,7 +197,7 @@ class WargrooveContext(CommonContext):
                     open(print_path, 'w').close()
                     with open(print_path, 'w') as f:
                         f.write("Received " +
-                                self.item_names.lookup_in_game(network_item.item) +
+                                self.item_names[network_item.item] +
                                 " from " +
                                 self.player_names[network_item.player])
                         f.close()
@@ -267,7 +267,9 @@ class WargrooveContext(CommonContext):
 
             def build(self):
                 container = super().build()
-                self.add_client_tab("Wargroove", self.build_tracker())
+                panel = TabbedPanelItem(text="Wargroove")
+                panel.content = self.build_tracker()
+                self.tabs.add_widget(panel)
                 return container
 
             def build_tracker(self) -> TrackerLayout:
@@ -340,7 +342,7 @@ class WargrooveContext(CommonContext):
             faction_items = 0
             faction_item_names = [faction + ' Commanders' for faction in faction_table.keys()]
             for network_item in self.items_received:
-                if self.item_names.lookup_in_game(network_item.item) in faction_item_names:
+                if self.item_names[network_item.item] in faction_item_names:
                     faction_items += 1
             starting_groove = (faction_items - 1) * self.starting_groove_multiplier
             # Must be an integer larger than 0

WebHost.py

@@ -1,4 +1,3 @@
-import argparse
 import os
 import multiprocessing
 import logging
@@ -13,9 +12,6 @@ ModuleUpdate.update()
 import Utils
 import settings
 
-if typing.TYPE_CHECKING:
-    from flask import Flask
-
 Utils.local_path.cached_path = os.path.dirname(__file__) or "."  # py3.8 is not abs. remove "." when dropping 3.8
 settings.no_gui = True
 configpath = os.path.abspath("config.yaml")
@@ -23,7 +19,7 @@ if not os.path.exists(configpath):  # fall back to config.yaml in home
     configpath = os.path.abspath(Utils.user_path('config.yaml'))
 
 
-def get_app() -> "Flask":
+def get_app():
     from WebHostLib import register, cache, app as raw_app
     from WebHostLib.models import db
 
@@ -32,15 +28,6 @@ def get_app() -> "Flask":
         import yaml
         app.config.from_file(configpath, yaml.safe_load)
         logging.info(f"Updated config from {configpath}")
-    # inside get_app() so it's usable in systems like gunicorn, which do not run WebHost.py, but import it.
-    parser = argparse.ArgumentParser()
-    parser.add_argument('--config_override', default=None,
-                        help="Path to yaml config file that overrules config.yaml.")
-    args = parser.parse_known_args()[0]
-    if args.config_override:
-        import yaml
-        app.config.from_file(os.path.abspath(args.config_override), yaml.safe_load)
-        logging.info(f"Updated config from {args.config_override}")
     if not app.config["HOST_ADDRESS"]:
         logging.info("Getting public IP, as HOST_ADDRESS is empty.")
         app.config["HOST_ADDRESS"] = Utils.get_public_ipv4()
@@ -68,7 +55,6 @@ 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)

WebHostLib/api/__init__.py

@@ -1,15 +1,78 @@
 """API endpoints package."""
 from typing import List, Tuple
+from uuid import UUID
 
-from flask import Blueprint
+from flask import Blueprint, abort, url_for
 
-from ..models import Seed
+import worlds.Files
+from .. import cache
+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]
 
 
-from . import datapackage, generate, room, user  # trigger registration
+@api_endpoints.route('/room_status/<suuid:room>')
+def room_info(room: UUID):
+    room = Room.get(id=room)
+    if room is None:
+        return abort(404)
+    
+    def supports_apdeltapatch(game: str):
+        return game in worlds.Files.AutoPatchRegister.patch_types
+    downloads = []
+    for slot in sorted(room.seed.slots):
+        if slot.data and not supports_apdeltapatch(slot.game):
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_slot_file", room_id=room.id, player_id=slot.player_id)
+            }
+            downloads.append(slot_download)
+        elif slot.data:
+            slot_download = {
+                "slot": slot.player_id,
+                "download": url_for("download_patch", patch_id=slot.id, room_id=room.id)
+            }
+            downloads.append(slot_download)
+    return {
+        "tracker": room.tracker,
+        "players": get_players(room.seed),
+        "last_port": room.last_port,
+        "last_activity": room.last_activity,
+        "timeout": room.timeout,
+        "downloads": downloads,
+    }
+
+
+@api_endpoints.route('/datapackage')
+@cache.cached()
+def get_datapackage():
+    from worlds import network_data_package
+    return network_data_package
+
+
+@api_endpoints.route('/datapackage_version')
+@cache.cached()
+def get_datapackage_versions():
+    from worlds import AutoWorldRegister
+
+    version_package = {game: world.data_version for game, world in AutoWorldRegister.world_types.items()}
+    return version_package
+
+
+@api_endpoints.route('/datapackage_checksum')
+@cache.cached()
+def get_datapackage_checksums():
+    from worlds import network_data_package
+    version_package = {
+        game: game_data["checksum"] for game, game_data in network_data_package["games"].items()
+    }
+    return version_package
+
+
+from . import generate, user  # trigger registration

WebHostLib/api/datapackage.py

@@ -1,32 +0,0 @@
-from flask import abort
-
-from Utils import restricted_loads
-from WebHostLib import cache
-from WebHostLib.models import GameDataPackage
-from . import api_endpoints
-
-
-@api_endpoints.route('/datapackage')
-@cache.cached()
-def get_datapackage():
-    from worlds import network_data_package
-    return network_data_package
-
-
-@api_endpoints.route('/datapackage/<string:checksum>')
-@cache.memoize(timeout=3600)
-def get_datapackage_by_checksum(checksum: str):
-    package = GameDataPackage.get(checksum=checksum)
-    if package:
-        return restricted_loads(package.data)
-    return abort(404)
-
-
-@api_endpoints.route('/datapackage_checksum')
-@cache.cached()
-def get_datapackage_checksums():
-    from worlds import network_data_package
-    version_package = {
-        game: game_data["checksum"] for game, game_data in network_data_package["games"].items()
-    }
-    return version_package

WebHostLib/api/room.py

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

WebHostLib/customserver.py

@@ -72,14 +72,6 @@ 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
@@ -176,28 +168,17 @@ def get_random_port():
 def get_static_server_data() -> dict:
     import worlds
     data = {
-        "non_hintable_names": {
-            world_name: world.hint_blacklist
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
-        "gamespackage": {
-            world_name: {
-                key: value
-                for key, value in game_package.items()
-                if key not in ("item_name_groups", "location_name_groups")
-            }
-            for world_name, game_package in worlds.network_data_package["games"].items()
-        },
-        "item_name_groups": {
-            world_name: world.item_name_groups
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
-        "location_name_groups": {
-            world_name: world.location_name_groups
-            for world_name, world in worlds.AutoWorldRegister.world_types.items()
-        },
+        "non_hintable_names": {},
+        "gamespackage": worlds.network_data_package["games"],
+        "item_name_groups": {world_name: world.item_name_groups for world_name, world in
+                             worlds.AutoWorldRegister.world_types.items()},
+        "location_name_groups": {world_name: world.location_name_groups for world_name, world in
+                                 worlds.AutoWorldRegister.world_types.items()},
     }
 
+    for world_name, world in worlds.AutoWorldRegister.world_types.items():
+        data["non_hintable_names"][world_name] = world.hint_blacklist
+
     return data
 
 
@@ -257,7 +238,6 @@ 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)
@@ -286,16 +266,12 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     ctx.logger.exception("Could not determine port. Likely hosting failure.")
                 with db_session:
                     ctx.auto_shutdown = Room.get(id=room_id).timeout
-                if ctx.saving:
-                    setattr(asyncio.current_task(), "save", lambda: ctx._save(True))
-                assert ctx.shutdown_task is None
                 ctx.shutdown_task = asyncio.create_task(auto_shutdown(ctx, []))
                 await ctx.shutdown_task
 
             except (KeyboardInterrupt, SystemExit):
                 if ctx.saving:
                     ctx._save()
-                    setattr(asyncio.current_task(), "save", None)
             except Exception as e:
                 with db_session:
                     room = Room.get(id=room_id)
@@ -305,12 +281,8 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
             else:
                 if ctx.saving:
                     ctx._save()
-                    setattr(asyncio.current_task(), "save", None)
             finally:
                 try:
-                    ctx.save_dirty = False  # make sure the saving thread does not write to DB after final wakeup
-                    ctx.exit_event.set()  # make sure the saving thread stops at some point
-                    # NOTE: async saving should probably be an async task and could be merged with shutdown_task
                     with (db_session):
                         # ensure the Room does not spin up again on its own, minute of safety buffer
                         room = Room.get(id=room_id)
@@ -322,34 +294,13 @@ def run_server_process(name: str, ponyconfig: dict, static_server_data: dict,
                     rooms_shutting_down.put(room_id)
 
     class Starter(threading.Thread):
-        _tasks: typing.List[asyncio.Future]
-
-        def __init__(self):
-            super().__init__()
-            self._tasks = []
-
-        def _done(self, task: asyncio.Future):
-            self._tasks.remove(task)
-            task.result()
-
         def run(self):
             while 1:
                 next_room = rooms_to_run.get(block=True,  timeout=None)
-                gc.collect()
-                task = asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
-                self._tasks.append(task)
-                task.add_done_callback(self._done)
+                asyncio.run_coroutine_threadsafe(start_room(next_room), loop)
                 logging.info(f"Starting room {next_room} on {name}.")
-                del task  # delete reference to task object
 
     starter = Starter()
     starter.daemon = True
     starter.start()
-    try:
-        loop.run_forever()
-    finally:
-        # save all tasks that want to be saved during shutdown
-        for task in asyncio.all_tasks(loop):
-            save: typing.Optional[typing.Callable[[], typing.Any]] = getattr(task, "save", None)
-            if save:
-                save()
+    loop.run_forever()

WebHostLib/generate.py

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

WebHostLib/misc.py

@@ -1,11 +1,10 @@
 import datetime
 import os
-from typing import Any, IO, Dict, Iterator, List, Tuple, Union
+from typing import List, Dict, 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
@@ -70,28 +69,14 @@ def tutorial_landing():
 
 @app.route('/faq/<string:lang>/')
 @cache.cached()
-def faq(lang: str):
-    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=["mdx_breakless_lists"]),
-    )
+def faq(lang):
+    return render_template("faq.html", lang=lang)
 
 
 @app.route('/glossary/<string:lang>/')
 @cache.cached()
-def glossary(lang: str):
-    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=["mdx_breakless_lists"]),
-    )
+def terms(lang):
+    return render_template("glossary.html", lang=lang)
 
 
 @app.route('/seed/<suuid:seed>')
@@ -112,91 +97,49 @@ def new_room(seed: UUID):
     return redirect(url_for("host_room", room=room.id))
 
 
-def _read_log(log: IO[Any], offset: int = 0) -> Iterator[bytes]:
-    marker = log.read(3)  # skip optional BOM
-    if marker != b'\xEF\xBB\xBF':
-        log.seek(0, os.SEEK_SET)
-    log.seek(offset, os.SEEK_CUR)
-    yield from log
-    log.close()  # free file handle as soon as possible
+def _read_log(path: str):
+    if os.path.exists(path):
+        with open(path, encoding="utf-8-sig") as log:
+            yield from log
+    else:
+        yield f"Logfile {path} does not exist. " \
+              f"Likely a crash during spinup of multiworld instance or it is still spinning up."
 
 
 @app.route('/log/<suuid:room>')
-def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
+def display_log(room: UUID):
     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")
-        try:
-            log = open(file_path, "rb")
-            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")
+        if os.path.exists(file_path):
+            return Response(_read_log(file_path), mimetype="text/plain;charset=UTF-8")
+        return "Log File does not exist."
 
     return "Access Denied", 403
 
 
-@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>")
+@app.route('/room/<suuid:room>', methods=['GET', 'POST'])
 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))
-                      or room.last_activity < now - datetime.timedelta(seconds=room.timeout))
+    should_refresh = not room.last_port and now - room.creation_time < datetime.timedelta(seconds=3)
     with db_session:
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
-    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)
+    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
 
 
 @app.route('/favicon.ico')

WebHostLib/options.py

@@ -3,7 +3,6 @@ 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
@@ -67,22 +66,6 @@ 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)
@@ -93,34 +76,6 @@ def test_ordered(obj):
 def option_presets(game: str) -> Response:
     world = AutoWorldRegister.world_types[game]
 
-    presets = {}
-    for preset_name, preset in world.web.options_presets.items():
-        presets[preset_name] = {}
-        for preset_option_name, preset_option in preset.items():
-            if preset_option == "random":
-                presets[preset_name][preset_option_name] = preset_option
-                continue
-
-            option = world.options_dataclass.type_hints[preset_option_name].from_any(preset_option)
-            if isinstance(option, Options.NamedRange) and isinstance(preset_option, str):
-                assert preset_option in option.special_range_names, \
-                    f"Invalid preset value '{preset_option}' for '{preset_option_name}' in '{preset_name}'. " \
-                    f"Expected {option.special_range_names.keys()} or {option.range_start}-{option.range_end}."
-
-                presets[preset_name][preset_option_name] = option.value
-            elif isinstance(option, (Options.Range, Options.OptionSet, Options.OptionList, Options.ItemDict)):
-                presets[preset_name][preset_option_name] = option.value
-            elif isinstance(preset_option, str):
-                # Ensure the option value is valid for Choice and Toggle options
-                assert option.name_lookup[option.value] == preset_option, \
-                    f"Invalid option value '{preset_option}' for '{preset_option_name}' in preset '{preset_name}'. " \
-                    f"Values must not be resolved to a different option via option.from_text (or an alias)."
-                # Use the name of the option
-                presets[preset_name][preset_option_name] = option.current_key
-            else:
-                # Use the name of the option
-                presets[preset_name][preset_option_name] = option.current_key
-
     class SetEncoder(json.JSONEncoder):
         def default(self, obj):
             from collections.abc import Set
@@ -128,7 +83,7 @@ def option_presets(game: str) -> Response:
                 return list(obj)
             return json.JSONEncoder.default(self, obj)
 
-    json_data = json.dumps(presets, cls=SetEncoder)
+    json_data = json.dumps(world.web.options_presets, cls=SetEncoder)
     response = Response(json_data)
     response.headers["Content-Type"] = "application/json"
     return response
@@ -231,13 +186,6 @@ 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-"):

WebHostLib/requirements.txt

@@ -1,13 +1,9 @@
-flask>=3.0.3
-werkzeug>=3.0.4
-pony>=0.7.19
-waitress>=3.0.0
-Flask-Caching>=2.3.0
-Flask-Compress>=1.15
-Flask-Limiter>=3.8.0
+flask>=3.0.0
+pony>=0.7.17
+waitress>=2.1.2
+Flask-Caching>=2.1.0
+Flask-Compress>=1.14
+Flask-Limiter>=3.5.0
 bokeh>=3.1.1; python_version <= '3.8'
-bokeh>=3.4.3; python_version == '3.9'
-bokeh>=3.5.2; python_version >= '3.10'
-markupsafe>=2.1.5
-Markdown>=3.7
-mdx-breakless-lists>=1.0.1
+bokeh>=3.3.2; python_version >= '3.9'
+markupsafe>=2.1.3

WebHostLib/robots.py

@@ -8,8 +8,7 @@ from . import cache
 def robots():
     # If this host is not official, do not allow search engine crawling
     if not app.config["ASSET_RIGHTS"]:
-        # filename changed in case the path is intercepted and served by an outside service
-        return app.send_static_file('robots_file.txt')
+        return app.send_static_file('robots.txt')
 
     # Send 404 if the host has affirmed this to be the official WebHost
     abort(404)

WebHostLib/static/assets/faq.js

@@ -0,0 +1,51 @@
+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>`;
+    });
+});

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 **#ap-world-dev** channel on our Discord.
+If you have more questions, feel free to ask in the **#archipelago-dev** channel on our Discord.

WebHostLib/static/assets/glossary.js

@@ -0,0 +1,51 @@
+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>`;
+    });
+});

WebHostLib/static/assets/playerOptions.js

@@ -288,11 +288,6 @@ 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"

WebHostLib/static/assets/trackerCommon.js

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

WebHostLib/static/static/branding/header-logo-full.svg

@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Generator: Adobe Illustrator 26.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 240 38" style="enable-background:new 0 0 240 38;" xml:space="preserve">
-<style type="text/css">
-	.st0{fill:#316B84;}
-</style>
-<g>
-	<g>
-		<path class="st0" d="M59.72,27.96L53.03,4.21L42.25,4.04l1.42,4.37l1.41-0.26l-7.9,24.22h8.44l-0.56-2.27l-0.81-3.27l8.9-5.7
-			l1.78,11.24h7.97v-4.73L59.72,27.96z M45.62,20.21l3.13-10.84h1.5l2.02,7.44L45.62,20.21z"/>
-		<path class="st0" d="M78.67,27.96V20.4l-4.11-2.5l3.29-3.78l-0.47-7.46l-2.82-2.45H56.65v5.27l3.81-1.11l2.31,13.36l-2.79,0.73
-			L61,26.34l5.06-0.52l0.36-6.15l4.32,0.13l3.16,3.62v8.94l12.89,1.49v-5.34L78.67,27.96z M73.27,13.33l-2.18,1.45h-4.64l-0.42-6.57
-			h5.68l1.55,1.37V13.33z"/>
-		<polygon class="st0" points="84.65,4.21 93.01,4.21 95.75,6.46 96.26,10.9 92.23,12.43 91.77,9.74 88.97,8.28 85.86,9.82 
-			83.88,15.02 85.51,20.94 88.49,22.38 91.99,20.59 91.99,18.59 96.26,16.96 95.85,22.85 91.81,26.87 84.17,26.55 80.79,23.58 
-			78.87,14.87 80.79,6.94 		"/>
-		<polygon class="st0" points="97.62,4.21 103.33,4.21 102.96,21.08 108.7,20.14 108.34,6.42 113.85,3.28 113.9,19.9 115.75,19.71 
-			115.27,25.86 113.88,25.86 114.27,32.36 108.7,32.36 108.7,26.39 102.96,26.39 102.96,32.36 91.77,33.85 92.2,28.85 97.88,27.96 
-					"/>
-		<polygon class="st0" points="147.43,28.86 147.43,32.36 162.85,32.36 162.48,25.36 159.5,26 158.89,27.68 154.1,27.24 
-			154.1,21.51 160.81,20.85 160.81,16.48 153.86,16.54 153.86,9.18 158.62,8.43 159.22,9.77 161.85,10.06 162.59,4 147.43,4 
-			147.43,6.54 148.68,7.46 148.68,28.4 		"/>
-		<polygon class="st0" points="163.89,9.24 163.89,4 172.31,4 170.35,26.87 179.55,24.74 179.55,32.36 164.51,32.34 164.65,28.71 
-			165.73,27.84 165.73,9.59 		"/>
-		<path class="st0" d="M193.69,32.36l-0.63-2.51l-2.84-1.89l-4.29-20.14L185.9,4h-11.27l-0.03,3.2l1.87-0.34l-2.79,14.07l-1.37,0.57
-			v2.85l6.29-1.33l0.4-2.7l4.65-0.89l1.69,12.93H193.69z M179.39,15.11l1.65-6.52l0.89,0.25l0.92,5.45L179.39,15.11z"/>
-		<polygon class="st0" points="208.47,21.68 210.62,21.12 210.04,18.15 200.51,17.46 198.87,21.13 203.56,21.9 203.32,23.91 
-			200.58,25.19 196.44,23.77 194.48,17.19 196.2,10.02 200.08,8.52 203.31,9.62 202.85,11.75 207.79,13.6 208.83,9.69 204.71,4.21 
-			195.57,4.21 191.24,7.36 189.29,16.87 192.06,27.54 199.03,30.53 203.2,29.3 203.09,32.36 209.01,32.36 209.4,29.95 207.38,28.99 
-					"/>
-		<path class="st0" d="M230.45,6.26L226.39,4l-8.59-0.01l-4.07,2.86l-2.58,8.9l1.52,11.82l5.61,4.73l7.65,0.01l5.72-4.59l2.47-12.46
-			L230.45,6.26z M228.23,21.75l-3.95,5.45l-2.16,0.43l-4.6-3.46L216,15.72l2.4-7.02l5.14-0.48l2.97,1.79l1.74,5.83L228.23,21.75z"/>
-		<path class="st0" d="M116.13,27.48l-0.24,4.88l12.26,0.09l-0.83-5.01l-2.86-0.48l0.14-17.62l2.45-0.42l-0.14-4.85l-10.92,0.36
-			l0.1,4.6l3.2,0.63l-0.42,17.67L116.13,27.48z"/>
-		<path class="st0" d="M141.34,4.21l-12.88-0.39v4.26l1.95,0.62v25.15l-1.8,1.41l-0.02,2.63h8.23L136,27.96h6.09l4.57-4.46V7.27
-			L141.34,4.21z M141.38,20.51l-2.54,1.89l-3.23,0.16L135.4,9.32h3.88l2.1,1.68V20.51z"/>
-	</g>
-	<g>
-		<path class="st0" d="M14.14,11.28c0,0.35-0.02,0.71-0.07,1.05c0.38,0.07,0.76,0.11,1.16,0.11s0.79-0.04,1.16-0.11
-			c-0.05-0.34-0.07-0.7-0.07-1.05c0-3.23,1.94-6.02,4.72-7.25C20.17,1.68,17.9,0,15.24,0S10.3,1.68,9.42,4.03
-			C12.2,5.26,14.14,8.04,14.14,11.28z"/>
-		<path class="st0" d="M18.04,11.28c0,0.16,0.01,0.32,0.02,0.48c0.02,0.3,0.06,0.6,0.13,0.88c0.06,0.28,0.15,0.56,0.25,0.83
-			c0.11,0.3,0.24,0.58,0.39,0.85c1.42-1.33,3.33-2.15,5.42-2.15s4.01,0.82,5.42,2.15c0.51-0.9,0.79-1.94,0.79-3.04
-			c0-3.42-2.79-6.22-6.22-6.22c-0.4,0-0.79,0.04-1.16,0.11c-0.28,0.06-0.56,0.13-0.83,0.22c-0.28,0.09-0.56,0.21-0.83,0.35
-			C19.42,6.77,18.04,8.87,18.04,11.28z"/>
-		<path class="st0" d="M6.22,12.16c2.1,0,4.01,0.82,5.42,2.15c0.15-0.27,0.28-0.55,0.39-0.85c0.1-0.27,0.19-0.54,0.25-0.83
-			c0.06-0.28,0.11-0.58,0.13-0.88c0.02-0.15,0.02-0.32,0.02-0.48c0-2.41-1.38-4.51-3.39-5.54C8.77,5.6,8.5,5.49,8.21,5.39
-			c-0.27-0.1-0.55-0.17-0.83-0.22C7,5.1,6.61,5.06,6.22,5.06C2.79,5.06,0,7.85,0,11.28c0,1.1,0.28,2.14,0.79,3.04
-			C2.21,12.98,4.12,12.16,6.22,12.16z"/>
-		<path class="st0" d="M29.21,16.33c-0.18-0.23-0.36-0.44-0.57-0.65c-1.12-1.12-2.67-1.81-4.38-1.81c-1.71,0-3.25,0.69-4.38,1.81
-			c-0.2,0.2-0.39,0.42-0.56,0.64c-0.18,0.23-0.34,0.47-0.47,0.72c-0.2,0.34-0.36,0.71-0.48,1.09c2.83,1.21,4.81,4.02,4.81,7.28
-			c0,0.26-0.01,0.52-0.04,0.78c0.37,0.07,0.75,0.1,1.13,0.1c3.43,0,6.22-2.79,6.22-6.22c0-1.11-0.29-2.14-0.8-3.04
-			C29.54,16.8,29.38,16.56,29.21,16.33z"/>
-		<path class="st0" d="M12.12,18.14c-0.13-0.38-0.28-0.75-0.48-1.09c-0.14-0.26-0.3-0.5-0.47-0.72c-0.17-0.23-0.36-0.44-0.56-0.64
-			c-1.12-1.12-2.67-1.81-4.38-1.81s-3.26,0.69-4.38,1.81c-0.21,0.2-0.39,0.42-0.56,0.64c-0.18,0.23-0.34,0.47-0.47,0.72
-			C0.29,17.94,0,18.98,0,20.08c0,3.43,2.79,6.22,6.22,6.22c0.39,0,0.76-0.03,1.13-0.1c-0.03-0.26-0.04-0.52-0.04-0.78
-			C7.31,22.15,9.29,19.34,12.12,18.14z"/>
-		<path class="st0" d="M18.04,19.87c-0.27-0.14-0.55-0.26-0.84-0.35c-0.27-0.09-0.55-0.17-0.84-0.22c-0.37-0.07-0.75-0.1-1.13-0.1
-			s-0.76,0.03-1.13,0.1c-0.28,0.05-0.57,0.13-0.84,0.22c-0.29,0.1-0.57,0.22-0.84,0.35C10.4,20.9,9.02,23,9.02,25.42
-			c0,0.07,0,0.14,0.01,0.21c0.01,0.31,0.04,0.61,0.1,0.9c0.05,0.28,0.12,0.57,0.21,0.84c0.82,2.48,3.16,4.27,5.9,4.27
-			s5.08-1.79,5.9-4.27c0.09-0.27,0.17-0.55,0.21-0.84c0.06-0.3,0.09-0.6,0.1-0.91c0.01-0.07,0.01-0.14,0.01-0.21
-			C21.45,23,20.07,20.9,18.04,19.87z"/>
-	</g>
-</g>
-</svg>

WebHostLib/static/static/branding/header-logo.svg

@@ -1 +1,66 @@
-<?xml version="1.0" encoding="utf-8"?><svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" x="0" y="0" viewBox="0 0 240 38" style="enable-background:new 0 0 240 38" xml:space="preserve"><style>.st0{fill:#316b84}</style><path class="st0" d="M59.72 27.96 53.03 4.21l-10.78-.17 1.42 4.37 1.41-.26-7.9 24.22h8.44l-.56-2.27-.81-3.27 8.9-5.7 1.78 11.24h7.97v-4.73l-3.18.32zm-14.1-7.75 3.13-10.84h1.5l2.02 7.44-6.65 3.4z"/><path class="st0" d="M78.67 27.96V20.4l-4.11-2.5 3.29-3.78-.47-7.46-2.82-2.45H56.65v5.27l3.81-1.11 2.31 13.36-2.79.73L61 26.34l5.06-.52.36-6.15 4.32.13 3.16 3.62v8.94l12.89 1.49v-5.34l-8.12-.55zm-5.4-14.63-2.18 1.45h-4.64l-.42-6.57h5.68l1.55 1.37v3.75z"/><path class="st0" d="M84.65 4.21h8.36l2.74 2.25.51 4.44-4.03 1.53-.46-2.69-2.8-1.46-3.11 1.54-1.98 5.2 1.63 5.92 2.98 1.44 3.5-1.79v-2l4.27-1.63-.41 5.89-4.04 4.02-7.64-.32-3.38-2.97-1.92-8.71 1.92-7.93z"/><path class="st0" d="M97.62 4.21h5.71l-.37 16.87 5.74-.94-.36-13.72 5.51-3.14.05 16.62 1.85-.19-.48 6.15h-1.39l.39 6.5h-5.57v-5.97h-5.74v5.97l-11.19 1.49.43-5 5.68-.89zm49.81 24.65v3.5h15.42l-.37-7-2.98.64-.61 1.68-4.79-.44v-5.73l6.71-.66v-4.37l-6.95.06V9.18l4.76-.75.6 1.34 2.63.29.74-6.06h-15.16v2.54l1.25.92V28.4zm16.46-19.62V4h8.42l-1.96 22.87 9.2-2.13v7.62l-15.04-.02.14-3.63 1.08-.87V9.59z"/><path class="st0" d="m193.69 32.36-.63-2.51-2.84-1.89-4.29-20.14L185.9 4h-11.27l-.03 3.2 1.87-.34-2.79 14.07-1.37.57v2.85l6.29-1.33.4-2.7 4.65-.89 1.69 12.93h8.35zm-14.3-17.25 1.65-6.52.89.25.92 5.45-3.46.82z"/><path class="st0" d="m208.47 21.68 2.15-.56-.58-2.97-9.53-.69-1.64 3.67 4.69.77-.24 2.01-2.74 1.28-4.14-1.42-1.96-6.58 1.72-7.17 3.88-1.5 3.23 1.1-.46 2.13 4.94 1.85 1.04-3.91-4.12-5.48h-9.14l-4.33 3.15-1.95 9.51 2.77 10.67 6.97 2.99 4.17-1.23-.11 3.06h5.92l.39-2.41-2.02-.96zm21.98-15.42L226.39 4l-8.59-.01-4.07 2.86-2.58 8.9 1.52 11.82 5.61 4.73 7.65.01 5.72-4.59 2.47-12.46-3.67-9zm-2.22 15.49-3.95 5.45-2.16.43-4.6-3.46-1.52-8.45 2.4-7.02 5.14-.48 2.97 1.79 1.74 5.83-.02 5.91zm-112.1 5.73-.24 4.88 12.26.09-.83-5.01-2.86-.48.14-17.62 2.45-.42-.14-4.85-10.92.36.1 4.6 3.2.63-.42 17.67-2.74.15zm25.21-23.27-12.88-.39v4.26l1.95.62v25.15l-1.8 1.41-.02 2.63h8.23l-.82-9.93h6.09l4.57-4.46V7.27l-5.32-3.06zm.04 16.3-2.54 1.89-3.23.16-.21-13.24h3.88l2.1 1.68v9.51zM14.14 11.28c0 .35-.02.71-.07 1.05.38.07.76.11 1.16.11s.79-.04 1.16-.11a7.933 7.933 0 0 1 4.65-8.3C20.17 1.68 17.9 0 15.24 0S10.3 1.68 9.42 4.03a7.922 7.922 0 0 1 4.72 7.25z"/><path class="st0" d="M18.04 11.28c0 .16.01.32.02.48.02.3.06.6.13.88.06.28.15.56.25.83.11.3.24.58.39.85 1.42-1.33 3.33-2.15 5.42-2.15s4.01.82 5.42 2.15c.51-.9.79-1.94.79-3.04 0-3.42-2.79-6.22-6.22-6.22-.4 0-.79.04-1.16.11-.28.06-.56.13-.83.22-.28.09-.56.21-.83.35a6.24 6.24 0 0 0-3.38 5.54zm-11.82.88c2.1 0 4.01.82 5.42 2.15.15-.27.28-.55.39-.85.1-.27.19-.54.25-.83.06-.28.11-.58.13-.88.02-.15.02-.32.02-.48a6.23 6.23 0 0 0-3.39-5.54c-.27-.13-.54-.24-.83-.34-.27-.1-.55-.17-.83-.22a6.42 6.42 0 0 0-1.16-.11 6.227 6.227 0 0 0-5.43 9.26 7.885 7.885 0 0 1 5.43-2.16z"/><path class="st0" d="M29.21 16.33c-.18-.23-.36-.44-.57-.65a6.174 6.174 0 0 0-4.38-1.81 6.192 6.192 0 0 0-4.94 2.45c-.18.23-.34.47-.47.72-.2.34-.36.71-.48 1.09a7.923 7.923 0 0 1 4.77 8.06c.37.07.75.1 1.13.1 3.43 0 6.22-2.79 6.22-6.22 0-1.11-.29-2.14-.8-3.04-.15-.23-.31-.47-.48-.7zm-17.09 1.81c-.13-.38-.28-.75-.48-1.09-.14-.26-.3-.5-.47-.72-.17-.23-.36-.44-.56-.64-1.12-1.12-2.67-1.81-4.38-1.81s-3.26.69-4.38 1.81c-.21.2-.39.42-.56.64-.18.23-.34.47-.47.72-.53.89-.82 1.93-.82 3.03 0 3.43 2.79 6.22 6.22 6.22.39 0 .76-.03 1.13-.1a7.902 7.902 0 0 1 4.77-8.06z"/><path class="st0" d="M18.04 19.87c-.27-.14-.55-.26-.84-.35-.27-.09-.55-.17-.84-.22-.37-.07-.75-.1-1.13-.1s-.76.03-1.13.1c-.28.05-.57.13-.84.22-.29.1-.57.22-.84.35a6.225 6.225 0 0 0-3.4 5.55c0 .07 0 .14.01.21.01.31.04.61.1.9.05.28.12.57.21.84.82 2.48 3.16 4.27 5.9 4.27s5.08-1.79 5.9-4.27c.09-.27.17-.55.21-.84.06-.3.09-.6.1-.91.01-.07.01-.14.01-.21a6.24 6.24 0 0 0-3.42-5.54z"/></svg>
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 26.0.3, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 240 38" style="enable-background:new 0 0 240 38;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#316B84;}
+</style>
+<g>
+	<g>
+		<path class="st0" d="M59.72,27.96L53.03,4.21L42.25,4.04l1.42,4.37l1.41-0.26l-7.9,24.22h8.44l-0.56-2.27l-0.81-3.27l8.9-5.7
+			l1.78,11.24h7.97v-4.73L59.72,27.96z M45.62,20.21l3.13-10.84h1.5l2.02,7.44L45.62,20.21z"/>
+		<path class="st0" d="M78.67,27.96V20.4l-4.11-2.5l3.29-3.78l-0.47-7.46l-2.82-2.45H56.65v5.27l3.81-1.11l2.31,13.36l-2.79,0.73
+			L61,26.34l5.06-0.52l0.36-6.15l4.32,0.13l3.16,3.62v8.94l12.89,1.49v-5.34L78.67,27.96z M73.27,13.33l-2.18,1.45h-4.64l-0.42-6.57
+			h5.68l1.55,1.37V13.33z"/>
+		<polygon class="st0" points="84.65,4.21 93.01,4.21 95.75,6.46 96.26,10.9 92.23,12.43 91.77,9.74 88.97,8.28 85.86,9.82 
+			83.88,15.02 85.51,20.94 88.49,22.38 91.99,20.59 91.99,18.59 96.26,16.96 95.85,22.85 91.81,26.87 84.17,26.55 80.79,23.58 
+			78.87,14.87 80.79,6.94 		"/>
+		<polygon class="st0" points="97.62,4.21 103.33,4.21 102.96,21.08 108.7,20.14 108.34,6.42 113.85,3.28 113.9,19.9 115.75,19.71 
+			115.27,25.86 113.88,25.86 114.27,32.36 108.7,32.36 108.7,26.39 102.96,26.39 102.96,32.36 91.77,33.85 92.2,28.85 97.88,27.96 
+					"/>
+		<polygon class="st0" points="147.43,28.86 147.43,32.36 162.85,32.36 162.48,25.36 159.5,26 158.89,27.68 154.1,27.24 
+			154.1,21.51 160.81,20.85 160.81,16.48 153.86,16.54 153.86,9.18 158.62,8.43 159.22,9.77 161.85,10.06 162.59,4 147.43,4 
+			147.43,6.54 148.68,7.46 148.68,28.4 		"/>
+		<polygon class="st0" points="163.89,9.24 163.89,4 172.31,4 170.35,26.87 179.55,24.74 179.55,32.36 164.51,32.34 164.65,28.71 
+			165.73,27.84 165.73,9.59 		"/>
+		<path class="st0" d="M193.69,32.36l-0.63-2.51l-2.84-1.89l-4.29-20.14L185.9,4h-11.27l-0.03,3.2l1.87-0.34l-2.79,14.07l-1.37,0.57
+			v2.85l6.29-1.33l0.4-2.7l4.65-0.89l1.69,12.93H193.69z M179.39,15.11l1.65-6.52l0.89,0.25l0.92,5.45L179.39,15.11z"/>
+		<polygon class="st0" points="208.47,21.68 210.62,21.12 210.04,18.15 200.51,17.46 198.87,21.13 203.56,21.9 203.32,23.91 
+			200.58,25.19 196.44,23.77 194.48,17.19 196.2,10.02 200.08,8.52 203.31,9.62 202.85,11.75 207.79,13.6 208.83,9.69 204.71,4.21 
+			195.57,4.21 191.24,7.36 189.29,16.87 192.06,27.54 199.03,30.53 203.2,29.3 203.09,32.36 209.01,32.36 209.4,29.95 207.38,28.99 
+					"/>
+		<path class="st0" d="M230.45,6.26L226.39,4l-8.59-0.01l-4.07,2.86l-2.58,8.9l1.52,11.82l5.61,4.73l7.65,0.01l5.72-4.59l2.47-12.46
+			L230.45,6.26z M228.23,21.75l-3.95,5.45l-2.16,0.43l-4.6-3.46L216,15.72l2.4-7.02l5.14-0.48l2.97,1.79l1.74,5.83L228.23,21.75z"/>
+		<path class="st0" d="M116.13,27.48l-0.24,4.88l12.26,0.09l-0.83-5.01l-2.86-0.48l0.14-17.62l2.45-0.42l-0.14-4.85l-10.92,0.36
+			l0.1,4.6l3.2,0.63l-0.42,17.67L116.13,27.48z"/>
+		<path class="st0" d="M141.34,4.21l-12.88-0.39v4.26l1.95,0.62v25.15l-1.8,1.41l-0.02,2.63h8.23L136,27.96h6.09l4.57-4.46V7.27
+			L141.34,4.21z M141.38,20.51l-2.54,1.89l-3.23,0.16L135.4,9.32h3.88l2.1,1.68V20.51z"/>
+	</g>
+	<g>
+		<path class="st0" d="M14.14,11.28c0,0.35-0.02,0.71-0.07,1.05c0.38,0.07,0.76,0.11,1.16,0.11s0.79-0.04,1.16-0.11
+			c-0.05-0.34-0.07-0.7-0.07-1.05c0-3.23,1.94-6.02,4.72-7.25C20.17,1.68,17.9,0,15.24,0S10.3,1.68,9.42,4.03
+			C12.2,5.26,14.14,8.04,14.14,11.28z"/>
+		<path class="st0" d="M18.04,11.28c0,0.16,0.01,0.32,0.02,0.48c0.02,0.3,0.06,0.6,0.13,0.88c0.06,0.28,0.15,0.56,0.25,0.83
+			c0.11,0.3,0.24,0.58,0.39,0.85c1.42-1.33,3.33-2.15,5.42-2.15s4.01,0.82,5.42,2.15c0.51-0.9,0.79-1.94,0.79-3.04
+			c0-3.42-2.79-6.22-6.22-6.22c-0.4,0-0.79,0.04-1.16,0.11c-0.28,0.06-0.56,0.13-0.83,0.22c-0.28,0.09-0.56,0.21-0.83,0.35
+			C19.42,6.77,18.04,8.87,18.04,11.28z"/>
+		<path class="st0" d="M6.22,12.16c2.1,0,4.01,0.82,5.42,2.15c0.15-0.27,0.28-0.55,0.39-0.85c0.1-0.27,0.19-0.54,0.25-0.83
+			c0.06-0.28,0.11-0.58,0.13-0.88c0.02-0.15,0.02-0.32,0.02-0.48c0-2.41-1.38-4.51-3.39-5.54C8.77,5.6,8.5,5.49,8.21,5.39
+			c-0.27-0.1-0.55-0.17-0.83-0.22C7,5.1,6.61,5.06,6.22,5.06C2.79,5.06,0,7.85,0,11.28c0,1.1,0.28,2.14,0.79,3.04
+			C2.21,12.98,4.12,12.16,6.22,12.16z"/>
+		<path class="st0" d="M29.21,16.33c-0.18-0.23-0.36-0.44-0.57-0.65c-1.12-1.12-2.67-1.81-4.38-1.81c-1.71,0-3.25,0.69-4.38,1.81
+			c-0.2,0.2-0.39,0.42-0.56,0.64c-0.18,0.23-0.34,0.47-0.47,0.72c-0.2,0.34-0.36,0.71-0.48,1.09c2.83,1.21,4.81,4.02,4.81,7.28
+			c0,0.26-0.01,0.52-0.04,0.78c0.37,0.07,0.75,0.1,1.13,0.1c3.43,0,6.22-2.79,6.22-6.22c0-1.11-0.29-2.14-0.8-3.04
+			C29.54,16.8,29.38,16.56,29.21,16.33z"/>
+		<path class="st0" d="M12.12,18.14c-0.13-0.38-0.28-0.75-0.48-1.09c-0.14-0.26-0.3-0.5-0.47-0.72c-0.17-0.23-0.36-0.44-0.56-0.64
+			c-1.12-1.12-2.67-1.81-4.38-1.81s-3.26,0.69-4.38,1.81c-0.21,0.2-0.39,0.42-0.56,0.64c-0.18,0.23-0.34,0.47-0.47,0.72
+			C0.29,17.94,0,18.98,0,20.08c0,3.43,2.79,6.22,6.22,6.22c0.39,0,0.76-0.03,1.13-0.1c-0.03-0.26-0.04-0.52-0.04-0.78
+			C7.31,22.15,9.29,19.34,12.12,18.14z"/>
+		<path class="st0" d="M18.04,19.87c-0.27-0.14-0.55-0.26-0.84-0.35c-0.27-0.09-0.55-0.17-0.84-0.22c-0.37-0.07-0.75-0.1-1.13-0.1
+			s-0.76,0.03-1.13,0.1c-0.28,0.05-0.57,0.13-0.84,0.22c-0.29,0.1-0.57,0.22-0.84,0.35C10.4,20.9,9.02,23,9.02,25.42
+			c0,0.07,0,0.14,0.01,0.21c0.01,0.31,0.04,0.61,0.1,0.9c0.05,0.28,0.12,0.57,0.21,0.84c0.82,2.48,3.16,4.27,5.9,4.27
+			s5.08-1.79,5.9-4.27c0.09-0.27,0.17-0.55,0.21-0.84c0.06-0.3,0.09-0.6,0.1-0.91c0.01-0.07,0.01-0.14,0.01-0.21
+			C21.45,23,20.07,20.9,18.04,19.87z"/>
+	</g>
+</g>
+</svg>

WebHostLib/static/styles/hostRoom.css

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

WebHostLib/static/styles/playerOptions/playerOptions.css

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

WebHostLib/static/styles/playerOptions/playerOptions.scss

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

WebHostLib/static/styles/tooltip.css

@@ -12,12 +12,12 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 */
 
 /* Base styles for the element that has a tooltip */
-[data-tooltip], .tooltip-container {
+[data-tooltip], .tooltip {
 	position: relative;
 }
 
 /* Base styles for the entire tooltip */
-[data-tooltip]:before, [data-tooltip]:after, .tooltip-container:before, .tooltip {
+[data-tooltip]:before, [data-tooltip]:after, .tooltip:before, .tooltip:after {
 	position: absolute;
 	visibility: hidden;
 	opacity: 0;
@@ -39,15 +39,14 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 	pointer-events: none;
 }
 
-[data-tooltip]:hover:before, [data-tooltip]:hover:after, .tooltip-container:hover:before,
-.tooltip-container:hover .tooltip {
+[data-tooltip]:hover:before, [data-tooltip]:hover:after, .tooltip:hover:before, .tooltip:hover:after{
 	visibility: visible;
 	opacity: 1;
 	word-break: break-word;
 }
 
 /** Directional arrow styles */
-[data-tooltip]:before, .tooltip-container:before {
+.tooltip:before, [data-tooltip]:before {
 	z-index: 10000;
 	border: 6px solid transparent;
 	background: transparent;
@@ -55,7 +54,7 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 }
 
 /** Content styles */
-[data-tooltip]:after, .tooltip {
+.tooltip:after, [data-tooltip]:after {
 	width: 260px;
 	z-index: 10000;
 	padding: 8px;
@@ -64,26 +63,24 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 	background-color: hsla(0, 0%, 20%, 0.9);
 	color: #fff;
 	content: attr(data-tooltip);
+	white-space: pre-wrap;
 	font-size: 14px;
 	line-height: 1.2;
 }
 
-[data-tooltip]:after {
-	white-space: pre-wrap;
-}
-
-[data-tooltip]:before, [data-tooltip]:after, .tooltip-container:before, .tooltip {
+[data-tooltip]:before, [data-tooltip]:after{
     visibility: hidden;
     opacity: 0;
     pointer-events: none;
 }
 
-[data-tooltip]:before, [data-tooltip]:after, .tooltip-container:before, .tooltip {
+[data-tooltip]:before, [data-tooltip]:after, .tooltip:before, .tooltip:after,
+.tooltip-top:before, .tooltip-top:after {
 	bottom: 100%;
 	left: 50%;
 }
 
-[data-tooltip]:before, .tooltip-container:before {
+[data-tooltip]:before, .tooltip:before, .tooltip-top:before {
 	margin-left: -6px;
 	margin-bottom: -12px;
 	border-top-color: #000;
@@ -91,19 +88,19 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 }
 
 /** Horizontally align tooltips on the top and bottom */
-[data-tooltip]:after, .tooltip {
+[data-tooltip]:after, .tooltip:after, .tooltip-top:after {
 	margin-left: -80px;
 }
 
-[data-tooltip]:hover:before, [data-tooltip]:hover:after, .tooltip-container:hover:before,
-.tooltip-container:hover .tooltip {
+[data-tooltip]:hover:before, [data-tooltip]:hover:after, .tooltip:hover:before, .tooltip:hover:after,
+.tooltip-top:hover:before, .tooltip-top:hover:after {
 	-webkit-transform: translateY(-12px);
 	-moz-transform:	translateY(-12px);
 	transform: translateY(-12px);
 }
 
 /** Tooltips on the left */
-.tooltip-left:before, [data-tooltip].tooltip-left:after, .tooltip-left .tooltip {
+.tooltip-left:before, .tooltip-left:after {
 	right: 100%;
 	bottom: 50%;
 	left: auto;
@@ -118,14 +115,14 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 	border-left-color: hsla(0, 0%, 20%, 0.9);
 }
 
-.tooltip-left:hover:before, [data-tooltip].tooltip-left:hover:after, .tooltip-left:hover .tooltip {
+.tooltip-left:hover:before, .tooltip-left:hover:after {
 	-webkit-transform: translateX(-12px);
 	-moz-transform:	translateX(-12px);
 	transform: translateX(-12px);
 }
 
 /** Tooltips on the bottom */
-.tooltip-bottom:before, [data-tooltip].tooltip-bottom:after, .tooltip-bottom .tooltip {
+.tooltip-bottom:before, .tooltip-bottom:after {
 	top: 100%;
 	bottom: auto;
 	left: 50%;
@@ -139,15 +136,14 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 	border-bottom-color: hsla(0, 0%, 20%, 0.9);
 }
 
-.tooltip-bottom:hover:before, [data-tooltip].tooltip-bottom:hover:after,
-.tooltip-bottom:hover .tooltip {
+.tooltip-bottom:hover:before, .tooltip-bottom:hover:after {
 	-webkit-transform: translateY(12px);
 	-moz-transform: translateY(12px);
 	transform: translateY(12px);
 }
 
 /** Tooltips on the right */
-.tooltip-right:before, [data-tooltip].tooltip-right:after, .tooltip-right .tooltip {
+.tooltip-right:before, .tooltip-right:after {
 	bottom: 50%;
 	left: 100%;
 }
@@ -160,8 +156,7 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 	border-right-color: hsla(0, 0%, 20%, 0.9);
 }
 
-.tooltip-right:hover:before, [data-tooltip].tooltip-right:hover:after,
-.tooltip-right:hover .tooltip {
+.tooltip-right:hover:before, .tooltip-right:hover:after {
 	-webkit-transform: translateX(12px);
 	-moz-transform:	translateX(12px);
 	transform: translateX(12px);
@@ -173,16 +168,7 @@ give it one of the following classes: tooltip-left, tooltip-right, tooltip-top,
 }
 
 /** Center content vertically for tooltips ont he left and right */
-[data-tooltip].tooltip-left:after, [data-tooltip].tooltip-right:after,
-.tooltip-left .tooltip, .tooltip-right .tooltip {
+.tooltip-left:after, .tooltip-right:after {
 	margin-left: 0;
 	margin-bottom: -16px;
 }
-
-.tooltip ul, .tooltip ol {
-	padding-left: 1rem;
-}
-
-.tooltip :last-child {
-	margin-bottom: 0;
-}

WebHostLib/templates/faq.html

@@ -0,0 +1,17 @@
+{% extends 'pageWrapper.html' %}
+
+{% block head %}
+    {% include 'header/grassHeader.html' %}
+    <title>Frequently Asked Questions</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/showdown/1.9.1/showdown.min.js"
+            integrity="sha512-L03kznCrNOfVxOUovR6ESfCz9Gfny7gihUX/huVbQB9zjODtYpxaVtIaAkpetoiyV2eqWbvxMH9fiSv5enX7bw=="
+            crossorigin="anonymous"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/faq.js") }}"></script>
+{% endblock %}
+
+{% block body %}
+    <div id="faq-wrapper" data-lang="{{ lang }}" class="markdown">
+        <!-- Content generated by JavaScript -->
+    </div>
+{%  endblock %}

WebHostLib/templates/genericTracker.html

@@ -99,18 +99,14 @@
                                 {% if hint.finding_player == player %}
                                     <b>{{ player_names_with_alias[(team, hint.finding_player)] }}</b>
                                 {% else %}
-                                    <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.finding_player) }}">
-                                        {{ player_names_with_alias[(team, hint.finding_player)] }}
-                                    </a>
+                                    {{ player_names_with_alias[(team, hint.finding_player)] }}
                                 {% endif %}
                             </td>
                             <td>
                                 {% if hint.receiving_player == player %}
                                     <b>{{ player_names_with_alias[(team, hint.receiving_player)] }}</b>
                                 {% else %}
-                                    <a href="{{ url_for("get_player_tracker", tracker=room.tracker, tracked_team=team, tracked_player=hint.receiving_player) }}">
-                                        {{ player_names_with_alias[(team, hint.receiving_player)] }}
-                                    </a>
+                                    {{ player_names_with_alias[(team, hint.receiving_player)] }}
                                 {% endif %}
                             </td>
                             <td>{{ item_id_to_name[games[(team, hint.receiving_player)]][hint.item] }}</td>

WebHostLib/templates/glossary.html

@@ -0,0 +1,17 @@
+{% extends 'pageWrapper.html' %}
+
+{% block head %}
+    {% include 'header/grassHeader.html' %}
+    <title>Glossary</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/showdown/1.9.1/showdown.min.js"
+            integrity="sha512-L03kznCrNOfVxOUovR6ESfCz9Gfny7gihUX/huVbQB9zjODtYpxaVtIaAkpetoiyV2eqWbvxMH9fiSv5enX7bw=="
+            crossorigin="anonymous"></script>
+    <script type="application/ecmascript" src="{{ url_for('static', filename="assets/glossary.js") }}"></script>
+{% endblock %}
+
+{% block body %}
+    <div id="glossary-wrapper" data-lang="{{ lang }}" class="markdown">
+        <!-- Content generated by JavaScript -->
+    </div>
+{%  endblock %}

WebHostLib/templates/hostRoom.html

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

WebHostLib/templates/macros.html

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

WebHostLib/templates/markdown_document.html

@@ -1,13 +0,0 @@
-{% extends 'pageWrapper.html' %}
-
-{% block head %}
-    {% include 'header/grassHeader.html' %}
-    <title>{{ title }}</title>
-    <link rel="stylesheet" type="text/css" href="{{ url_for('static', filename="styles/markdown.css") }}" />
-{% endblock %}
-
-{% block body %}
-    <div class="markdown">
-        {{ html_from_markdown | safe}}
-    </div>
-{%  endblock %}

WebHostLib/templates/multispheretracker.html

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

WebHostLib/templates/multitracker.html

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

WebHostLib/templates/ootTracker.html

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

WebHostLib/templates/playerOptions/macros.html

@@ -54,27 +54,27 @@
 {% macro NamedRange(option_name, option) %}
     {{ OptionTitle(option_name, option) }}
     <div class="named-range-container">
-        <select id="{{ option_name }}-select" name="{{ option_name }}" data-option-name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
+        <select id="{{ option_name }}-select" data-option-name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
             {% for key, val in option.special_range_names.items() %}
                 {% if option.default == val %}
-                    <option value="{{ val }}" selected>{{ key|replace("_", " ")|title }} ({{ val }})</option>
+                    <option value="{{ val }}" selected>{{ key }} ({{ val }})</option>
                 {% else %}
-                    <option value="{{ val }}">{{ key|replace("_", " ")|title }} ({{ val }})</option>
+                    <option value="{{ val }}">{{ key }} ({{ val }})</option>
                 {% endif %}
             {% endfor %}
             <option value="custom" hidden>Custom</option>
         </select>
-        <div class="named-range-wrapper js-required">
+        <div class="named-range-wrapper">
             <input
                     type="range"
                     id="{{ option_name }}"
-                    name="{{ option_name }}-range"
+                    name="{{ option_name }}"
                     min="{{ option.range_start }}"
                     max="{{ option.range_end }}"
                     value="{{ option.default | default(option.range_start) if option.default != "random" else option.range_start }}"
                     {{ "disabled" if option.default == "random" }}
             />
-            <span id="{{ option_name }}-value" class="range-value">
+            <span id="{{ option_name }}-value" class="range-value js-required">
                 {{ option.default | default(option.range_start) if option.default != "random" else option.range_start }}
             </span>
             {{ RandomizeButton(option_name, option) }}
@@ -111,7 +111,7 @@
     </div>
 {% endmacro %}
 
-{% macro ItemDict(option_name, option) %}
+{% macro ItemDict(option_name, option, world) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
         {% for item_name in (option.valid_keys|sort if (option.valid_keys|length > 0) else world.item_names|sort) %}
@@ -135,7 +135,7 @@
     </div>
 {% endmacro %}
 
-{% macro LocationSet(option_name, option) %}
+{% macro LocationSet(option_name, option, world) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
         {% for group_name in world.location_name_groups.keys()|sort %}
@@ -158,7 +158,7 @@
     </div>
 {% endmacro %}
 
-{% macro ItemSet(option_name, option) %}
+{% macro ItemSet(option_name, option, world) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
         {% for group_name in world.item_name_groups.keys()|sort %}
@@ -196,18 +196,7 @@
 {% macro OptionTitle(option_name, option) %}
     <label for="{{ option_name }}">
         {{ option.display_name|default(option_name) }}:
-        <span
-            class="interactive tooltip-container"
-            {% if not (option.rich_text_doc | default(world.web.rich_text_options_doc, true)) %}
-              data-tooltip="{{(option.__doc__ | default("Please document me!"))|replace('\n    ', '\n')|escape|trim}}"
-            {% endif %}>
-          (?)
-          {% if option.rich_text_doc | default(world.web.rich_text_options_doc, true) %}
-            <div class="tooltip">
-              {{ option.__doc__ | default("**Please document me!**") | rst_to_html | safe }}
-            </div>
-          {% endif %}
-        </span>
+        <span class="interactive" data-tooltip="{% filter dedent %}{{(option.__doc__ | default("Please document me!"))|escape }}{% endfilter %}">(?)</span>
     </label>
 {% endmacro %}
 

WebHostLib/templates/playerOptions/playerOptions.html

@@ -1,5 +1,5 @@
 {% extends 'pageWrapper.html' %}
-{% import 'playerOptions/macros.html' as inputs with context %}
+{% import 'playerOptions/macros.html' as inputs %}
 
 {% block head %}
     <title>{{ world_name }} Options</title>
@@ -11,7 +11,7 @@
     <noscript>
         <style>
             .js-required{
-                display: none !important;
+                display: none;
             }
         </style>
     </noscript>
@@ -94,16 +94,16 @@
                                             {{ inputs.FreeText(option_name, option) }}
 
                                         {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
-                                            {{ inputs.ItemDict(option_name, option) }}
+                                            {{ inputs.ItemDict(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}
 
                                         {% elif issubclass(option, Options.LocationSet) and option.verify_location_name %}
-                                            {{ inputs.LocationSet(option_name, option) }}
+                                            {{ inputs.LocationSet(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.ItemSet) and option.verify_item_name %}
-                                            {{ inputs.ItemSet(option_name, option) }}
+                                            {{ inputs.ItemSet(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.OptionSet) and option.valid_keys %}
                                             {{ inputs.OptionSet(option_name, option) }}
@@ -134,16 +134,16 @@
                                             {{ inputs.FreeText(option_name, option) }}
 
                                         {% elif issubclass(option, Options.ItemDict) and option.verify_item_name %}
-                                            {{ inputs.ItemDict(option_name, option) }}
+                                            {{ inputs.ItemDict(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.OptionList) and option.valid_keys %}
                                             {{ inputs.OptionList(option_name, option) }}
 
                                         {% elif issubclass(option, Options.LocationSet) and option.verify_location_name %}
-                                            {{ inputs.LocationSet(option_name, option) }}
+                                            {{ inputs.LocationSet(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.ItemSet) and option.verify_item_name %}
-                                            {{ inputs.ItemSet(option_name, option) }}
+                                            {{ inputs.ItemSet(option_name, option, world) }}
 
                                         {% elif issubclass(option, Options.OptionSet) and option.valid_keys %}
                                             {{ inputs.OptionSet(option_name, option) }}