Update docs/world maintainer.md

Co-authored-by: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com>

.gitattributes

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

.github/workflows/build.yml

@@ -36,10 +36,15 @@ 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"
@@ -49,12 +54,6 @@ jobs:
           Rename-Item "exe.$NAME" Archipelago
           7z a -mx=9 -mhe=on -ms "../dist/$ZIP_NAME" Archipelago
           Rename-Item Archipelago "exe.$NAME"  # inno_setup.iss expects the original name
-      - name: Store 7z
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ env.ZIP_NAME }}
-          path: dist/${{ env.ZIP_NAME }}
-          retention-days: 7  # keep for 7 days, should be enough
       - name: Build Setup
         run: |
           & "${env:ProgramFiles(x86)}\Inno Setup 6\iscc.exe" inno_setup.iss /DNO_SIGNTOOL
@@ -65,11 +64,38 @@ jobs:
           $contents = Get-ChildItem -Path setups/*.exe -Force -Recurse
           $SETUP_NAME=$contents[0].Name
           echo "SETUP_NAME=$SETUP_NAME" >> $Env:GITHUB_ENV
+      - name: Check build loads expected worlds
+        shell: bash
+        run: |
+          cd build/exe*
+          mv Players/Templates/meta.yaml .
+          ls -1 Players/Templates | sort > setup-player-templates.txt
+          rm -R Players/Templates
+          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
+          ls -1 Players/Templates | sort > generated-player-templates.txt
+          cmp setup-player-templates.txt generated-player-templates.txt \
+            || diff setup-player-templates.txt generated-player-templates.txt
+          mv meta.yaml Players/Templates/
+      - name: Test Generate
+        shell: bash
+        run: |
+          cd build/exe*
+          cp Players/Templates/Clique.yaml Players/
+          timeout 30 ./ArchipelagoGenerate
+      - name: Store 7z
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.ZIP_NAME }}
+          path: dist/${{ env.ZIP_NAME }}
+          compression-level: 0  # .7z is incompressible by zip
+          if-no-files-found: error
+          retention-days: 7  # keep for 7 days, should be enough
       - name: Store Setup
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.SETUP_NAME }}
           path: setups/${{ env.SETUP_NAME }}
+          if-no-files-found: error
           retention-days: 7  # keep for 7 days, should be enough
 
   build-ubuntu2004:
@@ -110,7 +136,7 @@ jobs:
           echo -e "setup.py dist output:\n `ls dist`"
           cd dist && export APPIMAGE_NAME="`ls *.AppImage`" && cd ..
           export TAR_NAME="${APPIMAGE_NAME%.AppImage}.tar.gz"
-          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -czvf ../dist/$TAR_NAME Archipelago && mv Archipelago "$DIR_NAME")
+          (cd build && DIR_NAME="`ls | grep exe`" && mv "$DIR_NAME" Archipelago && tar -cv Archipelago | gzip -8 > ../dist/$TAR_NAME && mv Archipelago "$DIR_NAME")
           echo "APPIMAGE_NAME=$APPIMAGE_NAME" >> $GITHUB_ENV
           echo "TAR_NAME=$TAR_NAME" >> $GITHUB_ENV
       # - copy code above to release.yml -
@@ -118,15 +144,36 @@ jobs:
         run: |
           source venv/bin/activate
           python setup.py build_exe --yes
+      - name: Check build loads expected worlds
+        shell: bash
+        run: |
+          cd build/exe*
+          mv Players/Templates/meta.yaml .
+          ls -1 Players/Templates | sort > setup-player-templates.txt
+          rm -R Players/Templates
+          timeout 30 ./ArchipelagoLauncher "Generate Template Options" || true
+          ls -1 Players/Templates | sort > generated-player-templates.txt
+          cmp setup-player-templates.txt generated-player-templates.txt \
+            || diff setup-player-templates.txt generated-player-templates.txt
+          mv meta.yaml Players/Templates/
+      - name: Test Generate
+        shell: bash
+        run: |
+          cd build/exe*
+          cp Players/Templates/Clique.yaml Players/
+          timeout 30 ./ArchipelagoGenerate
       - name: Store AppImage
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.APPIMAGE_NAME }}
           path: dist/${{ env.APPIMAGE_NAME }}
+          if-no-files-found: error
           retention-days: 7
       - name: Store .tar.gz
         uses: actions/upload-artifact@v4
         with:
           name: ${{ env.TAR_NAME }}
           path: dist/${{ env.TAR_NAME }}
+          compression-level: 0  # .gz is incompressible by zip
+          if-no-files-found: error
           retention-days: 7

.github/workflows/ctest.yml

@@ -0,0 +1,54 @@
+# Run CMake / CTest C++ unit tests
+
+name: ctest
+
+on:
+  push:
+    paths:
+      - '**.cc?'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.hh?'
+      - '**.hpp'
+      - '**.hxx'
+      - '**.CMakeLists'
+      - '.github/workflows/ctest.yml'
+  pull_request:
+    paths:
+      - '**.cc?'
+      - '**.cpp'
+      - '**.cxx'
+      - '**.hh?'
+      - '**.hpp'
+      - '**.hxx'
+      - '**.CMakeLists'
+      - '.github/workflows/ctest.yml'
+
+jobs:
+  ctest:
+    runs-on: ${{ matrix.os }}
+    name: Test C++ ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v4
+    - uses: ilammy/msvc-dev-cmd@v1
+      if: startsWith(matrix.os,'windows')
+    - uses: Bacondish2023/setup-googletest@v1
+      with:
+        build-type: 'Release'
+    - name: Build tests
+      run: |
+        cd test/cpp
+        mkdir build
+        cmake -S . -B build/ -DCMAKE_BUILD_TYPE=Release
+        cmake --build build/ --config Release
+        ls
+    - name: Run tests
+      run: |
+        cd test/cpp
+        ctest --test-dir build/ -C Release --output-on-failure

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

.github/workflows/unittests.yml

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

.gitignore

@@ -150,7 +150,7 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-.code-workspace
+*.code-workspace
 shell.nix
 
 # Spyder project settings
@@ -178,6 +178,7 @@ dmypy.json
 cython_debug/
 
 # Cython intermediates
+_speedups.c
 _speedups.cpp
 _speedups.html
 

AdventureClient.py

@@ -80,7 +80,7 @@ class AdventureContext(CommonContext):
         self.local_item_locations = {}
         self.dragon_speed_info = {}
 
-        options = Utils.get_options()
+        options = Utils.get_settings()
         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_options()["adventure_options"].get("death_link", False):
+            if Utils.get_settings()["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_slot(item.item) for item in args['items']])}"
+            msg = f"Received {', '.join([self.item_names.lookup_in_game(item.item) for item in args['items']])}"
             self._set_message(msg, SYSTEM_MESSAGE_ID)
         elif cmd == "Retrieved":
             if f"adventure_{self.auth}_freeincarnates_used" in args["keys"]:
@@ -415,8 +415,8 @@ async def atari_sync_task(ctx: AdventureContext):
 
 
 async def run_game(romfile):
-    auto_start = Utils.get_options()["adventure_options"].get("rom_start", True)
-    rom_args = Utils.get_options()["adventure_options"].get("rom_args")
+    auto_start = Utils.get_settings()["adventure_options"].get("rom_start", True)
+    rom_args = Utils.get_settings()["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 copy
+import collections
 import itertools
 import functools
 import logging
@@ -11,8 +11,10 @@ from argparse import Namespace
 from collections import Counter, deque
 from collections.abc import Collection, MutableSequence
 from enum import IntEnum, IntFlag
-from typing import Any, Callable, Dict, Iterable, Iterator, List, Mapping, NamedTuple, Optional, Set, Tuple, \
-                   TypedDict, Union, Type, ClassVar
+from typing import (AbstractSet, Any, Callable, ClassVar, Dict, Iterable, Iterator, List, Mapping, NamedTuple,
+                    Optional, Protocol, Set, Tuple, Union, Type)
+
+from typing_extensions import NotRequired, TypedDict
 
 import NetUtils
 import Options
@@ -22,16 +24,16 @@ if typing.TYPE_CHECKING:
     from worlds import AutoWorld
 
 
-class Group(TypedDict, total=False):
+class Group(TypedDict):
     name: str
     game: str
     world: "AutoWorld.World"
-    players: Set[int]
-    item_pool: Set[str]
-    replacement_items: Dict[int, Optional[str]]
-    local_items: Set[str]
-    non_local_items: Set[str]
-    link_replacement: bool
+    players: AbstractSet[int]
+    item_pool: NotRequired[Set[str]]
+    replacement_items: NotRequired[Dict[int, Optional[str]]]
+    local_items: NotRequired[Set[str]]
+    non_local_items: NotRequired[Set[str]]
+    link_replacement: NotRequired[bool]
 
 
 class ThreadBarrierProxy:
@@ -48,6 +50,11 @@ class ThreadBarrierProxy:
                                "Please use multiworld.per_slot_randoms[player] or randomize ahead of output.")
 
 
+class HasNameAndPlayer(Protocol):
+    name: str
+    player: int
+
+
 class MultiWorld():
     debug_types = False
     player_name: Dict[int, str]
@@ -63,7 +70,6 @@ class MultiWorld():
     state: CollectionState
 
     plando_options: PlandoOptions
-    accessibility: Dict[int, Options.Accessibility]
     early_items: Dict[int, Dict[str, int]]
     local_early_items: Dict[int, Dict[str, int]]
     local_items: Dict[int, Options.LocalItems]
@@ -157,7 +163,7 @@ class MultiWorld():
         self.start_inventory_from_pool: Dict[int, Options.StartInventoryPool] = {}
 
         for player in range(1, players + 1):
-            def set_player_attr(attr, val):
+            def set_player_attr(attr: str, val) -> None:
                 self.__dict__.setdefault(attr, {})[player] = val
             set_player_attr('plando_items', [])
             set_player_attr('plando_texts', {})
@@ -166,13 +172,13 @@ class MultiWorld():
             set_player_attr('completion_condition', lambda state: True)
         self.worlds = {}
         self.per_slot_randoms = Utils.DeprecateDict("Using per_slot_randoms is now deprecated. Please use the "
-                                                      "world's random object instead (usually self.random)")
+                                                    "world's random object instead (usually self.random)")
         self.plando_options = PlandoOptions.none
 
     def get_all_ids(self) -> Tuple[int, ...]:
         return self.player_ids + tuple(self.groups)
 
-    def add_group(self, name: str, game: str, players: Set[int] = frozenset()) -> Tuple[int, Group]:
+    def add_group(self, name: str, game: str, players: AbstractSet[int] = frozenset()) -> Tuple[int, Group]:
         """Create a group with name and return the assigned player ID and group.
         If a group of this name already exists, the set of players is extended instead of creating a new one."""
         from worlds import AutoWorld
@@ -196,7 +202,7 @@ class MultiWorld():
 
         return new_id, new_group
 
-    def get_player_groups(self, player) -> Set[int]:
+    def get_player_groups(self, player: int) -> Set[int]:
         return {group_id for group_id, group in self.groups.items() if player in group["players"]}
 
     def set_seed(self, seed: Optional[int] = None, secure: bool = False, name: Optional[str] = None):
@@ -259,7 +265,7 @@ class MultiWorld():
                         "link_replacement": replacement_prio.index(item_link["link_replacement"]),
                     }
 
-        for name, item_link in item_links.items():
+        for _name, item_link in item_links.items():
             current_item_name_groups = AutoWorld.AutoWorldRegister.world_types[item_link["game"]].item_name_groups
             pool = set()
             local_items = set()
@@ -288,6 +294,86 @@ 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
+            for item in self.itempool:
+                count = common_item_count.get(item.player, {}).get(item.name, 0)
+                if count:
+                    loc = Location(group_id, f"Item Link: {item.name} -> {self.player_name[item.player]} {count}",
+                        None, region)
+                    loc.access_rule = lambda state, item_name = item.name, group_id_ = group_id, count_ = count: \
+                        state.has(item_name, group_id_, count_)
+
+                    locations.append(loc)
+                    loc.place_locked_item(item)
+                    common_item_count[item.player][item.name] -= 1
+                else:
+                    new_itempool.append(item)
+
+            itemcount = len(self.itempool)
+            self.itempool = new_itempool
+
+            while itemcount > len(self.itempool):
+                items_to_add = []
+                for player in group["players"]:
+                    if group["link_replacement"]:
+                        item_player = group_id
+                    else:
+                        item_player = player
+                    if group["replacement_items"][player]:
+                        items_to_add.append(AutoWorld.call_single(self, "create_item", item_player,
+                            group["replacement_items"][player]))
+                    else:
+                        items_to_add.append(AutoWorld.call_single(self, "create_filler", item_player))
+                self.random.shuffle(items_to_add)
+                self.itempool.extend(items_to_add[:itemcount - len(self.itempool)])
+
     def secure(self):
         self.random = ThreadBarrierProxy(secrets.SystemRandom())
         self.is_race = True
@@ -309,7 +395,7 @@ class MultiWorld():
         return tuple(world for player, world in self.worlds.items() if
                      player not in self.groups and self.game[player] == game_name)
 
-    def get_name_string_for_object(self, obj) -> str:
+    def get_name_string_for_object(self, obj: HasNameAndPlayer) -> str:
         return obj.name if self.players == 1 else f'{obj.name} ({self.get_player_name(obj.player)})'
 
     def get_player_name(self, player: int) -> str:
@@ -351,7 +437,7 @@ class MultiWorld():
             subworld = self.worlds[player]
             for item in subworld.get_pre_fill_items():
                 subworld.collect(ret, item)
-        ret.sweep_for_events()
+        ret.sweep_for_advancements()
 
         if use_cache:
             self._all_state = ret
@@ -360,7 +446,7 @@ class MultiWorld():
     def get_items(self) -> List[Item]:
         return [loc.item for loc in self.get_filled_locations()] + self.itempool
 
-    def find_item_locations(self, item, player: int, resolve_group_locations: bool = False) -> List[Location]:
+    def find_item_locations(self, item: str, player: int, resolve_group_locations: bool = False) -> List[Location]:
         if resolve_group_locations:
             player_groups = self.get_player_groups(player)
             return [location for location in self.get_locations() if
@@ -369,7 +455,7 @@ class MultiWorld():
         return [location for location in self.get_locations() if
                 location.item and location.item.name == item and location.item.player == player]
 
-    def find_item(self, item, player: int) -> Location:
+    def find_item(self, item: str, player: int) -> Location:
         return next(location for location in self.get_locations() if
                     location.item and location.item.name == item and location.item.player == player)
 
@@ -462,9 +548,9 @@ class MultiWorld():
                 return True
             state = starting_state.copy()
         else:
-            if self.has_beaten_game(self.state):
-                return True
             state = CollectionState(self)
+            if self.has_beaten_game(state):
+                return True
         prog_locations = {location for location in self.get_locations() if location.item
                           and location.item.advancement and location not in state.locations_checked}
 
@@ -523,26 +609,21 @@ class MultiWorld():
         players: Dict[str, Set[int]] = {
             "minimal": set(),
             "items": set(),
-            "locations": set()
+            "full": set()
         }
-        for player, access in self.accessibility.items():
-            players[access.current_key].add(player)
+        for player, world in self.worlds.items():
+            players[world.options.accessibility.current_key].add(player)
 
         beatable_fulfilled = False
 
-        def location_condition(location: Location):
+        def location_condition(location: Location) -> bool:
             """Determine if this location has to be accessible, location is already filtered by location_relevant"""
-            if location.player in players["locations"] or (location.item and location.item.player not in
-                                                           players["minimal"]):
-                return True
-            return False
+            return location.player in players["full"] or \
+                (location.item and location.item.player not in players["minimal"])
 
-        def location_relevant(location: Location):
+        def location_relevant(location: Location) -> bool:
             """Determine if this location is relevant to sweep."""
-            if location.progress_type != LocationProgressType.EXCLUDED \
-               and (location.player in players["locations"] or location.advancement):
-                return True
-            return False
+            return location.player in players["full"] or location.advancement
 
         def all_done() -> bool:
             """Check if all access rules are fulfilled"""
@@ -587,7 +668,7 @@ class CollectionState():
     multiworld: MultiWorld
     reachable_regions: Dict[int, Set[Region]]
     blocked_connections: Dict[int, Set[Entrance]]
-    events: Set[Location]
+    advancements: Set[Location]
     path: Dict[Union[Region, Entrance], PathValue]
     locations_checked: Set[Location]
     stale: Dict[int, bool]
@@ -599,7 +680,7 @@ class CollectionState():
         self.multiworld = parent
         self.reachable_regions = {player: set() for player in parent.get_all_ids()}
         self.blocked_connections = {player: set() for player in parent.get_all_ids()}
-        self.events = set()
+        self.advancements = set()
         self.path = {}
         self.locations_checked = set()
         self.stale = {player: True for player in parent.get_all_ids()}
@@ -643,14 +724,14 @@ class CollectionState():
 
     def copy(self) -> CollectionState:
         ret = CollectionState(self.multiworld)
-        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)
+        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()
         for function in self.additional_copy_functions:
             ret = function(self, ret)
         return ret
@@ -680,20 +761,25 @@ class CollectionState():
     def can_reach_region(self, spot: str, player: int) -> bool:
         return self.multiworld.get_region(spot, player).can_reach(self)
 
-    def sweep_for_events(self, key_only: bool = False, locations: Optional[Iterable[Location]] = None) -> None:
+    def sweep_for_events(self, locations: Optional[Iterable[Location]] = None) -> None:
+        Utils.deprecate("sweep_for_events has been renamed to sweep_for_advancements. The functionality is the same. "
+                        "Please switch over to sweep_for_advancements.")
+        return self.sweep_for_advancements(locations)
+
+    def sweep_for_advancements(self, locations: Optional[Iterable[Location]] = None) -> None:
         if locations is None:
             locations = self.multiworld.get_filled_locations()
-        reachable_events = True
-        # 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)
+        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)
 
     # item name related
     def has(self, item: str, player: int, count: int = 1) -> bool:
@@ -727,7 +813,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."""
@@ -742,7 +828,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)
@@ -788,20 +874,16 @@ class CollectionState():
         )
 
     # Item related
-    def collect(self, item: Item, event: bool = False, location: Optional[Location] = None) -> bool:
+    def collect(self, item: Item, prevent_sweep: bool = False, location: Optional[Location] = None) -> bool:
         if location:
             self.locations_checked.add(location)
 
         changed = self.multiworld.worlds[item.player].collect(self, item)
 
-        if not changed and event:
-            self.prog_items[item.player][item.name] += 1
-            changed = True
-
         self.stale[item.player] = True
 
-        if changed and not event:
-            self.sweep_for_events()
+        if changed and not prevent_sweep:
+            self.sweep_for_advancements()
 
         return changed
 
@@ -825,7 +907,7 @@ class Entrance:
     addresses = None
     target = None
 
-    def __init__(self, player: int, name: str = '', parent: Region = None):
+    def __init__(self, player: int, name: str = "", parent: Optional[Region] = None) -> None:
         self.name = name
         self.parent_region = parent
         self.player = player
@@ -845,9 +927,6 @@ class Entrance:
         region.entrances.append(self)
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         multiworld = self.parent_region.multiworld if self.parent_region else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
@@ -973,7 +1052,7 @@ class Region:
             self.locations.append(location_type(self.player, location, address, self))
 
     def connect(self, connecting_region: Region, name: Optional[str] = None,
-                rule: Optional[Callable[[CollectionState], bool]] = None) -> entrance_type:
+                rule: Optional[Callable[[CollectionState], bool]] = None) -> Entrance:
         """
         Connects this Region to another Region, placing the provided rule on the connection.
 
@@ -1013,9 +1092,6 @@ class Region:
                          rules[connecting_region] if rules and connecting_region in rules else None)
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         return self.multiworld.get_name_string_for_object(self) if self.multiworld else f'{self.name} (Player {self.player})'
 
 
@@ -1034,9 +1110,9 @@ class Location:
     locked: bool = False
     show_in_spoiler: bool = True
     progress_type: LocationProgressType = LocationProgressType.DEFAULT
-    always_allow = staticmethod(lambda state, item: False)
+    always_allow: Callable[[CollectionState, Item], bool] = staticmethod(lambda state, item: False)
     access_rule: Callable[[CollectionState], bool] = staticmethod(lambda state: True)
-    item_rule = staticmethod(lambda item: True)
+    item_rule: Callable[[Item], bool] = staticmethod(lambda item: True)
     item: Optional[Item] = None
 
     def __init__(self, player: int, name: str = '', address: Optional[int] = None, parent: Optional[Region] = None):
@@ -1045,16 +1121,20 @@ class Location:
         self.address = address
         self.parent_region = parent
 
-    def can_fill(self, state: CollectionState, item: Item, check_access=True) -> bool:
-        return ((self.always_allow(state, item) and item.name not in state.multiworld.worlds[item.player].options.non_local_items)
-                or ((self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
-                    and self.item_rule(item)
-                    and (not check_access or self.can_reach(state))))
+    def can_fill(self, state: CollectionState, item: Item, check_access: bool = True) -> bool:
+        return ((
+            self.always_allow(state, item)
+            and item.name not in state.multiworld.worlds[item.player].options.non_local_items
+        ) or (
+            (self.progress_type != LocationProgressType.EXCLUDED or not (item.advancement or item.useful))
+            and self.item_rule(item)
+            and (not check_access or self.can_reach(state))
+        ))
 
     def can_reach(self, state: CollectionState) -> bool:
-        # self.access_rule computes faster on average, so placing it first for faster abort
+        # Region.can_reach is just a cache lookup, so placing it first for faster abort on average
         assert self.parent_region, "Can't reach location without region"
-        return self.access_rule(state) and self.parent_region.can_reach(state)
+        return self.parent_region.can_reach(state) and self.access_rule(state)
 
     def place_locked_item(self, item: Item):
         if self.item:
@@ -1064,9 +1144,6 @@ class Location:
         self.locked = True
 
     def __repr__(self):
-        return self.__str__()
-
-    def __str__(self):
         multiworld = self.parent_region.multiworld if self.parent_region and self.parent_region.multiworld else None
         return multiworld.get_name_string_for_object(self) if multiworld else f'{self.name} (Player {self.player})'
 
@@ -1088,7 +1165,7 @@ class Location:
     @property
     def native_item(self) -> bool:
         """Returns True if the item in this location matches game."""
-        return self.item and self.item.game == self.game
+        return self.item is not None and self.item.game == self.game
 
     @property
     def hint_text(self) -> str:
@@ -1171,9 +1248,6 @@ class Item:
         return hash((self.name, self.player))
 
     def __repr__(self) -> str:
-        return self.__str__()
-
-    def __str__(self) -> str:
         if self.location and self.location.parent_region and self.location.parent_region.multiworld:
             return self.location.parent_region.multiworld.get_name_string_for_object(self)
         return f"{self.name} (Player {self.player})"
@@ -1251,9 +1325,9 @@ class Spoiler:
 
         # in the second phase, we cull each sphere such that the game is still beatable,
         # reducing each range of influence to the bare minimum required inside it
-        restore_later = {}
+        restore_later: Dict[Location, Item] = {}
         for num, sphere in reversed(tuple(enumerate(collection_spheres))):
-            to_delete = set()
+            to_delete: Set[Location] = set()
             for location in sphere:
                 # we remove the item at location and check if game is still beatable
                 logging.debug('Checking if %s (Player %d) is required to beat the game.', location.item.name,
@@ -1271,7 +1345,7 @@ class Spoiler:
             sphere -= to_delete
 
         # second phase, sphere 0
-        removed_precollected = []
+        removed_precollected: List[Item] = []
         for item in (i for i in chain.from_iterable(multiworld.precollected_items.values()) if i.advancement):
             logging.debug('Checking if %s (Player %d) is required to beat the game.', item.name, item.player)
             multiworld.precollected_items[item.player].remove(item)
@@ -1291,8 +1365,6 @@ class Spoiler:
         state = CollectionState(multiworld)
         collection_spheres = []
         while required_locations:
-            state.sweep_for_events(key_only=True)
-
             sphere = set(filter(state.can_reach, required_locations))
 
             for location in sphere:
@@ -1354,7 +1426,7 @@ class Spoiler:
                 # Maybe move the big bomb over to the Event system instead?
                 if any(exit_path == 'Pyramid Fairy' for path in self.paths.values()
                        for (_, exit_path) in path):
-                    if multiworld.mode[player] != 'inverted':
+                    if multiworld.worlds[player].options.mode != 'inverted':
                         self.paths[str(multiworld.get_region('Big Bomb Shop', player))] = \
                             get_path(state, multiworld.get_region('Big Bomb Shop', player))
                     else:
@@ -1426,9 +1498,9 @@ class Spoiler:
 
             if self.paths:
                 outfile.write('\n\nPaths:\n\n')
-                path_listings = []
+                path_listings: List[str] = []
                 for location, path in sorted(self.paths.items()):
-                    path_lines = []
+                    path_lines: List[str] = []
                     for region, exit in path:
                         if exit is not None:
                             path_lines.append("{} -> {}".format(region, exit))

CommonClient.py

@@ -23,7 +23,7 @@ if __name__ == "__main__":
 
 from MultiServer import CommandProcessor
 from NetUtils import (Endpoint, decode, NetworkItem, encode, JSONtoTextParser, ClientStatus, Permission, NetworkSlot,
-                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes)
+                      RawJSONtoTextParser, add_json_text, add_json_location, add_json_item, JSONTypes, SlotType)
 from Utils import Version, stream_input, async_start
 from worlds import network_data_package, AutoWorldRegister
 import os
@@ -61,6 +61,7 @@ class ClientCommandProcessor(CommandProcessor):
         if address:
             self.ctx.server_address = None
             self.ctx.username = None
+            self.ctx.password = None
         elif not self.ctx.server_address:
             self.output("Please specify an address.")
             return False
@@ -225,6 +226,9 @@ class CommonContext:
         def lookup_in_slot(self, code: int, slot: typing.Optional[int] = None) -> str:
             """Returns the name for an item/location id in the context of a specific slot or own slot if `slot` is
             omitted.
+
+            Use of `lookup_in_slot` should not be used when not connected to a server. If looking in own game, set
+            `ctx.game` and use `lookup_in_game` method instead.
             """
             if slot is None:
                 slot = self.ctx.slot
@@ -248,7 +252,7 @@ class CommonContext:
     starting_reconnect_delay: int = 5
     current_reconnect_delay: int = starting_reconnect_delay
     command_processor: typing.Type[CommandProcessor] = ClientCommandProcessor
-    ui = None
+    ui: typing.Optional["kvui.GameManager"] = None
     ui_task: typing.Optional["asyncio.Task[None]"] = None
     input_task: typing.Optional["asyncio.Task[None]"] = None
     keep_alive_task: typing.Optional["asyncio.Task[None]"] = None
@@ -493,6 +497,11 @@ class CommonContext:
         """Gets called before sending a Say to the server from the user.
         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]):
         for permission_name, permission_flag in permissions.items():
@@ -506,6 +515,7 @@ class CommonContext:
     async def shutdown(self):
         self.server_address = ""
         self.username = None
+        self.password = None
         self.cancel_autoreconnect()
         if self.server and not self.server.socket.closed:
             await self.server.socket.close()
@@ -854,7 +864,8 @@ async def process_server_cmd(ctx: CommonContext, args: dict):
         ctx.team = args["team"]
         ctx.slot = args["slot"]
         # int keys get lost in JSON transfer
-        ctx.slot_info = {int(pid): data for pid, data in args["slot_info"].items()}
+        ctx.slot_info = {0: NetworkSlot("Archipelago", "Archipelago", SlotType.player)}
+        ctx.slot_info.update({int(pid): data for pid, data in args["slot_info"].items()})
         ctx.hint_points = args.get("hint_points", 0)
         ctx.consume_players_package(args["players"])
         ctx.stored_data_notification_keys.add(f"_read_hints_{ctx.team}_{ctx.slot}")

Fill.py

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

Generate.py

@@ -1,10 +1,12 @@
 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
@@ -15,21 +17,16 @@ 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.AutoWorld import AutoWorldRegister
-from worlds import failed_world_loads
 
 
 def mystery_argparse():
-    options = get_settings()
-    defaults = options.generator
+    from settings import get_settings
+    settings = get_settings()
+    defaults = settings.generator
 
     parser = argparse.ArgumentParser(description="CMD Generation Interface, defaults come from host.yaml.")
     parser.add_argument('--weights_file_path', default=defaults.weights_file_path,
@@ -41,7 +38,7 @@ 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=options.general_options.output_path,
+    parser.add_argument('--outputpath', default=settings.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)
@@ -61,20 +58,23 @@ 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, options
+    return args
 
 
 def get_seed_name(random_source) -> str:
     return f"{random_source.randint(0, pow(10, seeddigits) - 1)}".zfill(seeddigits)
 
 
-def main(args=None, callback=ERmain):
+def main(args=None) -> Tuple[argparse.Namespace, int]:
+    # __name__ == "__main__" check so unittests that already imported worlds don't trip this.
+    if __name__ == "__main__" and "worlds" in sys.modules:
+        raise Exception("Worlds system should not be loaded before logging init.")
+
     if not args:
-        args, options = mystery_argparse()
-    else:
-        options = get_settings()
+        args = mystery_argparse()
 
     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,6 +143,9 @@ def main(args=None, callback=ERmain):
         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
@@ -234,7 +237,7 @@ def main(args=None, callback=ERmain):
         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)
+    return erargs, seed
 
 
 def read_weights_yamls(path) -> Tuple[Any, ...]:
@@ -359,6 +362,8 @@ 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:
@@ -436,10 +441,13 @@ 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)
 
@@ -466,6 +474,7 @@ 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}. "
@@ -502,7 +511,7 @@ def roll_settings(weights: dict, plando_options: PlandoOptions = PlandoOptions.b
             continue
         logging.warning(f"{option_key} is not a valid option name for {ret.game} and is not present in triggers.")
     if PlandoOptions.items in plando_options:
-        ret.plando_items = game_weights.get("plando_items", [])
+        ret.plando_items = copy.deepcopy(game_weights.get("plando_items", []))
     if ret.game == "A Link to the Past":
         roll_alttp_settings(ret, game_weights)
 
@@ -537,7 +546,9 @@ def roll_alttp_settings(ret: argparse.Namespace, weights):
 if __name__ == '__main__':
     import atexit
     confirmation = atexit.register(input, "Press enter to close.")
-    multiworld = main()
+    erargs, seed = main()
+    from Main import main as ERmain
+    multiworld = ERmain(erargs, seed)
     if __debug__:
         import gc
         import sys

KH1Client.py

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

Launcher.py

@@ -266,7 +266,7 @@ def run_gui():
             if file and component:
                 run_component(component, file)
             else:
-                logging.warning(f"unable to identify component for {filename}")
+                logging.warning(f"unable to identify component for {file}")
 
         def _stop(self, *largs):
             # ran into what appears to be https://groups.google.com/g/kivy-users/c/saWDLoYCSZ4 with PyCharm.

LttPAdjuster.py

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

Main.py

@@ -11,7 +11,8 @@ from typing import Dict, List, Optional, Set, Tuple, Union
 
 import worlds
 from BaseClasses import CollectionState, Item, Location, LocationProgressType, MultiWorld, Region
-from Fill import balance_multiworld_progression, distribute_items_restrictive, distribute_planned, flood_items
+from Fill import FillError, balance_multiworld_progression, distribute_items_restrictive, distribute_planned, \
+    flood_items
 from Options import StartInventoryPool
 from Utils import __version__, output_path, version_tuple, get_settings
 from settings import get_settings
@@ -100,7 +101,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
                 multiworld.early_items[player][item_name] = max(0, early-count)
                 remaining_count = count-early
                 if remaining_count > 0:
-                    local_early = multiworld.early_local_items[player].get(item_name, 0)
+                    local_early = multiworld.local_early_items[player].get(item_name, 0)
                     if local_early:
                         multiworld.early_items[player][item_name] = max(0, local_early - remaining_count)
                     del local_early
@@ -124,14 +125,19 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
     for player in multiworld.player_ids:
         exclusion_rules(multiworld, player, multiworld.worlds[player].options.exclude_locations.value)
         multiworld.worlds[player].options.priority_locations.value -= multiworld.worlds[player].options.exclude_locations.value
+        world_excluded_locations = set()
         for location_name in multiworld.worlds[player].options.priority_locations.value:
             try:
                 location = multiworld.get_location(location_name, player)
-            except KeyError as e:  # failed to find the given location. Check if it's a legitimate location
-                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:
+            except KeyError:
+                continue
+
+            if location.progress_type != LocationProgressType.EXCLUDED:
                 location.progress_type = LocationProgressType.PRIORITY
+            else:
+                logger.warning(f"Unable to prioritize location \"{location_name}\" in player {player}'s world because the world excluded it.")
+                world_excluded_locations.add(location_name)
+        multiworld.worlds[player].options.priority_locations.value -= world_excluded_locations
 
     # Set local and non-local item rules.
     if multiworld.players > 1:
@@ -146,6 +152,7 @@ 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",
@@ -164,97 +171,26 @@ 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:
-                    new_items.extend(multiworld.itempool[i+1:])
+                    old_items.extend(multiworld.itempool[i+1:])
                     break
             else:
-                new_items.append(item)
+                old_items.append(item)
 
         # leftovers?
         if target:
             for player, remaining_items in depletion_pool.items():
                 remaining_items = {name: count for name, count in remaining_items.items() if count}
                 if remaining_items:
-                    raise Exception(f"{multiworld.get_player_name(player)}"
+                    logger.warning(f"{multiworld.get_player_name(player)}"
                                     f" is trying to remove items from their pool that don't exist: {remaining_items}")
-        assert len(multiworld.itempool) == len(new_items), "Item Pool amounts should not change."
-        multiworld.itempool[:] = new_items
+                    # 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
 
-    # 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)])
+    multiworld.link_items()
 
     if any(multiworld.item_links.values()):
         multiworld._all_state = None
@@ -411,7 +347,7 @@ def main(args, seed=None, baked_server_options: Optional[Dict[str, object]] = No
             output_file_futures.append(pool.submit(write_multidata))
             if not check_accessibility_task.result():
                 if not multiworld.can_beat_game():
-                    raise Exception("Game appears as unbeatable. Aborting.")
+                    raise FillError("Game appears as unbeatable. Aborting.", multiworld=multiworld)
                 else:
                     logger.warning("Location Accessibility requirements not fulfilled.")
 

ModuleUpdate.py

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

MultiServer.py

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

NetUtils.py

@@ -79,6 +79,7 @@ class NetworkItem(typing.NamedTuple):
     item: int
     location: int
     player: int
+    """ Sending player, except in LocationInfo (from LocationScouts), where it is the receiving player. """
     flags: int = 0
 
 
@@ -198,7 +199,8 @@ class JSONtoTextParser(metaclass=HandlerMeta):
         "slateblue": "6D8BE8",
         "plum": "AF99EF",
         "salmon": "FA8072",
-        "white": "FFFFFF"
+        "white": "FFFFFF",
+        "orange": "FF7700",
     }
 
     def __init__(self, ctx):
@@ -396,12 +398,12 @@ class _LocationStore(dict, typing.MutableMapping[int, typing.Dict[int, typing.Tu
                 location_id not in checked]
 
     def get_remaining(self, state: typing.Dict[typing.Tuple[int, int], typing.Set[int]], team: int, slot: int
-                      ) -> typing.List[int]:
+                      ) -> typing.List[typing.Tuple[int, int]]:
         checked = state[team, slot]
         player_locations = self[slot]
-        return sorted([player_locations[location_id][0] for
-                       location_id in player_locations if
-                       location_id not in checked])
+        return sorted([(player_locations[location_id][1], player_locations[location_id][0]) for
+                        location_id in player_locations if
+                        location_id not in checked])
 
 
 if typing.TYPE_CHECKING:  # type-check with pure python implementation until we have a typing stub

Options.py

@@ -53,8 +53,8 @@ class AssembleOptions(abc.ABCMeta):
         attrs["name_lookup"].update({option_id: name for name, option_id in new_options.items()})
         options.update(new_options)
         # apply aliases, without name_lookup
-        aliases = {name[6:].lower(): option_id for name, option_id in attrs.items() if
-                   name.startswith("alias_")}
+        aliases = attrs["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
@@ -126,10 +126,28 @@ class Option(typing.Generic[T], metaclass=AssembleOptions):
     # can be weighted between selections
     supports_weighting = True
 
+    rich_text_doc: typing.Optional[bool] = None
+    """Whether the WebHost should render the Option's docstring as rich text.
+
+    If this is True, the Option's docstring is interpreted as reStructuredText_,
+    the standard Python markup format. In the WebHost, it's rendered to HTML so
+    that lists, emphasis, and other rich text features are displayed properly.
+
+    If this is False, the docstring is instead interpreted as plain text, and
+    displayed as-is on the WebHost with whitespace preserved.
+
+    If this is None, it inherits the value of `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})"
@@ -735,6 +753,12 @@ class NamedRange(Range):
         elif value > self.range_end and value not in self.special_range_names.values():
             raise Exception(f"{value} is higher than maximum {self.range_end} for option {self.__class__.__name__} " +
                             f"and is also not one of the supported named special values: {self.special_range_names}")
+        
+        # See docstring
+        for key in self.special_range_names:
+            if key != key.lower():
+                raise Exception(f"{self.__class__.__name__} has an invalid special_range_names key: {key}. "
+                                f"NamedRange keys must use only lowercase letters, and ideally should be snake_case.")
         self.value = value
 
     @classmethod
@@ -762,17 +786,22 @@ class VerifyKeys(metaclass=FreezeValidKeys):
     verify_location_name: bool = False
     value: typing.Any
 
-    @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
+    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
             if extra:
-                raise Exception(f"Found unexpected key {', '.join(extra)} in {cls}. "
-                                f"Allowed keys: {cls._valid_keys}.")
+                raise OptionError(
+                    f"Found unexpected key {', '.join(extra)} in {getattr(self, 'display_name', self)}. "
+                    f"Allowed keys: {self._valid_keys}."
+                )
 
     def verify(self, world: typing.Type[World], player_name: str, plando_options: "PlandoOptions") -> None:
+        try:
+            self.verify_keys()
+        except OptionError as validation_error:
+            raise OptionError(f"Player {player_name} has invalid option keys:\n{validation_error}")
         if self.convert_name_groups and self.verify_item_name:
             new_value = type(self.value)()  # empty container of whatever value is
             for item_name in self.value:
@@ -809,7 +838,6 @@ class OptionDict(Option[typing.Dict[str, typing.Any]], VerifyKeys, typing.Mappin
     @classmethod
     def from_any(cls, data: typing.Dict[str, typing.Any]) -> OptionDict:
         if type(data) == dict:
-            cls.verify_keys(data)
             return cls(data)
         else:
             raise NotImplementedError(f"Cannot Convert from non-dictionary, got {type(data)}")
@@ -855,7 +883,6 @@ class OptionList(Option[typing.List[typing.Any]], VerifyKeys):
     @classmethod
     def from_any(cls, data: typing.Any):
         if is_iterable_except_str(data):
-            cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
 
@@ -881,7 +908,6 @@ class OptionSet(Option[typing.Set[str]], VerifyKeys):
     @classmethod
     def from_any(cls, data: typing.Any):
         if is_iterable_except_str(data):
-            cls.verify_keys(data)
             return cls(data)
         return cls.from_text(str(data))
 
@@ -924,6 +950,19 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
             self.value = []
             logging.warning(f"The plando texts module is turned off, "
                             f"so text for {player_name} will be ignored.")
+        else:
+            super().verify(world, player_name, plando_options)
+
+    def verify_keys(self) -> None:
+        if self.valid_keys:
+            data = set(text.at for text in self)
+            dataset = set(word.casefold() for word in data) if self.valid_keys_casefold else set(data)
+            extra = dataset - self._valid_keys
+            if extra:
+                raise OptionError(
+                    f"Invalid \"at\" placement {', '.join(extra)} in {getattr(self, 'display_name', self)}. "
+                    f"Allowed placements: {self._valid_keys}."
+                )
 
     @classmethod
     def from_any(cls, data: PlandoTextsFromAnyType) -> Self:
@@ -947,7 +986,6 @@ class PlandoTexts(Option[typing.List[PlandoText]], VerifyKeys):
                         texts.append(text)
                 else:
                     raise Exception(f"Cannot create plando text from non-dictionary type, got {type(text)}")
-            cls.verify_keys([text.at for text in texts])
             return cls(texts)
         else:
             raise NotImplementedError(f"Cannot Convert from non-list, got {type(data)}")
@@ -1120,27 +1158,48 @@ class PlandoConnections(Option[typing.List[PlandoConnection]], metaclass=Connect
 
 
 class Accessibility(Choice):
-    """Set rules for reachability of your items/locations.
-    Locations: ensure everything can be reached and acquired.
-    Items: ensure all logically relevant items can be acquired.
-    Minimal: ensure what is needed to reach your goal can be acquired."""
+    """
+    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.
+    """
     display_name = "Accessibility"
-    option_locations = 0
-    option_items = 1
+    rich_text_doc = True
+    option_full = 0
     option_minimal = 2
     alias_none = 2
+    alias_locations = 0
+    alias_items = 0
+    default = 0
+
+
+class ItemsAccessibility(Accessibility):
+    """
+    Set rules for reachability of your items/locations.
+    
+    **Full:** ensure everything can be reached and acquired.
+
+    **Minimal:** ensure what is needed to reach your goal can be acquired.
+
+    **Items:** ensure all logically relevant items can be acquired. Some items, such as keys, may be self-locking, and
+    some locations may be inaccessible.
+    """
+    option_items = 1
     default = 1
 
 
 class ProgressionBalancing(NamedRange):
-    """
-    A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
+    """A system that can move progression earlier, to try and prevent the player from getting stuck and bored early.
+
     A lower setting means more getting stuck. A higher setting means less getting stuck.
     """
     default = 50
     range_start = 0
     range_end = 99
     display_name = "Progression Balancing"
+    rich_text_doc = True
     special_range_names = {
         "disabled": 0,
         "normal": 50,
@@ -1177,6 +1236,7 @@ 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:
@@ -1205,29 +1265,36 @@ class CommonOptions(metaclass=OptionsMetaProperty):
 class LocalItems(ItemSet):
     """Forces these items to be in their native world."""
     display_name = "Local Items"
+    rich_text_doc = True
 
 
 class NonLocalItems(ItemSet):
     """Forces these items to be outside their native world."""
     display_name = "Non-local Items"
+    rich_text_doc = True
 
 
 class StartInventory(ItemDict):
     """Start with these items."""
     verify_item_name = True
     display_name = "Start Inventory"
+    rich_text_doc = True
 
 
 class StartInventoryPool(StartInventory):
     """Start with these items and don't place them in the world.
-    The game decides what the replacement items will be."""
+
+    The game decides what the replacement items will be.
+    """
     verify_item_name = True
     display_name = "Start Inventory from Pool"
+    rich_text_doc = True
 
 
 class StartHints(ItemSet):
-    """Start with these item's locations prefilled into the !hint command."""
+    """Start with these item's locations prefilled into the ``!hint`` command."""
     display_name = "Start Hints"
+    rich_text_doc = True
 
 
 class LocationSet(OptionSet):
@@ -1236,28 +1303,33 @@ class LocationSet(OptionSet):
 
 
 class StartLocationHints(LocationSet):
-    """Start with these locations and their item prefilled into the !hint command"""
+    """Start with these locations and their item prefilled into the ``!hint`` command."""
     display_name = "Start Location Hints"
+    rich_text_doc = True
 
 
 class ExcludeLocations(LocationSet):
-    """Prevent these locations from having an important item"""
+    """Prevent these locations from having an important item."""
     display_name = "Excluded Locations"
+    rich_text_doc = True
 
 
 class PriorityLocations(LocationSet):
-    """Prevent these locations from having an unimportant item"""
+    """Prevent these locations from having an unimportant item."""
     display_name = "Priority Locations"
+    rich_text_doc = True
 
 
 class DeathLink(Toggle):
     """When you die, everyone dies. Of course the reverse is true too."""
     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([
         {
@@ -1324,6 +1396,7 @@ class ItemLinks(OptionList):
 
 class Removed(FreeText):
     """This Option has been Removed."""
+    rich_text_doc = True
     default = ""
     visibility = Visibility.none
 
@@ -1426,14 +1499,18 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
         return data, notes
 
+    def yaml_dump_scalar(scalar) -> str:
+        # yaml dump may add end of document marker and newlines.
+        return yaml.dump(scalar).replace("...\n", "").strip()
+
     for game_name, world in AutoWorldRegister.world_types.items():
         if not world.hidden or generate_hidden:
-            grouped_options = get_option_groups(world)
+            option_groups = get_option_groups(world)
             with open(local_path("data", "options.yaml")) as f:
                 file_data = f.read()
             res = Template(file_data).render(
-                option_groups=grouped_options,
-                __version__=__version__, game=game_name, yaml_dump=yaml.dump,
+                option_groups=option_groups,
+                __version__=__version__, game=game_name, yaml_dump=yaml_dump_scalar,
                 dictify_range=dictify_range,
             )
 
@@ -1441,31 +1518,3 @@ def generate_yaml_templates(target_folder: typing.Union[str, "pathlib.Path"], ge
 
             with open(os.path.join(target_folder, game_name + ".yaml"), "w", encoding="utf-8-sig") as f:
                 f.write(res)
-
-
-if __name__ == "__main__":
-
-    from worlds.alttp.Options import Logic
-    import argparse
-
-    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,6 +72,10 @@ 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=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=Utils.user_path("Undertale"), exist_ok=True)
             self.ctx.patch_game()
             self.output("Patched.")
 
@@ -43,7 +43,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
     def _cmd_auto_patch(self, steaminstall: typing.Optional[str] = None):
         """Patch the game automatically."""
         if isinstance(self.ctx, UndertaleContext):
-            os.makedirs(name=os.path.join(os.getcwd(), "Undertale"), exist_ok=True)
+            os.makedirs(name=Utils.user_path("Undertale"), exist_ok=True)
             tempInstall = steaminstall
             if not os.path.isfile(os.path.join(tempInstall, "data.win")):
                 tempInstall = None
@@ -62,7 +62,7 @@ class UndertaleCommandProcessor(ClientCommandProcessor):
                 for file_name in os.listdir(tempInstall):
                     if file_name != "steam_api.dll":
                         shutil.copy(os.path.join(tempInstall, file_name),
-                               os.path.join(os.getcwd(), "Undertale", file_name))
+                               Utils.user_path("Undertale", file_name))
                 self.ctx.patch_game()
                 self.output("Patching successful!")
 
@@ -111,12 +111,12 @@ class UndertaleContext(CommonContext):
         self.save_game_folder = os.path.expandvars(r"%localappdata%/UNDERTALE")
 
     def patch_game(self):
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "rb") as f:
+        with open(Utils.user_path("Undertale", "data.win"), "rb") as f:
             patchedFile = bsdiff4.patch(f.read(), undertale.data_path("patch.bsdiff"))
-        with open(os.path.join(os.getcwd(), "Undertale", "data.win"), "wb") as f:
+        with open(Utils.user_path("Undertale", "data.win"), "wb") as f:
             f.write(patchedFile)
-        os.makedirs(name=os.path.join(os.getcwd(), "Undertale", "Custom Sprites"), exist_ok=True)
-        with open(os.path.expandvars(os.path.join(os.getcwd(), "Undertale", "Custom Sprites",
+        os.makedirs(name=Utils.user_path("Undertale", "Custom Sprites"), exist_ok=True)
+        with open(os.path.expandvars(Utils.user_path("Undertale", "Custom Sprites",
                                      "Which Character.txt")), "w") as f:
             f.writelines(["// Put the folder name of the sprites you want to play as, make sure it is the only "
                           "line other than this one.\n", "frisk"])
@@ -247,8 +247,8 @@ async def process_undertale_cmd(ctx: UndertaleContext, cmd: str, args: dict):
             with open(os.path.join(ctx.save_game_folder, filename), "w") as f:
                 toDraw = ""
                 for i in range(20):
-                    if i < len(str(ctx.item_names.lookup_in_slot(l.item))):
-                        toDraw += str(ctx.item_names.lookup_in_slot(l.item))[i]
+                    if i < len(str(ctx.item_names.lookup_in_game(l.item))):
+                        toDraw += str(ctx.item_names.lookup_in_game(l.item))[i]
                     else:
                         break
                 f.write(toDraw)

Utils.py

@@ -553,6 +553,7 @@ 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 ''}"
     )
 
 

WargrooveClient.py

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

WebHost.py

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

@@ -5,7 +5,6 @@ from uuid import UUID
 from flask import Blueprint, abort, url_for
 
 import worlds.Files
-from .. import cache
 from ..models import Room, Seed
 
 api_endpoints = Blueprint('api', __name__, url_prefix="/api")
@@ -49,21 +48,4 @@ def room_info(room: UUID):
     }
 
 
-@api_endpoints.route('/datapackage')
-@cache.cached()
-def get_datapackage():
-    from worlds import network_data_package
-    return network_data_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
+from . import generate, user, datapackage  # trigger registration

WebHostLib/api/datapackage.py

@@ -0,0 +1,32 @@
+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/customserver.py

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

WebHostLib/misc.py

@@ -1,6 +1,6 @@
 import datetime
 import os
-from typing import List, Dict, Union
+from typing import Any, IO, Dict, Iterator, List, Tuple, Union
 
 import jinja2.exceptions
 from flask import request, redirect, url_for, render_template, Response, session, abort, send_from_directory
@@ -97,25 +97,37 @@ def new_room(seed: UUID):
     return redirect(url_for("host_room", room=room.id))
 
 
-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."
+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
 
 
 @app.route('/log/<suuid:room>')
-def display_log(room: UUID):
+def display_log(room: UUID) -> Union[str, Response, Tuple[str, int]]:
     room = Room.get(id=room)
     if room is None:
         return abort(404)
     if room.owner == session["_id"]:
         file_path = os.path.join("logs", str(room.id) + ".txt")
-        if os.path.exists(file_path):
-            return Response(_read_log(file_path), mimetype="text/plain;charset=UTF-8")
-        return "Log File does not exist."
+        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")
 
     return "Access Denied", 403
 
@@ -139,7 +151,22 @@ def host_room(room: UUID):
     with db_session:
         room.last_activity = now  # will trigger a spinup, if it's not already running
 
-    return render_template("hostRoom.html", room=room, should_refresh=should_refresh)
+    def get_log(max_size: int = 1024000) -> str:
+        try:
+            with open(os.path.join("logs", str(room.id) + ".txt"), "rb") as log:
+                raw_size = 0
+                fragments: List[str] = []
+                for block in _read_log(log):
+                    if raw_size + len(block) > max_size:
+                        fragments.append("…")
+                        break
+                    raw_size += len(block)
+                    fragments.append(block.decode("utf-8"))
+                return "".join(fragments)
+        except FileNotFoundError:
+            return ""
+
+    return render_template("hostRoom.html", room=room, should_refresh=should_refresh, get_log=get_log)
 
 
 @app.route('/favicon.ico')

WebHostLib/options.py

@@ -3,6 +3,7 @@ import json
 import os
 from textwrap import dedent
 from typing import Dict, Union
+from docutils.core import publish_parts
 
 import yaml
 from flask import redirect, render_template, request, Response
@@ -66,6 +67,22 @@ def filter_dedent(text: str) -> str:
     return dedent(text).strip("\n ")
 
 
+@app.template_filter("rst_to_html")
+def filter_rst_to_html(text: str) -> str:
+    """Converts reStructuredText (such as a Python docstring) to HTML."""
+    if text.startswith(" ") or text.startswith("\t"):
+        text = dedent(text)
+    elif "\n" in text:
+        lines = text.splitlines()
+        text = lines[0] + "\n" + dedent("\n".join(lines[1:]))
+
+    return publish_parts(text, writer_name='html', settings=None, settings_overrides={
+        'raw_enable': False,
+        'file_insertion_enabled': False,
+        'output_encoding': 'unicode'
+    })['body']
+
+
 @app.template_test("ordered")
 def test_ordered(obj):
     return isinstance(obj, collections.abc.Sequence)
@@ -214,6 +231,13 @@ def generate_yaml(game: str):
 
                 del options[key]
 
+            # Detect keys which end with -range, indicating a NamedRange with a possible custom value
+            elif key_parts[-1].endswith("-range"):
+                if options[key_parts[-1][:-6]] == "custom":
+                    options[key_parts[-1][:-6]] = val
+
+                del options[key]
+
         # Detect random-* keys and set their options accordingly
         for key, val in options.copy().items():
             if key.startswith("random-"):

WebHostLib/requirements.txt

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

WebHostLib/robots.py

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

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

WebHostLib/templates/hostRoom.html

@@ -44,7 +44,7 @@
         {{ macros.list_patches_room(room) }}
         {% if room.owner == session["_id"] %}
             <div style="display: flex; align-items: center;">
-                <form method=post style="flex-grow: 1; margin-right: 1em;">
+                <form method="post" id="command-form" 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"
@@ -55,24 +55,89 @@
                     Open Log File...
                 </a>
             </div>
-        <div id="logger"></div>
-        <script type="application/ecmascript">
-            let xmlhttp = new XMLHttpRequest();
-            let url = '{{ url_for('display_log', room = room.id) }}';
+        {%  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 awaitingCommandResponse = false;
+          let logger = document.getElementById("logger");
 
-            xmlhttp.onreadystatechange = function () {
-                if (this.readyState === 4 && this.status === 200) {
-                    document.getElementById("logger").innerText = this.responseText;
-                }
-            };
-
-            function request_new() {
-                xmlhttp.open("GET", url, true);
-                xmlhttp.send();
+          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);
             }
+          }
 
-            window.setTimeout(request_new, 1000);
-            window.setInterval(request_new, 10000);
+          async function updateLog() {
+            try {
+              let res = await fetch(url, {
+                headers: {
+                  'Range': `bytes=${bytesReceived}-`,
+                }
+              });
+              if (res.ok) {
+                let text = await res.text();
+                if (text.length > 0) {
+                  awaitingCommandResponse = false;
+                  if (bytesReceived === 0 || res.status !== 206) {
+                    logger.innerHTML = '';
+                  }
+                  if (res.status !== 206) {
+                    bytesReceived = 0;
+                  } else {
+                    bytesReceived += new Blob([text]).size;
+                  }
+                  if (logger.innerHTML.endsWith('…')) {
+                    logger.innerHTML = logger.innerHTML.substring(0, logger.innerHTML.length - 1);
+                  }
+                  logger.appendChild(document.createTextNode(text));
+                  scrollToBottom(logger);
+                }
+              }
+            }
+            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;
+            }
+            /** @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 res = await req;
+            if (res.ok || res.type === 'opaqueredirect') {
+              awaitingCommandResponse = true;
+              window.clearTimeout(updateLogTimeout);
+              updateLogTimeout = window.setTimeout(updateLog, 100);
+            } else {
+              window.alert(res.statusText);
+            }
+          }
+
+          document.getElementById("command-form").addEventListener("submit", postForm);
+          updateLogTimeout = window.setTimeout(updateLog, 1000);
+          logger.scrollTop = logger.scrollHeight;
         </script>
         {% endif %}
     </div>

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" data-option-name="{{ option_name }}" {{ "disabled" if option.default == "random" }}>
+        <select id="{{ option_name }}-select" name="{{ option_name }}" 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 }} ({{ val }})</option>
+                    <option value="{{ val }}" selected>{{ key|replace("_", " ")|title }} ({{ val }})</option>
                 {% else %}
-                    <option value="{{ val }}">{{ key }} ({{ val }})</option>
+                    <option value="{{ val }}">{{ key|replace("_", " ")|title }} ({{ val }})</option>
                 {% endif %}
             {% endfor %}
             <option value="custom" hidden>Custom</option>
         </select>
-        <div class="named-range-wrapper">
+        <div class="named-range-wrapper js-required">
             <input
                     type="range"
                     id="{{ option_name }}"
-                    name="{{ option_name }}"
+                    name="{{ option_name }}-range"
                     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 js-required">
+            <span id="{{ option_name }}-value" class="range-value">
                 {{ 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, world) %}
+{% macro ItemDict(option_name, option) %}
     {{ 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, world) %}
+{% macro LocationSet(option_name, option) %}
     {{ 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, world) %}
+{% macro ItemSet(option_name, option) %}
     {{ OptionTitle(option_name, option) }}
     <div class="option-container">
         {% for group_name in world.item_name_groups.keys()|sort %}
@@ -196,7 +196,18 @@
 {% macro OptionTitle(option_name, option) %}
     <label for="{{ option_name }}">
         {{ option.display_name|default(option_name) }}:
-        <span class="interactive" data-tooltip="{% filter dedent %}{{(option.__doc__ | default("Please document me!"))|escape }}{% endfilter %}">(?)</span>
+        <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>
     </label>
 {% endmacro %}
 

WebHostLib/templates/playerOptions/playerOptions.html

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

WebHostLib/templates/weightedOptions/macros.html

@@ -18,7 +18,11 @@
         <tbody>
             {% for id, name in option.name_lookup.items() %}
                 {% if name != 'random' %}
-                    {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.get_option_name(option.default)|lower == name|lower else None) }}
+                    {% if option.default != 'random' %}
+                        {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.default == id else None) }}
+                    {% else %}
+                        {{ RangeRow(option_name, option, option.get_option_name(id), name) }}
+                    {% endif %}
                 {% endif %}
             {% endfor %}
             {{ RandomRow(option_name, option) }}
@@ -34,16 +38,16 @@
         Normal range: {{ option.range_start }} - {{ option.range_end }}
         {% if option.special_range_names %}
             <br /><br />
-            The following values has special meaning, and may fall outside the normal range.
+            The following values have special meanings, and may fall outside the normal range.
             <ul>
                 {% for name, value in option.special_range_names.items() %}
-                    <li>{{ value }}: {{ name }}</li>
+                    <li>{{ value }}: {{ name|replace("_", " ")|title }}</li>
                 {% endfor %}
             </ul>
         {% endif %}
         <div class="add-option-div">
             <input type="number" class="range-option-value" data-option="{{ option_name }}" />
-            <button class="add-range-option-button" data-option="{{ option_name }}">Add</button>
+            <button type="button" class="add-range-option-button" data-option="{{ option_name }}">Add</button>
         </div>
     </div>
     <table class="range-rows" data-option="{{ option_name }}">
@@ -68,7 +72,7 @@
         This option allows custom values only. Please enter your desired values below.
         <div class="custom-value-wrapper">
             <input class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
-            <button data-option="{{ option_name }}">Add</button>
+            <button type="button" data-option="{{ option_name }}">Add</button>
         </div>
         <table>
             <tbody>
@@ -85,14 +89,18 @@
         Custom values are also allowed for this option. To create one, enter it into the input box below.
         <div class="custom-value-wrapper">
             <input class="custom-value" data-option="{{ option_name }}" placeholder="Custom Value" />
-            <button data-option="{{ option_name }}">Add</button>
+            <button type="button" data-option="{{ option_name }}">Add</button>
         </div>
     </div>
     <table>
         <tbody>
             {% for id, name in option.name_lookup.items() %}
                 {% if name != 'random' %}
-                    {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.get_option_name(option.default)|lower == name else None) }}
+                    {% if option.default != 'random' %}
+                        {{ RangeRow(option_name, option, option.get_option_name(id), name, False, name if option.default == id else None) }}
+                    {% else %}
+                        {{ RangeRow(option_name, option, option.get_option_name(id), name) }}
+                    {% endif %}
                 {% endif %}
             {% endfor %}
             {{ RandomRow(option_name, option) }}
@@ -130,7 +138,7 @@
                     id="{{ option_name }}-{{ key }}"
                     name="{{ option_name }}||{{ key }}"
                     value="1"
-                    checked="{{ "checked" if key in option.default else "" }}"
+                    {{ "checked" if key in option.default }}
                 />
                 <label for="{{ option_name }}-{{ key }}">
                     {{ key }}

WebHostLib/tracker.py

@@ -79,7 +79,7 @@ class TrackerData:
 
             # Normal lookup tables as well.
             self.item_name_to_id[game] = game_package["item_name_to_id"]
-            self.location_name_to_id[game] = game_package["item_name_to_id"]
+            self.location_name_to_id[game] = game_package["location_name_to_id"]
 
     def get_seed_name(self) -> str:
         """Retrieves the seed name."""
@@ -1366,28 +1366,28 @@ if "Starcraft 2" in network_data_package["games"]:
         organics_icon_base_url = "https://0rganics.org/archipelago/sc2wol/"
 
         icons = {
-            "Starting Minerals":                           "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/icons/icon-mineral-protoss.png",
-            "Starting Vespene":                            "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/icons/icon-gas-terran.png",
+            "Starting Minerals":                           github_icon_base_url + "blizzard/icon-mineral-nobg.png",
+            "Starting Vespene":                            github_icon_base_url + "blizzard/icon-gas-terran-nobg.png",
             "Starting Supply":                             github_icon_base_url + "blizzard/icon-supply-terran_nobg.png",
 
-            "Terran Infantry Weapons Level 1":             "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryweaponslevel1.png",
-            "Terran Infantry Weapons Level 2":             "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryweaponslevel2.png",
-            "Terran Infantry Weapons Level 3":             "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryweaponslevel3.png",
-            "Terran Infantry Armor Level 1":               "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryarmorlevel1.png",
-            "Terran Infantry Armor Level 2":               "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryarmorlevel2.png",
-            "Terran Infantry Armor Level 3":               "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-infantryarmorlevel3.png",
-            "Terran Vehicle Weapons Level 1":              "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleweaponslevel1.png",
-            "Terran Vehicle Weapons Level 2":              "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleweaponslevel2.png",
-            "Terran Vehicle Weapons Level 3":              "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleweaponslevel3.png",
-            "Terran Vehicle Armor Level 1":                "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleplatinglevel1.png",
-            "Terran Vehicle Armor Level 2":                "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleplatinglevel2.png",
-            "Terran Vehicle Armor Level 3":                "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-vehicleplatinglevel3.png",
-            "Terran Ship Weapons Level 1":                 "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipweaponslevel1.png",
-            "Terran Ship Weapons Level 2":                 "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipweaponslevel2.png",
-            "Terran Ship Weapons Level 3":                 "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipweaponslevel3.png",
-            "Terran Ship Armor Level 1":                   "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipplatinglevel1.png",
-            "Terran Ship Armor Level 2":                   "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipplatinglevel2.png",
-            "Terran Ship Armor Level 3":                   "https://sclegacy.com/images/uploaded/starcraftii_beta/gamefiles/upgrades/btn-upgrade-terran-shipplatinglevel3.png",
+            "Terran Infantry Weapons Level 1":             github_icon_base_url + "blizzard/btn-upgrade-terran-infantryweaponslevel1.png",
+            "Terran Infantry Weapons Level 2":             github_icon_base_url + "blizzard/btn-upgrade-terran-infantryweaponslevel2.png",
+            "Terran Infantry Weapons Level 3":             github_icon_base_url + "blizzard/btn-upgrade-terran-infantryweaponslevel3.png",
+            "Terran Infantry Armor Level 1":               github_icon_base_url + "blizzard/btn-upgrade-terran-infantryarmorlevel1.png",
+            "Terran Infantry Armor Level 2":               github_icon_base_url + "blizzard/btn-upgrade-terran-infantryarmorlevel2.png",
+            "Terran Infantry Armor Level 3":               github_icon_base_url + "blizzard/btn-upgrade-terran-infantryarmorlevel3.png",
+            "Terran Vehicle Weapons Level 1":              github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleweaponslevel1.png",
+            "Terran Vehicle Weapons Level 2":              github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleweaponslevel2.png",
+            "Terran Vehicle Weapons Level 3":              github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleweaponslevel3.png",
+            "Terran Vehicle Armor Level 1":                github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleplatinglevel1.png",
+            "Terran Vehicle Armor Level 2":                github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleplatinglevel2.png",
+            "Terran Vehicle Armor Level 3":                github_icon_base_url + "blizzard/btn-upgrade-terran-vehicleplatinglevel3.png",
+            "Terran Ship Weapons Level 1":                 github_icon_base_url + "blizzard/btn-upgrade-terran-shipweaponslevel1.png",
+            "Terran Ship Weapons Level 2":                 github_icon_base_url + "blizzard/btn-upgrade-terran-shipweaponslevel2.png",
+            "Terran Ship Weapons Level 3":                 github_icon_base_url + "blizzard/btn-upgrade-terran-shipweaponslevel3.png",
+            "Terran Ship Armor Level 1":                   github_icon_base_url + "blizzard/btn-upgrade-terran-shipplatinglevel1.png",
+            "Terran Ship Armor Level 2":                   github_icon_base_url + "blizzard/btn-upgrade-terran-shipplatinglevel2.png",
+            "Terran Ship Armor Level 3":                   github_icon_base_url + "blizzard/btn-upgrade-terran-shipplatinglevel3.png",
 
             "Bunker":                                      "https://static.wikia.nocookie.net/starcraft/images/c/c5/Bunker_SC2_Icon1.jpg",
             "Missile Turret":                              "https://static.wikia.nocookie.net/starcraft/images/5/5f/MissileTurret_SC2_Icon1.jpg",

Zelda1Client.py

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

_speedups.pyx

@@ -1,5 +1,6 @@
 #cython: language_level=3
-#distutils: language = c++
+#distutils: language = c
+#distutils: depends = intset.h
 
 """
 Provides faster implementation of some core parts.
@@ -13,7 +14,6 @@ from cpython cimport PyObject
 from typing import Any, Dict, Iterable, Iterator, Generator, Sequence, Tuple, TypeVar, Union, Set, List, TYPE_CHECKING
 from cymem.cymem cimport Pool
 from libc.stdint cimport int64_t, uint32_t
-from libcpp.set cimport set as std_set
 from collections import defaultdict
 
 cdef extern from *:
@@ -31,6 +31,27 @@ ctypedef int64_t ap_id_t
 cdef ap_player_t MAX_PLAYER_ID = 1000000  # limit the size of indexing array
 cdef size_t INVALID_SIZE = <size_t>(-1)  # this is all 0xff... adding 1 results in 0, but it's not negative
 
+# configure INTSET for player
+cdef extern from *:
+    """
+    #define INTSET_NAME ap_player_set
+    #define INTSET_TYPE uint32_t  // has to match ap_player_t
+    """
+
+# create INTSET for player
+cdef extern from "intset.h":
+    """
+    #undef INTSET_NAME
+    #undef INTSET_TYPE
+    """
+    ctypedef struct ap_player_set:
+        pass
+
+    ap_player_set* ap_player_set_new(size_t bucket_count) nogil
+    void ap_player_set_free(ap_player_set* set) nogil
+    bint ap_player_set_add(ap_player_set* set, ap_player_t val) nogil
+    bint ap_player_set_contains(ap_player_set* set, ap_player_t val) nogil
+
 
 cdef struct LocationEntry:
     # layout is so that
@@ -185,7 +206,7 @@ cdef class LocationStore:
     def find_item(self, slots: Set[int], seeked_item_id: int) -> Generator[Tuple[int, int, int, int, int], None, None]:
         cdef ap_id_t item = seeked_item_id
         cdef ap_player_t receiver
-        cdef std_set[ap_player_t] receivers
+        cdef ap_player_set* receivers
         cdef size_t slot_count = len(slots)
         if slot_count == 1:
             # specialized implementation for single slot
@@ -197,13 +218,20 @@ cdef class LocationStore:
                             yield entry.sender, entry.location, entry.item, entry.receiver, entry.flags
         elif slot_count:
             # generic implementation with lookup in set
-            for receiver in slots:
-                receivers.insert(receiver)
-            with nogil:
-                for entry in self.entries[:self.entry_count]:
-                    if entry.item == item and receivers.count(entry.receiver):
-                        with gil:
-                            yield entry.sender, entry.location, entry.item, entry.receiver, entry.flags
+            receivers = ap_player_set_new(min(1023, slot_count))  # limit top level struct to 16KB
+            if not receivers:
+                raise MemoryError()
+            try:
+                for receiver in slots:
+                    if not ap_player_set_add(receivers, receiver):
+                        raise MemoryError()
+                with nogil:
+                    for entry in self.entries[:self.entry_count]:
+                        if entry.item == item and ap_player_set_contains(receivers, entry.receiver):
+                            with gil:
+                                yield entry.sender, entry.location, entry.item, entry.receiver, entry.flags
+            finally:
+                ap_player_set_free(receivers)
 
     def get_for_player(self, slot: int) -> Dict[int, Set[int]]:
         cdef ap_player_t receiver = slot
@@ -259,15 +287,15 @@ cdef class LocationStore:
                     entry in self.entries[start:start + count] if
                     entry.location not in checked]
 
-    def get_remaining(self, state: State, team: int, slot: int) -> List[int]:
+    def get_remaining(self, state: State, team: int, slot: int) -> List[Tuple[int, int]]:
         cdef LocationEntry* entry
         cdef ap_player_t sender = slot
         cdef size_t start = self.sender_index[sender].start
         cdef size_t count = self.sender_index[sender].count
         cdef set checked = state[team, slot]
-        return sorted([entry.item for
-                       entry in self.entries[start:start+count] if
-                       entry.location not in checked])
+        return sorted([(entry.receiver, entry.item) for
+                        entry in self.entries[start:start+count] if
+                        entry.location not in checked])
 
 
 @cython.auto_pickle(False)

_speedups.pyxbld

@@ -1,8 +1,10 @@
-# This file is required to get pyximport to work with C++.
-# Switching from std::set to a pure C implementation is still on the table to simplify everything.
+# This file is used when doing pyximport
+import os
 
 def make_ext(modname, pyxfilename):
     from distutils.extension import Extension
     return Extension(name=modname,
                      sources=[pyxfilename],
-                     language='c++')
+                     depends=["intset.h"],
+                     include_dirs=[os.getcwd()],
+                     language="c")

data/client.kv

@@ -13,6 +13,7 @@
     plum: "AF99EF"  # typically progression item
     salmon: "FA8072"  # typically trap item
     white: "FFFFFF"  # not used, if you want to change the generic text color change color in Label
+    orange: "FF7700"  # Used for command echo
 <Label>:
     color: "FFFFFF"
 <TabbedPanel>:

data/options.yaml

@@ -68,21 +68,21 @@ requires:
 
     {%- elif option.options -%}
     {%- for suboption_option_id, sub_option_name in option.name_lookup.items() %}
-    {{ sub_option_name }}: {% if suboption_option_id == option.default %}50{% else %}0{% endif %}
+    {{ yaml_dump(sub_option_name) }}: {% if suboption_option_id == option.default %}50{% else %}0{% endif %}
     {%- endfor -%}
 
     {%- if option.name_lookup[option.default] not in option.options %}
-    {{ option.default }}: 50
+    {{ yaml_dump(option.default) }}: 50
     {%- endif -%}
 
     {%- elif option.default is string %}
-    {{ option.default }}: 50
+    {{ yaml_dump(option.default) }}: 50
 
     {%- elif option.default is iterable and option.default is not mapping %}
     {{ option.default | list }}
 
     {%- else %}
-    {{ yaml_dump(option.default) | trim | indent(4, first=false) }}
+    {{ yaml_dump(option.default) | indent(4, first=false) }}
     {%- endif -%}
     {{ "\n" }}
   {%- endfor %}

docs/CODEOWNERS

@@ -1,8 +1,8 @@
 # Archipelago World Code Owners / Maintainers Document
 #
-# This file is used to notate the current "owners" or "maintainers" of any currently merged world folder. For any pull
-# requests that modify these worlds, a code owner must approve the PR in addition to a core maintainer. This is not to
-# be used for files/folders outside the /worlds folder, those will always need sign off from a core maintainer.
+# This file is used to notate the current "owners" or "maintainers" of any currently merged world folder as well as
+# certain documentation. For any pull requests that modify these worlds/docs, a code owner must approve the PR in
+# addition to a core maintainer. All other files and folders are owned and maintained by core maintainers directly.
 #
 # All usernames must be GitHub usernames (and are case sensitive).
 
@@ -70,7 +70,7 @@
 /worlds/heretic/ @Daivuk
 
 # Hollow Knight
-/worlds/hk/ @BadMagic100 @ThePhar
+/worlds/hk/ @BadMagic100 @qwint
 
 # Hylics 2
 /worlds/hylics2/ @TRPG0
@@ -78,6 +78,9 @@
 # Kirby's Dream Land 3
 /worlds/kdl3/ @Silvris
 
+# Kingdom Hearts
+/worlds/kh1/ @gaithern
+
 # Kingdom Hearts 2
 /worlds/kh2/ @JaredWeakStrike
 
@@ -87,9 +90,6 @@
 # Lingo
 /worlds/lingo/ @hatkirby
 
-# Links Awakening DX
-/worlds/ladx/ @zig-for
-
 # Lufia II Ancient Cave
 /worlds/lufia2ac/ @el-u
 /worlds/lufia2ac/docs/ @wordfcuk @el-u
@@ -106,6 +106,9 @@
 # Minecraft
 /worlds/minecraft/ @KonoTyran @espeon65536
 
+# Mega Man 2
+/worlds/mm2/ @Silvris
+
 # MegaMan Battle Network 3
 /worlds/mmbn3/ @digiholic
 
@@ -118,6 +121,9 @@
 # Ocarina of Time
 /worlds/oot/ @espeon65536
 
+# Old School Runescape
+/worlds/osrs @digiholic
+
 # Overcooked! 2
 /worlds/overcooked2/ @toasterparty
 
@@ -196,6 +202,9 @@
 # The Witness
 /worlds/witness/ @NewSoupVi @blastron
 
+# Yacht Dice
+/worlds/yachtdice/ @spinerak
+
 # Yoshi's Island
 /worlds/yoshisisland/ @PinkSwitch
 
@@ -218,6 +227,8 @@
 # Final Fantasy (1)
 # /worlds/ff1/
 
+# Links Awakening DX
+# /worlds/ladx/
 
 ## Disabled Unmaintained Worlds
 
@@ -227,3 +238,11 @@
 
 # Ori and the Blind Forest
 # /worlds_disabled/oribf/
+
+###################
+## Documentation ##
+###################
+
+# Apworld Dev Faq
+/docs/apworld_dev_faq.md @qwint @ScipioWright
+

docs/apworld_dev_faq.md

@@ -0,0 +1,45 @@
+# APWorld Dev FAQ
+
+This document is meant as a reference tool to show solutions to common problems when developing an apworld.
+It is not intended to answer every question about Archipelago and it assumes you have read the other docs, 
+including [Contributing](contributing.md), [Adding Games](<adding games.md>), and [World API](<world api.md>).
+
+---
+
+### My game has a restrictive start that leads to fill errors
+
+Hint to the Generator that an item needs to be in sphere one with local_early_items. Here, `1` represents the number of "Sword" items to attempt to place in sphere one.
+```py
+early_item_name = "Sword"
+self.multiworld.local_early_items[self.player][early_item_name] = 1
+```
+
+Some alternative ways to try to fix this problem are:
+* Add more locations to sphere one of your world, potentially only when there would be a restrictive start
+* Pre-place items yourself, such as during `create_items`
+* Put items into the player's starting inventory using `push_precollected`
+* Raise an exception, such as an `OptionError` during `generate_early`, to disallow options that would lead to a restrictive start
+
+---
+
+### I have multiple settings that change the item/location pool counts and need to balance them out
+
+In an ideal situation your system for producing locations and items wouldn't leave any opportunity for them to be unbalanced. But in real, complex situations, that might be unfeasible.
+
+If that's the case, you can create extra filler based on the difference between your unfilled locations and your itempool by comparing [get_unfilled_locations](https://github.com/ArchipelagoMW/Archipelago/blob/main/BaseClasses.py#:~:text=get_unfilled_locations) to your list of items to submit
+
+Note: to use self.create_filler(), self.get_filler_item_name() should be defined to only return valid filler item names
+```py
+total_locations = len(self.multiworld.get_unfilled_locations(self.player))
+item_pool = self.create_non_filler_items()
+
+for _ in range(total_locations - len(item_pool)):
+    item_pool.append(self.create_filler())
+
+self.multiworld.itempool += item_pool
+```
+
+A faster alternative to the `for` loop would be to use a [list comprehension](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions):
+```py
+item_pool += [self.create_filler() for _ in range(total_locations - len(item_pool))]
+```

docs/network protocol.md

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

docs/options api.md

@@ -85,6 +85,50 @@ class ExampleWorld(World):
     options: ExampleGameOptions
 ```
 
+### Option Documentation
+
+Options' [docstrings] are used as their user-facing documentation. They're displayed on the WebHost setup page when a
+user hovers over the yellow "(?)" icon, and included in the YAML templates generated for each game.
+
+[docstrings]: /docs/world%20api.md#docstrings
+
+The WebHost can display Option documentation either as plain text with all whitespace preserved (other than the base
+indentation), or as HTML generated from the standard Python [reStructuredText] format. Although plain text is the
+default for backwards compatibility, world authors are encouraged to write their Option documentation as
+reStructuredText and enable rich text rendering by setting `World.rich_text_options_doc = True`.
+
+[reStructuredText]: https://docutils.sourceforge.io/rst.html
+
+```python
+from worlds.AutoWorld import WebWorld
+
+
+class ExampleWebWorld(WebWorld):
+    # Render all this world's options as rich text.
+    rich_text_options_doc = True
+```
+
+You can set a single option to use rich or plain text by setting
+`Option.rich_text_doc`.
+
+```python
+from Options import Toggle, Range, Choice, PerGameCommonOptions
+
+
+class Difficulty(Choice):
+    """Sets overall game difficulty.
+
+    - **Easy:** All enemies die in one hit.
+    - **Normal:** Enemies and the player both have normal health bars.
+    - **Hard:** The player dies in one hit."""
+    display_name = "Difficulty"
+    rich_text_doc = True
+    option_easy = 0
+    option_normal = 1
+    option_hard = 2
+    default = 1
+```
+
 ### Option Groups
 Options may be categorized into groups for display on the WebHost. Option groups are displayed in the order specified
 by your world on the player-options and weighted-options pages. In the generated template files, there will be a comment

docs/running from source.md

@@ -8,7 +8,7 @@ use that version. These steps are for developers or platforms without compiled r
 
 What you'll need:
  * [Python 3.8.7 or newer](https://www.python.org/downloads/), not the Windows Store version
-   * **Python 3.12 is currently unsupported**
+   * Python 3.12.x is currently the newest supported version
  * pip: included in downloads from python.org, separate in many Linux distributions
  * Matching C compiler
    * possibly optional, read operating system specific sections
@@ -31,7 +31,7 @@ After this, you should be able to run the programs.
 
 Recommended steps
  * Download and install a "Windows installer (64-bit)" from the [Python download page](https://www.python.org/downloads)
-   * **Python 3.12 is currently unsupported**
+   * [read above](#General) which versions are supported
 
  * **Optional**: Download and install Visual Studio Build Tools from
    [Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/).

docs/world api.md

@@ -56,6 +56,12 @@ webhost:
 
 * `options_page` can be changed to a link instead of an AP-generated options page.
 
+* `rich_text_options_doc` controls whether [Option documentation] uses plain text (`False`) or rich text (`True`). It
+  defaults to `False`, but world authors are encouraged to set it to `True` for nicer-looking documentation that looks
+  good on both the WebHost and the YAML template.
+
+  [Option documentation]: /docs/options%20api.md#option-documentation
+
 * `theme` to be used for your game-specific AP pages. Available themes:
 
   | dirt                                       | grass (default)                             | grassFlowers                                       | ice                                       | jungle                                       | ocean                                       | partyTime                                       | stone                                       |
@@ -450,8 +456,9 @@ In addition, the following methods can be implemented and are called in this ord
   called to place player's regions and their locations into the MultiWorld's regions list.
   If it's hard to separate, this can be done during `generate_early` or `create_items` as well.
 * `create_items(self)`
-  called to place player's items into the MultiWorld's itempool. After this step all regions
-  and items have to be in the MultiWorld's regions and itempool, and these lists should not be modified afterward.
+  called to place player's items into the MultiWorld's itempool. By the end of this step all regions, locations and
+  items have to be in the MultiWorld's regions and itempool. You cannot add or remove items, locations, or regions
+  after this step. Locations cannot be moved to different regions after this step.
 * `set_rules(self)`
   called to set access and item rules on locations and entrances.
 * `generate_basic(self)`

docs/world maintainer.md

@@ -26,8 +26,17 @@ Unless these are shared between multiple people, we expect the following from ea
 ### Adding a World
 
 When we merge your world into the core Archipelago repository, you automatically become world maintainer unless you
-nominate someone else (i.e. there are multiple devs). You can define who is allowed to approve changes to your world
-in the [CODEOWNERS](/docs/CODEOWNERS) document.
+nominate someone else (i.e. there are multiple devs).
+
+### Being added as a maintainer to an existing implementation
+
+At any point, a world maintainer can approve the addition of another maintainer to their world.  
+In order to do this, either an existing maintainer or the new maintainer must open a PR updating the
+[CODEOWNERS](/docs/CODEOWNERS) file.  
+This change must be approved by all existing maintainers of the affected world, the new maintainer candidate, and
+one core maintainer.  
+To help the core team review the change, information about the new maintainer and their contributions should be
+included in the PR description.
 
 ### Getting Voted
 

inno_setup.iss

@@ -89,6 +89,9 @@ Type: files; Name: "{app}\ArchipelagoPokemonClient.exe"
 Type: files; Name: "{app}\data\lua\connector_pkmn_rb.lua"
 Type: filesandordirs; Name: "{app}\lib\worlds\rogue-legacy"
 Type: dirifempty; Name: "{app}\lib\worlds\rogue-legacy"
+Type: files; Name: "{app}\lib\worlds\sc2wol.apworld"
+Type: filesandordirs; Name: "{app}\lib\worlds\sc2wol"
+Type: dirifempty; Name: "{app}\lib\worlds\sc2wol"
 Type: filesandordirs; Name: "{app}\lib\worlds\bk_sudoku"
 Type: dirifempty; Name: "{app}\lib\worlds\bk_sudoku"
 Type: files; Name: "{app}\ArchipelagoLauncher(DEBUG).exe"
@@ -183,6 +186,11 @@ Root: HKCR; Subkey: "{#MyAppName}cv64patch";                     ValueData: "Arc
 Root: HKCR; Subkey: "{#MyAppName}cv64patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                                          ValueType: string; ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}cv64patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                                 ValueType: string; ValueName: "";
 
+Root: HKCR; Subkey: ".apmm2";                                   ValueData: "{#MyAppName}mm2patch";                               Flags: uninsdeletevalue; ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch";                     ValueData: "Archipelago Mega Man 2 Patch";                    Flags: uninsdeletekey;   ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch\DefaultIcon";         ValueData: "{app}\ArchipelagoBizHawkClient.exe,0";                                          ValueType: string; ValueName: "";
+Root: HKCR; Subkey: "{#MyAppName}mm2patch\shell\open\command";  ValueData: """{app}\ArchipelagoBizHawkClient.exe"" ""%1""";                                 ValueType: string; ValueName: "";
+
 Root: HKCR; Subkey: ".apladx";                                   ValueData: "{#MyAppName}ladxpatch";        Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ladxpatch";                     ValueData: "Archipelago Links Awakening DX Patch"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}ladxpatch\DefaultIcon";         ValueData: "{app}\ArchipelagoLinksAwakeningClient.exe,0";                           ValueType: string;  ValueName: "";
@@ -216,7 +224,7 @@ Root: HKCR; Subkey: "{#MyAppName}multidata\shell\open\command";  ValueData: """{
 Root: HKCR; Subkey: ".apworld";                                 ValueData: "{#MyAppName}worlddata";  Flags: uninsdeletevalue; ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}worlddata";                    ValueData: "Archipelago World Data"; Flags: uninsdeletekey;   ValueType: string;  ValueName: "";
 Root: HKCR; Subkey: "{#MyAppName}worlddata\DefaultIcon";        ValueData: "{app}\ArchipelagoLauncher.exe,0";                 ValueType: string;  ValueName: "";
-Root: HKCR; Subkey: "{#MyAppName}worlddata\shell\open\command"; ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";
+Root: HKCR; Subkey: "{#MyAppName}worlddata\shell\open\command"; ValueData: """{app}\ArchipelagoLauncher.exe"" ""%1""";        ValueType: string;  ValueName: "";
 
 Root: HKCR; Subkey: "archipelago"; ValueType: "string"; ValueData: "Archipegalo Protocol"; Flags: uninsdeletekey;
 Root: HKCR; Subkey: "archipelago"; ValueType: "string"; ValueName: "URL Protocol"; ValueData: "";

intset.h

@@ -0,0 +1,135 @@
+/* A specialized unordered_set implementation for literals, where bucket_count
+ * is defined at initialization rather than increased automatically.
+ */
+#include <stddef.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef INTSET_NAME
+#error "Please #define INTSET_NAME ... before including intset.h"
+#endif
+
+#ifndef INTSET_TYPE
+#error "Please #define INTSET_TYPE ... before including intset.h"
+#endif
+
+/* macros to generate unique names from INTSET_NAME */
+#ifndef INTSET_CONCAT
+#define INTSET_CONCAT_(a, b) a ## b
+#define INTSET_CONCAT(a, b) INTSET_CONCAT_(a, b)
+#define INTSET_FUNC_(a, b) INTSET_CONCAT(a, _ ## b)
+#endif
+
+#define INTSET_FUNC(name) INTSET_FUNC_(INTSET_NAME, name)
+#define INTSET_BUCKET INTSET_CONCAT(INTSET_NAME, Bucket)
+#define INTSET_UNION INTSET_CONCAT(INTSET_NAME, Union)
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4200)
+#endif
+
+
+typedef struct {
+    size_t count;
+    union INTSET_UNION {
+        INTSET_TYPE val;
+        INTSET_TYPE *data;
+    } v;
+} INTSET_BUCKET;
+
+typedef struct {
+    size_t bucket_count;
+    INTSET_BUCKET buckets[];
+} INTSET_NAME;
+
+static INTSET_NAME *INTSET_FUNC(new)(size_t buckets)
+{
+    size_t i, size;
+    INTSET_NAME *set;
+
+    if (buckets < 1)
+        buckets = 1;
+    if ((SIZE_MAX - sizeof(INTSET_NAME)) / sizeof(INTSET_BUCKET) < buckets)
+        return NULL;
+    size = sizeof(INTSET_NAME) + buckets * sizeof(INTSET_BUCKET);
+    set = (INTSET_NAME*)malloc(size);
+    if (!set)
+        return NULL;
+    memset(set, 0, size); /* gcc -fanalyzer does not understand this sets all buckets' count to 0 */
+    for (i = 0; i < buckets; i++) {
+        set->buckets[i].count = 0;
+    }
+    set->bucket_count = buckets;
+    return set;
+}
+
+static void INTSET_FUNC(free)(INTSET_NAME *set)
+{
+    size_t i;
+    if (!set)
+        return;
+    for (i = 0; i < set->bucket_count; i++) {
+        if (set->buckets[i].count > 1)
+            free(set->buckets[i].v.data);
+    }
+    free(set);
+}
+
+static bool INTSET_FUNC(contains)(INTSET_NAME *set, INTSET_TYPE val)
+{
+    size_t i;
+    INTSET_BUCKET* bucket = &set->buckets[(size_t)val % set->bucket_count];
+    if (bucket->count == 1)
+        return bucket->v.val == val;
+    for (i = 0; i < bucket->count; ++i) {
+        if (bucket->v.data[i] == val)
+            return true;
+    }
+    return false;
+}
+
+static bool INTSET_FUNC(add)(INTSET_NAME *set, INTSET_TYPE val)
+{
+    INTSET_BUCKET* bucket;
+
+    if (INTSET_FUNC(contains)(set, val))
+        return true; /* ok */
+
+    bucket = &set->buckets[(size_t)val % set->bucket_count];
+    if (bucket->count == 0) {
+        bucket->v.val = val;
+        bucket->count = 1;
+    } else if (bucket->count == 1) {
+        INTSET_TYPE old = bucket->v.val;
+        bucket->v.data = (INTSET_TYPE*)malloc(2 * sizeof(INTSET_TYPE));
+        if (!bucket->v.data) {
+            bucket->v.val = old;
+            return false; /* error */
+        }
+        bucket->v.data[0] = old;
+        bucket->v.data[1] = val;
+        bucket->count = 2;
+    } else {
+        size_t new_bucket_size;
+        INTSET_TYPE* new_bucket_data;
+
+        new_bucket_size = (bucket->count + 1) * sizeof(INTSET_TYPE);
+        new_bucket_data = (INTSET_TYPE*)realloc(bucket->v.data, new_bucket_size);
+        if (!new_bucket_data)
+            return false; /* error */
+        bucket->v.data = new_bucket_data;
+        bucket->v.data[bucket->count++] = val;
+    }
+    return true; /* success */
+}
+
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#undef INTSET_FUNC
+#undef INTSET_BUCKET
+#undef INTSET_UNION

kvui.py

@@ -3,6 +3,9 @@ import logging
 import sys
 import typing
 import re
+from collections import deque
+
+assert "kivy" not in sys.modules, "kvui should be imported before kivy for frozen compatibility"
 
 if sys.platform == "win32":
     import ctypes
@@ -380,6 +383,57 @@ class ConnectBarTextInput(TextInput):
         return super(ConnectBarTextInput, self).insert_text(s, from_undo=from_undo)
 
 
+def is_command_input(string: str) -> bool:
+    return len(string) > 0 and string[0] in "/!"
+
+
+class CommandPromptTextInput(TextInput):
+    MAXIMUM_HISTORY_MESSAGES = 50
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._command_history_index = -1
+        self._command_history: typing.Deque[str] = deque(maxlen=CommandPromptTextInput.MAXIMUM_HISTORY_MESSAGES)
+    
+    def update_history(self, new_entry: str) -> None:
+        self._command_history_index = -1
+        if is_command_input(new_entry):
+            self._command_history.appendleft(new_entry)
+
+    def keyboard_on_key_down(
+        self,
+        window,
+        keycode: typing.Tuple[int, str],
+        text: typing.Optional[str],
+        modifiers: typing.List[str]
+    ) -> bool:
+        """
+        :param window: The kivy window object
+        :param keycode: A tuple of (keycode, keyname). Keynames are always lowercase
+        :param text: The text printed by this key, not accounting for modifiers, or `None` if no text.
+                     Seems to pretty naively interpret the keycode as unicode, so numlock can return odd characters.
+        :param modifiers: A list of string modifiers, like `ctrl` or `numlock`
+        """
+        if keycode[1] == 'up':
+            self._change_to_history_text_if_available(self._command_history_index + 1)
+            return True
+        if keycode[1] == 'down':
+            self._change_to_history_text_if_available(self._command_history_index - 1)
+            return True
+        return super().keyboard_on_key_down(window, keycode, text, modifiers)
+    
+    def _change_to_history_text_if_available(self, new_index: int) -> None:
+        if new_index < -1:
+            return
+        if new_index >= len(self._command_history):
+            return
+        self._command_history_index = new_index
+        if new_index == -1:
+            self.text = ""
+            return
+        self.text = self._command_history[self._command_history_index]
+
+
 class MessageBox(Popup):
     class MessageBoxLabel(Label):
         def __init__(self, **kwargs):
@@ -415,7 +469,7 @@ class GameManager(App):
         self.commandprocessor = ctx.command_processor(ctx)
         self.icon = r"data/icon.png"
         self.json_to_kivy_parser = KivyJSONtoTextParser(ctx)
-        self.log_panels = {}
+        self.log_panels: typing.Dict[str, Widget] = {}
 
         # keep track of last used command to autofill on click
         self.last_autofillable_command = "hint"
@@ -499,7 +553,7 @@ class GameManager(App):
         info_button = Button(size=(dp(100), dp(30)), text="Command:", size_hint_x=None)
         info_button.bind(on_release=self.command_button_action)
         bottom_layout.add_widget(info_button)
-        self.textinput = TextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
+        self.textinput = CommandPromptTextInput(size_hint_y=None, height=dp(30), multiline=False, write_tab=False)
         self.textinput.bind(on_text_validate=self.on_message)
         self.textinput.text_validate_unfocus = False
         bottom_layout.add_widget(self.textinput)
@@ -543,8 +597,9 @@ class GameManager(App):
                                              "!help for server commands.")
 
     def connect_button_action(self, button):
+        self.ctx.username = None
+        self.ctx.password = None
         if self.ctx.server:
-            self.ctx.username = None
             async_start(self.ctx.disconnect())
         else:
             async_start(self.ctx.connect(self.server_connect_bar.text.replace("/connect ", "")))
@@ -557,14 +612,18 @@ class GameManager(App):
 
         self.ctx.exit_event.set()
 
-    def on_message(self, textinput: TextInput):
+    def on_message(self, textinput: CommandPromptTextInput):
         try:
             input_text = textinput.text.strip()
             textinput.text = ""
+            textinput.update_history(input_text)
 
             if self.ctx.input_requests > 0:
                 self.ctx.input_requests -= 1
                 self.ctx.input_queue.put_nowait(input_text)
+            elif is_command_input(input_text):
+                self.ctx.on_ui_command(input_text)
+                self.commandprocessor(input_text)
             elif input_text:
                 self.commandprocessor(input_text)
 
@@ -780,6 +839,10 @@ class KivyJSONtoTextParser(JSONtoTextParser):
         return self._handle_text(node)
 
     def _handle_text(self, node: JSONMessagePart):
+        # All other text goes through _handle_color, and we don't want to escape markup twice,
+        # or mess up text that already has intentional markup applied to it
+        if node.get("type", "text") == "text":
+            node["text"] = escape_markup(node["text"])
         for ref in node.get("refs", []):
             node["text"] = f"[ref={self.ref_count}|{ref}]{node['text']}[/ref]"
             self.ref_count += 1

requirements.txt

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

settings.py

@@ -3,6 +3,7 @@ Application settings / host.yaml interface using type hints.
 This is different from player options.
 """
 
+import os
 import os.path
 import shutil
 import sys
@@ -11,7 +12,6 @@ import warnings
 from enum import IntEnum
 from threading import Lock
 from typing import cast, Any, BinaryIO, ClassVar, Dict, Iterator, List, Optional, TextIO, Tuple, Union, TypeVar
-import os
 
 __all__ = [
     "get_settings", "fmt_doc", "no_gui",
@@ -798,6 +798,7 @@ class Settings(Group):
             atexit.register(autosave)
 
     def save(self, location: Optional[str] = None) -> None:  # as above
+        from Utils import parse_yaml
         location = location or self._filename
         assert location, "No file specified"
         temp_location = location + ".tmp"  # not using tempfile to test expected file access
@@ -807,10 +808,18 @@ class Settings(Group):
         # can't use utf-8-sig because it breaks backward compat: pyyaml on Windows with bytes does not strip the BOM
         with open(temp_location, "w", encoding="utf-8") as f:
             self.dump(f)
-        # replace old with new
-        if os.path.exists(location):
+            f.flush()
+            if hasattr(os, "fsync"):
+                os.fsync(f.fileno())
+        # validate new file is valid yaml
+        with open(temp_location, encoding="utf-8") as f:
+            parse_yaml(f.read())
+        # replace old with new, try atomic operation first
+        try:
+            os.rename(temp_location, location)
+        except (OSError, FileExistsError):
             os.unlink(location)
-        os.rename(temp_location, location)
+            os.rename(temp_location, location)
         self._filename = location
 
     def dump(self, f: TextIO, level: int = 0) -> None:
@@ -832,7 +841,6 @@ def get_settings() -> Settings:
     with _lock:  # make sure we only have one instance
         res = getattr(get_settings, "_cache", None)
         if not res:
-            import os
             from Utils import user_path, local_path
             filenames = ("options.yaml", "host.yaml")
             locations: List[str] = []

setup.py

@@ -21,7 +21,7 @@ from pathlib import Path
 
 # This is a bit jank. We need cx-Freeze to be able to run anything from this script, so install it
 try:
-    requirement = 'cx-Freeze==7.0.0'
+    requirement = 'cx-Freeze==7.2.0'
     import pkg_resources
     try:
         pkg_resources.require(requirement)
@@ -66,7 +66,6 @@ non_apworlds: set = {
     "Adventure",
     "ArchipIDLE",
     "Archipelago",
-    "ChecksFinder",
     "Clique",
     "Final Fantasy",
     "Lufia II Ancient Cave",

test/bases.py

@@ -23,8 +23,8 @@ class TestBase(unittest.TestCase):
         state = CollectionState(self.multiworld)
         for item in items:
             item.classification = ItemClassification.progression
-            state.collect(item, event=True)
-        state.sweep_for_events()
+            state.collect(item, prevent_sweep=True)
+        state.sweep_for_advancements()
         state.update_reachable_regions(1)
         self._state_cache[self.multiworld, tuple(items)] = state
         return state
@@ -221,8 +221,8 @@ class WorldTestBase(unittest.TestCase):
         if isinstance(items, Item):
             items = (items,)
         for item in items:
-            if item.location and item.advancement and item.location in self.multiworld.state.events:
-                self.multiworld.state.events.remove(item.location)
+            if item.location and item.advancement and item.location in self.multiworld.state.advancements:
+                self.multiworld.state.advancements.remove(item.location)
             self.multiworld.state.remove(item)
 
     def can_reach_location(self, location: str) -> bool:
@@ -292,14 +292,12 @@ class WorldTestBase(unittest.TestCase):
         """Ensure all state can reach everything and complete the game with the defined options"""
         if not (self.run_default_tests and self.constructed):
             return
-        with self.subTest("Game", game=self.game):
-            excluded = self.multiworld.worlds[self.player].options.exclude_locations.value
+        with self.subTest("Game", game=self.game, seed=self.multiworld.seed):
             state = self.multiworld.get_all_state(False)
             for location in self.multiworld.get_locations():
-                if location.name not in excluded:
-                    with self.subTest("Location should be reached", location=location):
-                        reachable = location.can_reach(state)
-                        self.assertTrue(reachable, f"{location.name} unreachable")
+                with self.subTest("Location should be reached", location=location.name):
+                    reachable = location.can_reach(state)
+                    self.assertTrue(reachable, f"{location.name} unreachable")
             with self.subTest("Beatable"):
                 self.multiworld.state = state
                 self.assertBeatable(True)
@@ -308,7 +306,7 @@ class WorldTestBase(unittest.TestCase):
         """Ensure empty state can reach at least one location with the defined options"""
         if not (self.run_default_tests and self.constructed):
             return
-        with self.subTest("Game", game=self.game):
+        with self.subTest("Game", game=self.game, seed=self.multiworld.seed):
             state = CollectionState(self.multiworld)
             locations = self.multiworld.get_reachable_locations(state, self.player)
             self.assertGreater(len(locations), 0,
@@ -329,7 +327,7 @@ class WorldTestBase(unittest.TestCase):
                 for n in range(len(locations) - 1, -1, -1):
                     if locations[n].can_reach(state):
                         sphere.append(locations.pop(n))
-                self.assertTrue(sphere or self.multiworld.accessibility[1] == "minimal",
+                self.assertTrue(sphere or self.multiworld.worlds[1].options.accessibility == "minimal",
                                 f"Unreachable locations: {locations}")
                 if not sphere:
                     break

test/cpp/CMakeLists.txt

@@ -0,0 +1,49 @@
+cmake_minimum_required(VERSION 3.5)
+project(ap-cpp-tests)
+
+enable_testing()
+
+find_package(GTest REQUIRED)
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    add_definitions("/source-charset:utf-8")
+    set(CMAKE_CXX_FLAGS_DEBUG "/MTd")
+    set(CMAKE_CXX_FLAGS_RELEASE "/MT")
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # enable static analysis for gcc
+    add_compile_options(-fanalyzer -Werror)
+    # disable stuff that gets triggered by googletest
+    add_compile_options(-Wno-analyzer-malloc-leak)
+    # enable asan for gcc
+    add_compile_options(-fsanitize=address)
+    add_link_options(-fsanitize=address)
+endif ()
+
+add_executable(test_default)
+
+target_include_directories(test_default
+        PRIVATE
+        ${GTEST_INCLUDE_DIRS}
+)
+
+target_link_libraries(test_default
+        ${GTEST_BOTH_LIBRARIES}
+)
+
+add_test(
+        NAME test_default
+        COMMAND  test_default
+)
+
+set_property(
+        TEST test_default
+        PROPERTY ENVIRONMENT "ASAN_OPTIONS=allocator_may_return_null=1"
+)
+
+file(GLOB ITEMS *)
+foreach(item ${ITEMS})
+    if(IS_DIRECTORY ${item} AND EXISTS ${item}/CMakeLists.txt)
+        message(${item})
+        add_subdirectory(${item})
+    endif()
+endforeach()

test/cpp/README.md

@@ -0,0 +1,32 @@
+# C++ tests
+
+Test framework for C and C++ code in AP.
+
+## Adding a Test
+
+### GoogleTest
+
+Adding GoogleTests is as simple as creating a directory with
+* one or more `test_*.cpp` files that define tests using
+  [GoogleTest API](https://google.github.io/googletest/)
+* a `CMakeLists.txt` that adds the .cpp files to `test_default` target using
+  [target_sources](https://cmake.org/cmake/help/latest/command/target_sources.html)
+
+### CTest
+
+If either GoogleTest is not suitable for the test or the build flags / sources / libraries are incompatible,
+you can add another CTest to the project using add_target and add_test, similar to how it's done for `test_default`.
+
+## Running Tests
+
+* Install [CMake](https://cmake.org/).
+* Build and/or install GoogleTest and make sure
+  [CMake can find it](https://cmake.org/cmake/help/latest/module/FindGTest.html), or
+  [create a parent `CMakeLists.txt` that fetches GoogleTest](https://google.github.io/googletest/quickstart-cmake.html).
+* Enter the directory with the top-most `CMakeLists.txt` and run
+  ```sh
+  mkdir build
+  cmake -S . -B build/ -DCMAKE_BUILD_TYPE=Release
+  cmake --build build/ --config Release && \
+  ctest --test-dir build/ -C Release --output-on-failure
+  ```

test/cpp/intset/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(test_default
+        PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/test_intset.cpp
+)

test/cpp/intset/test_intset.cpp

@@ -0,0 +1,105 @@
+#include <limits>
+#include <cstdint>
+#include <gtest/gtest.h>
+
+// uint32Set
+#define INTSET_NAME uint32Set
+#define INTSET_TYPE uint32_t
+#include "../../../intset.h"
+#undef INTSET_NAME
+#undef INTSET_TYPE
+
+// int64Set
+#define INTSET_NAME int64Set
+#define INTSET_TYPE int64_t
+#include "../../../intset.h"
+
+
+TEST(IntsetTest, ZeroBuckets)
+{
+    // trying to allocate with zero buckets has to either fail or be functioning
+    uint32Set *set = uint32Set_new(0);
+    if (!set)
+        return; // failed -> OK
+
+    EXPECT_FALSE(uint32Set_contains(set, 1));
+    EXPECT_TRUE(uint32Set_add(set, 1));
+    EXPECT_TRUE(uint32Set_contains(set, 1));
+    uint32Set_free(set);
+}
+
+TEST(IntsetTest, Duplicate)
+{
+    // adding the same number again can't fail
+    uint32Set *set = uint32Set_new(2);
+    ASSERT_TRUE(set);
+    EXPECT_TRUE(uint32Set_add(set, 0));
+    EXPECT_TRUE(uint32Set_add(set, 0));
+    EXPECT_TRUE(uint32Set_contains(set, 0));
+    uint32Set_free(set);
+}
+
+TEST(IntsetTest, SetAllocFailure)
+{
+    // try to allocate 100TB of RAM, should fail and return NULL
+    if (sizeof(size_t) < 8)
+        GTEST_SKIP() << "Alloc error not testable on 32bit";
+    int64Set *set = int64Set_new(6250000000000ULL);
+    EXPECT_FALSE(set);
+    int64Set_free(set);
+}
+
+TEST(IntsetTest, SetAllocOverflow)
+{
+    // try to overflow argument passed to malloc
+    int64Set *set = int64Set_new(std::numeric_limits<size_t>::max());
+    EXPECT_FALSE(set);
+    int64Set_free(set);
+}
+
+TEST(IntsetTest, NullFree)
+{
+    // free(NULL) should not try to free buckets
+    uint32Set_free(NULL);
+    int64Set_free(NULL);
+}
+
+TEST(IntsetTest, BucketRealloc)
+{
+    // add a couple of values to the same bucket to test growing the bucket
+    uint32Set* set = uint32Set_new(1);
+    ASSERT_TRUE(set);
+    EXPECT_FALSE(uint32Set_contains(set, 0));
+    EXPECT_TRUE(uint32Set_add(set, 0));
+    EXPECT_TRUE(uint32Set_contains(set, 0));
+    for (uint32_t i = 1; i < 32; ++i) {
+        EXPECT_TRUE(uint32Set_add(set, i));
+        EXPECT_TRUE(uint32Set_contains(set, i - 1));
+        EXPECT_TRUE(uint32Set_contains(set, i));
+        EXPECT_FALSE(uint32Set_contains(set, i + 1));
+    }
+    uint32Set_free(set);
+}
+
+TEST(IntSet, Max)
+{
+    constexpr auto n = std::numeric_limits<uint32_t>::max();
+    uint32Set *set = uint32Set_new(1);
+    ASSERT_TRUE(set);
+    EXPECT_FALSE(uint32Set_contains(set, n));
+    EXPECT_TRUE(uint32Set_add(set, n));
+    EXPECT_TRUE(uint32Set_contains(set, n));
+    uint32Set_free(set);
+}
+
+TEST(InsetTest, Negative)
+{
+    constexpr auto n = std::numeric_limits<int64_t>::min();
+    static_assert(n < 0, "n not negative");
+    int64Set *set = int64Set_new(3);
+    ASSERT_TRUE(set);
+    EXPECT_FALSE(int64Set_contains(set, n));
+    EXPECT_TRUE(int64Set_add(set, n));
+    EXPECT_TRUE(int64Set_contains(set, n));
+    int64Set_free(set);
+}

test/general/__init__.py

@@ -2,6 +2,7 @@ from argparse import Namespace
 from typing import List, Optional, Tuple, Type, Union
 
 from BaseClasses import CollectionState, Item, ItemClassification, Location, MultiWorld, Region
+from worlds import network_data_package
 from worlds.AutoWorld import World, call_all
 
 gen_steps = ("generate_early", "create_regions", "create_items", "set_rules", "generate_basic", "pre_fill")
@@ -60,6 +61,10 @@ class TestWorld(World):
     hidden = True
 
 
+# add our test world to the data package, so we can test it later
+network_data_package["games"][TestWorld.game] = TestWorld.get_data_package_data()
+
+
 def generate_test_multiworld(players: int = 1) -> MultiWorld:
     """
     Generates a multiworld using a special Test Case World class, and seed of 0.

test/general/test_fill.py

@@ -174,8 +174,8 @@ class TestFillRestrictive(unittest.TestCase):
         player1 = generate_player_data(multiworld, 1, 3, 3)
         player2 = generate_player_data(multiworld, 2, 3, 3)
 
-        multiworld.accessibility[player1.id].value = multiworld.accessibility[player1.id].option_minimal
-        multiworld.accessibility[player2.id].value = multiworld.accessibility[player2.id].option_locations
+        multiworld.worlds[player1.id].options.accessibility.value = Accessibility.option_minimal
+        multiworld.worlds[player2.id].options.accessibility.value = Accessibility.option_full
 
         multiworld.completion_condition[player1.id] = lambda state: True
         multiworld.completion_condition[player2.id] = lambda state: state.has(player2.prog_items[2].name, player2.id)
@@ -192,7 +192,7 @@ class TestFillRestrictive(unittest.TestCase):
         location_pool = player1.locations[1:] + player2.locations
         item_pool = player1.prog_items[:-1] + player2.prog_items
         fill_restrictive(multiworld, multiworld.state, location_pool, item_pool)
-        multiworld.state.sweep_for_events()  # collect everything
+        multiworld.state.sweep_for_advancements()  # collect everything
 
         # all of player2's locations and items should be accessible (not all of player1's)
         for item in player2.prog_items:
@@ -443,8 +443,8 @@ class TestFillRestrictive(unittest.TestCase):
         item = player1.prog_items[0]
         item.code = None
         location.place_locked_item(item)
-        multiworld.state.sweep_for_events()
-        multiworld.state.sweep_for_events()
+        multiworld.state.sweep_for_advancements()
+        multiworld.state.sweep_for_advancements()
         self.assertTrue(multiworld.state.prog_items[item.player][item.name], "Sweep did not collect - Test flawed")
         self.assertEqual(multiworld.state.prog_items[item.player][item.name], 1, "Sweep collected multiple times")
 

test/general/test_host_yaml.py

@@ -1,11 +1,12 @@
 import os
+import os.path
 import unittest
 from io import StringIO
-from tempfile import TemporaryFile
+from tempfile import TemporaryDirectory, TemporaryFile
 from typing import Any, Dict, List, cast
 
 import Utils
-from settings import Settings, Group
+from settings import Group, Settings, ServerOptions
 
 
 class TestIDs(unittest.TestCase):
@@ -80,3 +81,27 @@ class TestSettingsDumper(unittest.TestCase):
                 self.assertEqual(value_spaces[2], value_spaces[0])  # start of sub-list
                 self.assertGreater(value_spaces[3], value_spaces[0],
                                    f"{value_lines[3]} should have more indentation than {value_lines[0]} in {lines}")
+
+
+class TestSettingsSave(unittest.TestCase):
+    def test_save(self) -> None:
+        """Test that saving and updating works"""
+        with TemporaryDirectory() as d:
+            filename = os.path.join(d, "host.yaml")
+            new_release_mode = ServerOptions.ReleaseMode("enabled")
+            # create default host.yaml
+            settings = Settings(None)
+            settings.save(filename)
+            self.assertTrue(os.path.exists(filename),
+                            "Default settings could not be saved")
+            self.assertNotEqual(settings.server_options.release_mode, new_release_mode,
+                                "Unexpected default release mode")
+            # update host.yaml
+            settings.server_options.release_mode = new_release_mode
+            settings.save(filename)
+            self.assertFalse(os.path.exists(filename + ".tmp"),
+                             "Temp file was not removed during save")
+            # read back host.yaml
+            settings = Settings(filename)
+            self.assertEqual(settings.server_options.release_mode, new_release_mode,
+                             "Settings were not overwritten")

test/general/test_ids.py

@@ -1,6 +1,7 @@
 import unittest
 
 from Fill import distribute_items_restrictive
+from worlds import network_data_package
 from worlds.AutoWorld import AutoWorldRegister, call_all
 from . import setup_solo_multiworld
 
@@ -84,3 +85,4 @@ class TestIDs(unittest.TestCase):
                                           f"{loc_name} is not a valid item name for location_name_to_id")
                     self.assertIsInstance(loc_id, int,
                                           f"{loc_id} for {loc_name} should be an int")
+                self.assertEqual(datapackage["checksum"], network_data_package["games"][gamename]["checksum"])

test/general/test_options.py

@@ -1,6 +1,6 @@
 import unittest
 
-from BaseClasses import PlandoOptions
+from BaseClasses import MultiWorld, PlandoOptions
 from Options import ItemLinks
 from worlds.AutoWorld import AutoWorldRegister
 
@@ -47,3 +47,15 @@ class TestOptions(unittest.TestCase):
             self.assertIn("Bow", link.value[0]["item_pool"])
         
         # TODO test that the group created using these options has the items
+
+    def test_item_links_resolve(self):
+        """Test item link option resolves correctly."""
+        item_link_group = [{
+            "name": "ItemLinkTest",
+            "item_pool": ["Everything"],
+            "link_replacement": False,
+            "replacement_item": None,
+        }]
+        item_links = {1: ItemLinks.from_any(item_link_group), 2: ItemLinks.from_any(item_link_group)}
+        for link in item_links.values():
+            self.assertEqual(link.value[0], item_link_group[0])

test/general/test_reachability.py

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

test/hosting/generate.py

@@ -26,6 +26,7 @@ def _generate_local_inner(games: Iterable[str],
         with TemporaryDirectory() as players_dir:
             with TemporaryDirectory() as output_dir:
                 import Generate
+                import Main
 
                 for n, game in enumerate(games, 1):
                     player_path = Path(players_dir) / f"{n}.yaml"
@@ -42,7 +43,7 @@ def _generate_local_inner(games: Iterable[str],
                 sys.argv = [sys.argv[0], "--seed", str(hash(tuple(games))),
                             "--player_files_path", players_dir,
                             "--outputpath", output_dir]
-                Generate.main()
+                Main.main(*Generate.main())
                 output_files = list(Path(output_dir).glob('*.zip'))
                 assert len(output_files) == 1
                 final_file = dest / output_files[0].name

test/hosting/webhost.py

@@ -66,12 +66,19 @@ def create_room(app_client: "FlaskClient", seed: str, auto_start: bool = False)
 def start_room(app_client: "FlaskClient", room_id: str, timeout: float = 30) -> str:
     from time import sleep
 
+    import pony.orm
+
     poll_interval = .2
 
     print(f"Starting room {room_id}")
     no_timeout = timeout <= 0
     while no_timeout or timeout > 0:
-        response = app_client.get(f"/room/{room_id}")
+        try:
+            response = app_client.get(f"/room/{room_id}")
+        except pony.orm.core.OptimisticCheckError:
+            # hoster wrote to room during our transaction
+            continue
+
         assert response.status_code == 200, f"Starting room for {room_id} failed: status {response.status_code}"
         match = re.search(r"/connect ([\w:.\-]+)", response.text)
         if match:

test/multiworld/test_multiworlds.py

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

test/netutils/test_location_store.py

@@ -1,4 +1,5 @@
 # Tests for _speedups.LocationStore and NetUtils._LocationStore
+import os
 import typing
 import unittest
 import warnings
@@ -7,6 +8,8 @@ from NetUtils import LocationStore, _LocationStore
 State = typing.Dict[typing.Tuple[int, int], typing.Set[int]]
 RawLocations = typing.Dict[int, typing.Dict[int, typing.Tuple[int, int, int]]]
 
+ci = bool(os.environ.get("CI"))  # always set in GitHub actions
+
 sample_data: RawLocations = {
     1: {
         11: (21, 2, 7),
@@ -24,6 +27,9 @@ sample_data: RawLocations = {
     3: {
         9: (99, 4, 0),
     },
+    5: {
+        9: (99, 5, 0),
+    }
 }
 
 empty_state: State = {
@@ -45,14 +51,14 @@ class Base:
         store: typing.Union[LocationStore, _LocationStore]
 
         def test_len(self) -> None:
-            self.assertEqual(len(self.store), 4)
+            self.assertEqual(len(self.store), 5)
             self.assertEqual(len(self.store[1]), 3)
 
         def test_key_error(self) -> None:
             with self.assertRaises(KeyError):
                 _ = self.store[0]
             with self.assertRaises(KeyError):
-                _ = self.store[5]
+                _ = self.store[6]
             locations = self.store[1]  # no Exception
             with self.assertRaises(KeyError):
                 _ = locations[7]
@@ -71,7 +77,7 @@ class Base:
             self.assertEqual(self.store[1].get(10, (None, None, None)), (None, None, None))
 
         def test_iter(self) -> None:
-            self.assertEqual(sorted(self.store), [1, 2, 3, 4])
+            self.assertEqual(sorted(self.store), [1, 2, 3, 4, 5])
             self.assertEqual(len(self.store), len(sample_data))
             self.assertEqual(list(self.store[1]), [11, 12, 13])
             self.assertEqual(len(self.store[1]), len(sample_data[1]))
@@ -85,13 +91,26 @@ class Base:
             self.assertEqual(sorted(self.store[1].items())[0][1], self.store[1][11])
 
         def test_find_item(self) -> None:
+            # empty player set
             self.assertEqual(sorted(self.store.find_item(set(), 99)), [])
+            # no such player, single
+            self.assertEqual(sorted(self.store.find_item({6}, 99)), [])
+            # no such player, set
+            self.assertEqual(sorted(self.store.find_item({7, 8, 9}, 99)), [])
+            # no such item
             self.assertEqual(sorted(self.store.find_item({3}, 1)), [])
-            self.assertEqual(sorted(self.store.find_item({5}, 99)), [])
+            # valid matches
             self.assertEqual(sorted(self.store.find_item({3}, 99)),
                              [(4, 9, 99, 3, 0)])
             self.assertEqual(sorted(self.store.find_item({3, 4}, 99)),
                              [(3, 9, 99, 4, 0), (4, 9, 99, 3, 0)])
+            self.assertEqual(sorted(self.store.find_item({2, 3, 4}, 99)),
+                             [(3, 9, 99, 4, 0), (4, 9, 99, 3, 0)])
+            # test hash collision in set
+            self.assertEqual(sorted(self.store.find_item({3, 5}, 99)),
+                             [(4, 9, 99, 3, 0), (5, 9, 99, 5, 0)])
+            self.assertEqual(sorted(self.store.find_item(set(range(2048)), 13)),
+                             [(1, 13, 13, 1, 0)])
 
         def test_get_for_player(self) -> None:
             self.assertEqual(self.store.get_for_player(3), {4: {9}})
@@ -111,9 +130,9 @@ class Base:
 
         def test_get_remaining(self) -> None:
             self.assertEqual(self.store.get_remaining(full_state, 0, 1), [])
-            self.assertEqual(self.store.get_remaining(one_state, 0, 1), [13, 21])
-            self.assertEqual(self.store.get_remaining(empty_state, 0, 1), [13, 21, 22])
-            self.assertEqual(self.store.get_remaining(empty_state, 0, 3), [99])
+            self.assertEqual(self.store.get_remaining(one_state, 0, 1), [(1, 13), (2, 21)])
+            self.assertEqual(self.store.get_remaining(empty_state, 0, 1), [(1, 13), (2, 21), (2, 22)])
+            self.assertEqual(self.store.get_remaining(empty_state, 0, 3), [(4, 99)])
 
         def test_location_set_intersection(self) -> None:
             locations = {10, 11, 12}
@@ -196,18 +215,20 @@ class TestPurePythonLocationStoreConstructor(Base.TestLocationStoreConstructor):
         super().setUp()
 
 
-@unittest.skipIf(LocationStore is _LocationStore, "_speedups not available")
+@unittest.skipIf(LocationStore is _LocationStore and not ci, "_speedups not available")
 class TestSpeedupsLocationStore(Base.TestLocationStore):
     """Run base method tests for cython implementation."""
     def setUp(self) -> None:
+        self.assertFalse(LocationStore is _LocationStore, "Failed to load _speedups")
         self.store = LocationStore(sample_data)
         super().setUp()
 
 
-@unittest.skipIf(LocationStore is _LocationStore, "_speedups not available")
+@unittest.skipIf(LocationStore is _LocationStore and not ci, "_speedups not available")
 class TestSpeedupsLocationStoreConstructor(Base.TestLocationStoreConstructor):
     """Run base constructor tests and tests the additional constraints for cython implementation."""
     def setUp(self) -> None:
+        self.assertFalse(LocationStore is _LocationStore, "Failed to load _speedups")
         self.type = LocationStore
         super().setUp()
 

test/programs/test_generate.py

@@ -9,6 +9,7 @@ from pathlib import Path
 from tempfile import TemporaryDirectory
 
 import Generate
+import Main
 
 
 class TestGenerateMain(unittest.TestCase):
@@ -58,7 +59,7 @@ class TestGenerateMain(unittest.TestCase):
                     '--player_files_path', str(self.abs_input_dir),
                     '--outputpath', self.output_tempdir.name]
         print(f'Testing Generate.py {sys.argv} in {os.getcwd()}')
-        Generate.main()
+        Main.main(*Generate.main())
 
         self.assertOutput(self.output_tempdir.name)
 
@@ -67,7 +68,7 @@ class TestGenerateMain(unittest.TestCase):
                     '--player_files_path', str(self.rel_input_dir),
                     '--outputpath', self.output_tempdir.name]
         print(f'Testing Generate.py {sys.argv} in {os.getcwd()}')
-        Generate.main()
+        Main.main(*Generate.main())
 
         self.assertOutput(self.output_tempdir.name)
 
@@ -86,7 +87,7 @@ class TestGenerateMain(unittest.TestCase):
             sys.argv = [sys.argv[0], '--seed', '0',
                         '--outputpath', self.output_tempdir.name]
             print(f'Testing Generate.py {sys.argv} in {os.getcwd()}, player_files_path={self.yaml_input_dir}')
-            Generate.main()
+            Main.main(*Generate.main())
         finally:
             user_path.cached_path = user_path_backup
 

test/webhost/__init__.py

@@ -0,0 +1,36 @@
+import unittest
+import typing
+from uuid import uuid4
+
+from flask import Flask
+from flask.testing import FlaskClient
+
+
+class TestBase(unittest.TestCase):
+    app: typing.ClassVar[Flask]
+    client: FlaskClient
+
+    @classmethod
+    def setUpClass(cls) -> None:
+        from WebHostLib import app as raw_app
+        from WebHost import get_app
+
+        raw_app.config["PONY"] = {
+            "provider": "sqlite",
+            "filename": ":memory:",
+            "create_db": True,
+        }
+        raw_app.config.update({
+            "TESTING": True,
+            "DEBUG": True,
+        })
+        try:
+            cls.app = get_app()
+        except AssertionError as e:
+            # since we only have 1 global app object, this might fail, but luckily all tests use the same config
+            if "register_blueprint" not in e.args[0]:
+                raise
+            cls.app = raw_app
+
+    def setUp(self) -> None:
+        self.client = self.app.test_client()

test/webhost/test_api_generate.py

@@ -1,31 +1,16 @@
 import io
-import unittest
 import json
 import yaml
 
+from . import TestBase
 
-class TestDocs(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls) -> None:
-        from WebHostLib import app as raw_app
-        from WebHost import get_app
-        raw_app.config["PONY"] = {
-            "provider": "sqlite",
-            "filename": ":memory:",
-            "create_db": True,
-        }
-        raw_app.config.update({
-            "TESTING": True,
-        })
-        app = get_app()
 
-        cls.client = app.test_client()
-
-    def test_correct_error_empty_request(self):
+class TestAPIGenerate(TestBase):
+    def test_correct_error_empty_request(self) -> None:
         response = self.client.post("/api/generate")
         self.assertIn("No options found. Expected file attachment or json weights.", response.text)
 
-    def test_generation_queued_weights(self):
+    def test_generation_queued_weights(self) -> None:
         options = {
             "Tester1":
                 {
@@ -43,7 +28,7 @@ class TestDocs(unittest.TestCase):
         self.assertTrue(json_data["text"].startswith("Generation of seed "))
         self.assertTrue(json_data["text"].endswith(" started successfully."))
 
-    def test_generation_queued_file(self):
+    def test_generation_queued_file(self) -> None:
         options = {
             "game": "Archipelago",
             "name": "Tester",

test/webhost/test_host_room.py

@@ -0,0 +1,192 @@
+import os
+from uuid import UUID, uuid4, uuid5
+
+from flask import url_for
+
+from . import TestBase
+
+
+class TestHostFakeRoom(TestBase):
+    room_id: UUID
+    log_filename: str
+
+    def setUp(self) -> None:
+        from pony.orm import db_session
+        from Utils import user_path
+        from WebHostLib.models import Room, Seed
+
+        super().setUp()
+
+        with self.client.session_transaction() as session:
+            session["_id"] = uuid4()
+            with db_session:
+                # create an empty seed and a room from it
+                seed = Seed(multidata=b"", owner=session["_id"])
+                room = Room(seed=seed, owner=session["_id"], tracker=uuid4())
+                self.room_id = room.id
+                self.log_filename = user_path("logs", f"{self.room_id}.txt")
+
+    def tearDown(self) -> None:
+        from pony.orm import db_session, select
+        from WebHostLib.models import Command, Room
+
+        with db_session:
+            for command in select(command for command in Command if command.room.id == self.room_id):  # type: ignore
+                command.delete()
+            room: Room = Room.get(id=self.room_id)
+            room.seed.delete()
+            room.delete()
+
+        try:
+            os.unlink(self.log_filename)
+        except FileNotFoundError:
+            pass
+
+    def test_display_log_missing_full(self) -> None:
+        """
+        Verify that we get a 200 response even if log is missing.
+        This is required to not get an error for fetch.
+        """
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("display_log", room=self.room_id))
+            self.assertEqual(response.status_code, 200)
+
+    def test_display_log_missing_range(self) -> None:
+        """
+        Verify that we get a full response for missing log even if we asked for range.
+        This is required for the JS logic to differentiate between log update and log error message.
+        """
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("display_log", room=self.room_id), headers={
+                "Range": "bytes=100-"
+            })
+            self.assertEqual(response.status_code, 200)
+
+    def test_display_log_denied(self) -> None:
+        """Verify that only the owner can see the log."""
+        other_client = self.app.test_client()
+        with self.app.app_context(), self.app.test_request_context():
+            response = other_client.get(url_for("display_log", room=self.room_id))
+            self.assertEqual(response.status_code, 403)
+
+    def test_display_log_missing_room(self) -> None:
+        """Verify log for missing room gives an error as opposed to missing log for existing room."""
+        missing_room_id = uuid5(uuid4(), "")  # rooms are always uuid4, so this can't exist
+        other_client = self.app.test_client()
+        with self.app.app_context(), self.app.test_request_context():
+            response = other_client.get(url_for("display_log", room=missing_room_id))
+            self.assertEqual(response.status_code, 404)
+
+    def test_display_log_full(self) -> None:
+        """Verify full log response."""
+        with open(self.log_filename, "w", encoding="utf-8") as f:
+            text = "x" * 200
+            f.write(text)
+
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("display_log", room=self.room_id))
+            self.assertEqual(response.status_code, 200)
+            self.assertEqual(response.get_data(True), text)
+
+    def test_display_log_range(self) -> None:
+        """Verify that Range header in request gives a range in response."""
+        with open(self.log_filename, "w", encoding="utf-8") as f:
+            f.write(" " * 100)
+            text = "x" * 100
+            f.write(text)
+
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("display_log", room=self.room_id), headers={
+                "Range": "bytes=100-"
+            })
+            self.assertEqual(response.status_code, 206)
+            self.assertEqual(response.get_data(True), text)
+
+    def test_display_log_range_bom(self) -> None:
+        """Verify that a BOM in the log file is skipped for range."""
+        with open(self.log_filename, "w", encoding="utf-8-sig") as f:
+            f.write(" " * 100)
+            text = "x" * 100
+            f.write(text)
+            self.assertEqual(f.tell(), 203)  # including BOM
+
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("display_log", room=self.room_id), headers={
+                "Range": "bytes=100-"
+            })
+            self.assertEqual(response.status_code, 206)
+            self.assertEqual(response.get_data(True), text)
+
+    def test_host_room_missing(self) -> None:
+        """Verify that missing room gives a 404 response."""
+        missing_room_id = uuid5(uuid4(), "")  # rooms are always uuid4, so this can't exist
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("host_room", room=missing_room_id))
+            self.assertEqual(response.status_code, 404)
+
+    def test_host_room_own(self) -> None:
+        """Verify that own room gives the full output."""
+        with open(self.log_filename, "w", encoding="utf-8-sig") as f:
+            text = "* should be visible *"
+            f.write(text)
+
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.get(url_for("host_room", room=self.room_id))
+            response_text = response.get_data(True)
+            self.assertEqual(response.status_code, 200)
+            self.assertIn("href=\"/seed/", response_text)
+            self.assertIn(text, response_text)
+
+    def test_host_room_other(self) -> None:
+        """Verify that non-own room gives the reduced output."""
+        from pony.orm import db_session
+        from WebHostLib.models import Room
+
+        with db_session:
+            room: Room = Room.get(id=self.room_id)
+            room.last_port = 12345
+
+        with open(self.log_filename, "w", encoding="utf-8-sig") as f:
+            text = "* should not be visible *"
+            f.write(text)
+
+        other_client = self.app.test_client()
+        with self.app.app_context(), self.app.test_request_context():
+            response = other_client.get(url_for("host_room", room=self.room_id))
+            response_text = response.get_data(True)
+            self.assertEqual(response.status_code, 200)
+            self.assertNotIn("href=\"/seed/", response_text)
+            self.assertNotIn(text, response_text)
+            self.assertIn("/connect ", response_text)
+            self.assertIn(":12345", response_text)
+
+    def test_host_room_own_post(self) -> None:
+        """Verify command from owner gets queued for the server and response is redirect."""
+        from pony.orm import db_session, select
+        from WebHostLib.models import Command
+
+        with self.app.app_context(), self.app.test_request_context():
+            response = self.client.post(url_for("host_room", room=self.room_id), data={
+                "cmd": "/help"
+            })
+            self.assertEqual(response.status_code, 302, response.text)\
+
+        with db_session:
+            commands = select(command for command in Command if command.room.id == self.room_id)  # type: ignore
+            self.assertIn("/help", (command.commandtext for command in commands))
+
+    def test_host_room_other_post(self) -> None:
+        """Verify command from non-owner does not get queued for the server."""
+        from pony.orm import db_session, select
+        from WebHostLib.models import Command
+
+        other_client = self.app.test_client()
+        with self.app.app_context(), self.app.test_request_context():
+            response = other_client.post(url_for("host_room", room=self.room_id), data={
+                "cmd": "/help"
+            })
+            self.assertLess(response.status_code, 500)
+
+        with db_session:
+            commands = select(command for command in Command if command.room.id == self.room_id)  # type: ignore
+            self.assertNotIn("/help", (command.commandtext for command in commands))

worlds/AutoWorld.py

@@ -123,8 +123,8 @@ class WebWorldRegister(type):
             assert group.options, "A custom defined Option Group must contain at least one Option."
             # catch incorrectly titled versions of the prebuilt groups so they don't create extra groups
             title_name = group.name.title()
-            if title_name in prebuilt_options:
-                group.name = title_name
+            assert title_name not in prebuilt_options or title_name == group.name, \
+                f"Prebuilt group name \"{group.name}\" must be \"{title_name}\""
 
             if group.name == "Item & Location Options":
                 assert not any(option in item_and_loc_options for option in group.options), \
@@ -223,6 +223,21 @@ class WebWorld(metaclass=WebWorldRegister):
     option_groups: ClassVar[List[OptionGroup]] = []
     """Ordered list of option groupings. Any options not set in a group will be placed in a pre-built "Game Options"."""
 
+    rich_text_options_doc = False
+    """Whether the WebHost should render Options' docstrings as rich text.
+
+    If this is True, Options' docstrings are interpreted as reStructuredText_,
+    the standard Python markup format. In the WebHost, they're rendered to HTML
+    so that lists, emphasis, and other rich text features are displayed
+    properly.
+
+    If this is False, the docstrings are instead interpreted as plain text, and
+    displayed as-is on the WebHost with whitespace preserved. For backwards
+    compatibility, this is the default.
+
+    .. _reStructuredText: https://docutils.sourceforge.io/rst.html
+    """
+
     location_descriptions: Dict[str, str] = {}
     """An optional map from location names (or location group names) to brief descriptions for users."""
 
@@ -265,7 +280,7 @@ class World(metaclass=AutoWorldRegister):
     future. Protocol level compatibility check moved to MultiServer.min_client_version.
     """
 
-    required_server_version: Tuple[int, int, int] = (0, 2, 4)
+    required_server_version: Tuple[int, int, int] = (0, 5, 0)
     """update this if the resulting multidata breaks forward-compatibility of the server"""
 
     hint_blacklist: ClassVar[FrozenSet[str]] = frozenset()

worlds/LauncherComponents.py

@@ -132,7 +132,8 @@ def _install_apworld(apworld_src: str = "") -> Optional[Tuple[pathlib.Path, path
             break
     if found_already_loaded:
         raise Exception(f"Installed APWorld successfully, but '{module_name}' is already loaded,\n"
-                        "so a Launcher restart is required to use the new installation.")
+                        "so a Launcher restart is required to use the new installation.\n"
+                        "If the Launcher is not open, no action needs to be taken.")
     world_source = worlds.WorldSource(str(target), is_zip=True)
     bisect.insort(worlds.world_sources, world_source)
     world_source.load()

worlds/__init__.py

@@ -1,4 +1,5 @@
 import importlib
+import importlib.util
 import logging
 import os
 import sys
@@ -72,7 +73,12 @@ class WorldSource:
                 else:  # TODO: remove with 3.8 support
                     mod = importer.load_module(os.path.basename(self.path).rsplit(".", 1)[0])
 
-                mod.__package__ = f"worlds.{mod.__package__}"
+                if mod.__package__ is not None:
+                    mod.__package__ = f"worlds.{mod.__package__}"
+                else:
+                    # load_module does not populate package, we'll have to assume mod.__name__ is correct here
+                    # probably safe to remove with 3.8 support
+                    mod.__package__ = f"worlds.{mod.__name__}"
                 mod.__name__ = f"worlds.{mod.__name__}"
                 sys.modules[mod.__name__] = mod
                 with warnings.catch_warnings():
@@ -107,8 +113,9 @@ for folder in (folder for folder in (user_folder, local_folder) if folder):
         if not entry.name.startswith(("_", ".")):
             file_name = entry.name if relative else os.path.join(folder, entry.name)
             if entry.is_dir():
-                init_file_path = os.path.join(entry.path, '__init__.py')
-                if os.path.isfile(init_file_path):
+                if os.path.isfile(os.path.join(entry.path, '__init__.py')):
+                    world_sources.append(WorldSource(file_name, relative=relative))
+                elif os.path.isfile(os.path.join(entry.path, '__init__.pyc')):
                     world_sources.append(WorldSource(file_name, relative=relative))
                 else:
                     logging.warning(f"excluding {entry.name} from world sources because it has no __init__.py")
@@ -126,3 +133,4 @@ from .AutoWorld import AutoWorldRegister
 network_data_package: DataPackage = {
     "games": {world_name: world.get_data_package_data() for world_name, world in AutoWorldRegister.world_types.items()},
 }
+

worlds/_sc2common/bot/sc2process.py

@@ -28,6 +28,11 @@ class kill_switch:
         logger.debug("kill_switch: Add switch")
         cls._to_kill.append(value)
 
+    @classmethod
+    def kill(cls, value):
+        logger.info(f"kill_switch: Process cleanup for 1 process")
+        value._clean(verbose=False)
+
     @classmethod
     def kill_all(cls):
         logger.info(f"kill_switch: Process cleanup for {len(cls._to_kill)} processes")
@@ -116,7 +121,7 @@ class SC2Process:
     async def __aexit__(self, *args):
         logger.exception("async exit")
         await self._close_connection()
-        kill_switch.kill_all()
+        kill_switch.kill(self)
         signal.signal(signal.SIGINT, signal.SIG_DFL)
 
     @property

worlds/adventure/Options.py

@@ -2,7 +2,8 @@ from __future__ import annotations
 
 from typing import Dict
 
-from Options import Choice, Option, DefaultOnToggle, DeathLink, Range, Toggle
+from dataclasses import dataclass
+from Options import Choice, Option, DefaultOnToggle, DeathLink, Range, Toggle, PerGameCommonOptions
 
 
 class FreeincarnateMax(Range):
@@ -223,22 +224,22 @@ class StartCastle(Choice):
     option_white = 2
     default = option_yellow
 
+@dataclass
+class AdventureOptions(PerGameCommonOptions):
+    dragon_slay_check: DragonSlayCheck
+    death_link: DeathLink
+    bat_logic: BatLogic
+    freeincarnate_max: FreeincarnateMax
+    dragon_rando_type: DragonRandoType
+    connector_multi_slot: ConnectorMultiSlot
+    yorgle_speed: YorgleStartingSpeed
+    yorgle_min_speed: YorgleMinimumSpeed
+    grundle_speed: GrundleStartingSpeed
+    grundle_min_speed: GrundleMinimumSpeed
+    rhindle_speed: RhindleStartingSpeed
+    rhindle_min_speed: RhindleMinimumSpeed
+    difficulty_switch_a: DifficultySwitchA
+    difficulty_switch_b: DifficultySwitchB
+    start_castle: StartCastle
 
-adventure_option_definitions: Dict[str, type(Option)] = {
-    "dragon_slay_check": DragonSlayCheck,
-    "death_link": DeathLink,
-    "bat_logic": BatLogic,
-    "freeincarnate_max": FreeincarnateMax,
-    "dragon_rando_type": DragonRandoType,
-    "connector_multi_slot": ConnectorMultiSlot,
-    "yorgle_speed": YorgleStartingSpeed,
-    "yorgle_min_speed": YorgleMinimumSpeed,
-    "grundle_speed": GrundleStartingSpeed,
-    "grundle_min_speed": GrundleMinimumSpeed,
-    "rhindle_speed": RhindleStartingSpeed,
-    "rhindle_min_speed": RhindleMinimumSpeed,
-    "difficulty_switch_a": DifficultySwitchA,
-    "difficulty_switch_b": DifficultySwitchB,
-    "start_castle": StartCastle,
 
-}

worlds/adventure/Regions.py

@@ -1,4 +1,5 @@
 from BaseClasses import MultiWorld, Region, Entrance, LocationProgressType
+from Options import PerGameCommonOptions
 from .Locations import location_table, LocationData, AdventureLocation, dragon_room_to_region
 
 
@@ -24,7 +25,7 @@ def connect(world: MultiWorld, player: int, source: str, target: str, rule: call
         connect(world, player, target, source, rule, True)
 
 
-def create_regions(multiworld: MultiWorld, player: int, dragon_rooms: []) -> None:
+def create_regions(options: PerGameCommonOptions, multiworld: MultiWorld, player: int, dragon_rooms: []) -> None:
 
     menu = Region("Menu", player, multiworld)
 
@@ -74,7 +75,7 @@ def create_regions(multiworld: MultiWorld, player: int, dragon_rooms: []) -> Non
     credits_room_far_side.exits.append(Entrance(player, "CreditsFromFarSide", credits_room_far_side))
     multiworld.regions.append(credits_room_far_side)
 
-    dragon_slay_check = multiworld.dragon_slay_check[player].value
+    dragon_slay_check = options.dragon_slay_check.value
     priority_locations = determine_priority_locations(multiworld, dragon_slay_check)
 
     for name, location_data in location_table.items():

worlds/adventure/Rules.py

@@ -1,12 +1,10 @@
-from worlds.adventure import location_table
-from worlds.adventure.Options import BatLogic, DifficultySwitchB, DifficultySwitchA
+from .Options import BatLogic, DifficultySwitchB
 from worlds.generic.Rules import add_rule, set_rule, forbid_item
-from BaseClasses import LocationProgressType
 
 
 def set_rules(self) -> None:
     world = self.multiworld
-    use_bat_logic = world.bat_logic[self.player].value == BatLogic.option_use_logic
+    use_bat_logic = self.options.bat_logic.value == BatLogic.option_use_logic
 
     set_rule(world.get_entrance("YellowCastlePort", self.player),
              lambda state: state.has("Yellow Key", self.player))
@@ -28,7 +26,7 @@ def set_rules(self) -> None:
                  lambda state: state.has("Bridge", self.player) or
                                state.has("Magnet", self.player))
 
-    dragon_slay_check = world.dragon_slay_check[self.player].value
+    dragon_slay_check = self.options.dragon_slay_check.value
     if dragon_slay_check:
         if self.difficulty_switch_b == DifficultySwitchB.option_hard_with_unlock_item:
             set_rule(world.get_location("Slay Yorgle", self.player),

worlds/adventure/__init__.py

@@ -15,7 +15,8 @@ from Options import AssembleOptions
 from worlds.AutoWorld import WebWorld, World
 from Fill import fill_restrictive
 from worlds.generic.Rules import add_rule, set_rule
-from .Options import adventure_option_definitions, DragonRandoType, DifficultySwitchA, DifficultySwitchB
+from .Options import DragonRandoType, DifficultySwitchA, DifficultySwitchB, \
+    AdventureOptions
 from .Rom import get_base_rom_bytes, get_base_rom_path, AdventureDeltaPatch, apply_basepatch, \
     AdventureAutoCollectLocation
 from .Items import item_table, ItemData, nothing_item_id, event_table, AdventureItem, standard_item_max
@@ -109,7 +110,7 @@ class AdventureWorld(World):
     game: ClassVar[str] = "Adventure"
     web: ClassVar[WebWorld] = AdventureWeb()
 
-    option_definitions: ClassVar[Dict[str, AssembleOptions]] = adventure_option_definitions
+    options_dataclass = AdventureOptions
     settings: ClassVar[AdventureSettings]
     item_name_to_id: ClassVar[Dict[str, int]] = {name: data.id for name, data in item_table.items()}
     location_name_to_id: ClassVar[Dict[str, int]] = {name: data.location_id for name, data in location_table.items()}
@@ -149,18 +150,18 @@ class AdventureWorld(World):
             bytearray(f"ADVENTURE{__version__.replace('.', '')[:3]}_{self.player}_{self.multiworld.seed}", "utf8")[:21]
         self.rom_name.extend([0] * (21 - len(self.rom_name)))
 
-        self.dragon_rando_type = self.multiworld.dragon_rando_type[self.player].value
-        self.dragon_slay_check = self.multiworld.dragon_slay_check[self.player].value
-        self.connector_multi_slot = self.multiworld.connector_multi_slot[self.player].value
-        self.yorgle_speed = self.multiworld.yorgle_speed[self.player].value
-        self.yorgle_min_speed = self.multiworld.yorgle_min_speed[self.player].value
-        self.grundle_speed = self.multiworld.grundle_speed[self.player].value
-        self.grundle_min_speed = self.multiworld.grundle_min_speed[self.player].value
-        self.rhindle_speed = self.multiworld.rhindle_speed[self.player].value
-        self.rhindle_min_speed = self.multiworld.rhindle_min_speed[self.player].value
-        self.difficulty_switch_a = self.multiworld.difficulty_switch_a[self.player].value
-        self.difficulty_switch_b = self.multiworld.difficulty_switch_b[self.player].value
-        self.start_castle = self.multiworld.start_castle[self.player].value
+        self.dragon_rando_type = self.options.dragon_rando_type.value
+        self.dragon_slay_check = self.options.dragon_slay_check.value
+        self.connector_multi_slot = self.options.connector_multi_slot.value
+        self.yorgle_speed = self.options.yorgle_speed.value
+        self.yorgle_min_speed = self.options.yorgle_min_speed.value
+        self.grundle_speed = self.options.grundle_speed.value
+        self.grundle_min_speed = self.options.grundle_min_speed.value
+        self.rhindle_speed = self.options.rhindle_speed.value
+        self.rhindle_min_speed = self.options.rhindle_min_speed.value
+        self.difficulty_switch_a = self.options.difficulty_switch_a.value
+        self.difficulty_switch_b = self.options.difficulty_switch_b.value
+        self.start_castle = self.options.start_castle.value
         self.created_items = 0
 
         if self.dragon_slay_check == 0:
@@ -227,7 +228,7 @@ class AdventureWorld(World):
         extra_filler_count = num_locations - self.created_items
 
         # traps would probably go here, if enabled
-        freeincarnate_max = self.multiworld.freeincarnate_max[self.player].value
+        freeincarnate_max = self.options.freeincarnate_max.value
         actual_freeincarnates = min(extra_filler_count, freeincarnate_max)
         self.multiworld.itempool += [self.create_item("Freeincarnate") for _ in range(actual_freeincarnates)]
         self.created_items += actual_freeincarnates
@@ -247,7 +248,7 @@ class AdventureWorld(World):
                 self.created_items += 1
 
     def create_regions(self) -> None:
-        create_regions(self.multiworld, self.player, self.dragon_rooms)
+        create_regions(self.options, self.multiworld, self.player, self.dragon_rooms)
 
     set_rules = set_rules
 
@@ -354,7 +355,7 @@ class AdventureWorld(World):
         auto_collect_locations: [AdventureAutoCollectLocation] = []
         local_item_to_location: {int, int} = {}
         bat_no_touch_locs: [LocationData] = []
-        bat_logic: int = self.multiworld.bat_logic[self.player].value
+        bat_logic: int = self.options.bat_logic.value
         try:
             rom_deltas: { int, int } = {}
             self.place_dragons(rom_deltas)
@@ -421,7 +422,7 @@ class AdventureWorld(World):
                 item_position_data_start = get_item_position_data_start(unplaced_item.table_index)
                 rom_deltas[item_position_data_start] = 0xff
 
-            if self.multiworld.connector_multi_slot[self.player].value:
+            if self.options.connector_multi_slot.value:
                 rom_deltas[connector_port_offset] = (self.player & 0xff)
             else:
                 rom_deltas[connector_port_offset] = 0

worlds/ahit/Items.py

@@ -39,7 +39,7 @@ def create_itempool(world: "HatInTimeWorld") -> List[Item]:
                 continue
         else:
             if name == "Scooter Badge":
-                if world.options.CTRLogic is CTRLogic.option_scooter or get_difficulty(world) >= Difficulty.MODERATE:
+                if world.options.CTRLogic == CTRLogic.option_scooter or get_difficulty(world) >= Difficulty.MODERATE:
                     item_type = ItemClassification.progression
             elif name == "No Bonk Badge" and world.is_dw():
                 item_type = ItemClassification.progression

worlds/ahit/Regions.py

@@ -292,6 +292,9 @@ blacklisted_combos = {
     # See above comment
     "Time Rift - Deep Sea":             ["Alpine Free Roam", "Nyakuza Free Roam", "Contractual Obligations",
                                          "Murder on the Owl Express"],
+
+    # was causing test failures
+    "Time Rift - Balcony":              ["Alpine Free Roam"],
 }
 
 
@@ -656,6 +659,10 @@ def is_valid_act_combo(world: "HatInTimeWorld", entrance_act: Region,
             if exit_act.name not in chapter_finales:
                 return False
 
+    exit_chapter: str = act_chapters.get(exit_act.name)
+    # make sure that certain time rift combinations never happen
+    always_block: bool = exit_chapter != "Mafia Town" and exit_chapter != "Subcon Forest"
+    if not ignore_certain_rules or always_block:
         if entrance_act.name in rift_access_regions and exit_act.name in rift_access_regions[entrance_act.name]:
             return False
 
@@ -681,9 +688,12 @@ def is_valid_first_act(world: "HatInTimeWorld", act: Region) -> bool:
     if act.name not in guaranteed_first_acts:
         return False
 
+    if world.options.ActRandomizer == ActRandomizer.option_light and "Time Rift" in act.name:
+        return False
+
     # If there's only a single level in the starting chapter, only allow Mafia Town or Subcon Forest levels
     start_chapter = world.options.StartingChapter
-    if start_chapter is ChapterIndex.ALPINE or start_chapter is ChapterIndex.SUBCON:
+    if start_chapter == ChapterIndex.ALPINE or start_chapter == ChapterIndex.SUBCON:
         if "Time Rift" in act.name:
             return False
 
@@ -720,7 +730,8 @@ def is_valid_first_act(world: "HatInTimeWorld", act: Region) -> bool:
     elif act.name == "Contractual Obligations" and world.options.ShuffleSubconPaintings:
         return False
 
-    if world.options.ShuffleSubconPaintings and act_chapters.get(act.name, "") == "Subcon Forest":
+    if world.options.ShuffleSubconPaintings and "Time Rift" not in act.name \
+       and act_chapters.get(act.name, "") == "Subcon Forest":
         # Only allow Subcon levels if painting skips are allowed
         if diff < Difficulty.MODERATE or world.options.NoPaintingSkips:
             return False
@@ -957,40 +968,35 @@ def get_act_by_number(world: "HatInTimeWorld", chapter_name: str, num: int) -> R
 def create_thug_shops(world: "HatInTimeWorld"):
     min_items: int = world.options.NyakuzaThugMinShopItems.value
     max_items: int = world.options.NyakuzaThugMaxShopItems.value
-    count = -1
-    step = 0
-    old_name = ""
+
+    thug_location_counts: Dict[str, int] = {}
 
     for key, data in shop_locations.items():
-        if data.nyakuza_thug == "":
+        thug_name = data.nyakuza_thug
+        if thug_name == "":
+            # Different shop type.
             continue
 
-        if old_name != "" and old_name == data.nyakuza_thug:
+        if thug_name not in world.nyakuza_thug_items:
+            shop_item_count = world.random.randint(min_items, max_items)
+            world.nyakuza_thug_items[thug_name] = shop_item_count
+        else:
+            shop_item_count = world.nyakuza_thug_items[thug_name]
+
+        if shop_item_count <= 0:
             continue
 
-        try:
-            if world.nyakuza_thug_items[data.nyakuza_thug] <= 0:
-                continue
-        except KeyError:
-            pass
+        location_count = thug_location_counts.setdefault(thug_name, 0)
+        if location_count >= shop_item_count:
+            # Already created all the locations for this thug.
+            continue
 
-        if count == -1:
-            count = world.random.randint(min_items, max_items)
-            world.nyakuza_thug_items.setdefault(data.nyakuza_thug, count)
-            if count <= 0:
-                continue
-
-        if count >= 1:
-            region = world.multiworld.get_region(data.region, world.player)
-            loc = HatInTimeLocation(world.player, key, data.id, region)
-            region.locations.append(loc)
-            world.shop_locs.append(loc.name)
-
-            step += 1
-            if step >= count:
-                old_name = data.nyakuza_thug
-                step = 0
-                count = -1
+        # Create the shop location.
+        region = world.multiworld.get_region(data.region, world.player)
+        loc = HatInTimeLocation(world.player, key, data.id, region)
+        region.locations.append(loc)
+        world.shop_locs.append(loc.name)
+        thug_location_counts[thug_name] = location_count + 1
 
 
 def create_events(world: "HatInTimeWorld") -> int:

worlds/ahit/Rules.py

@@ -1,7 +1,6 @@
 from worlds.AutoWorld import CollectionState
 from worlds.generic.Rules import add_rule, set_rule
-from .Locations import location_table, zipline_unlocks, is_location_valid, contract_locations, \
-    shop_locations, event_locs
+from .Locations import location_table, zipline_unlocks, is_location_valid, shop_locations, event_locs
 from .Types import HatType, ChapterIndex, hat_type_to_item, Difficulty, HitType
 from BaseClasses import Location, Entrance, Region
 from typing import TYPE_CHECKING, List, Callable, Union, Dict
@@ -148,14 +147,14 @@ def set_rules(world: "HatInTimeWorld"):
     if world.is_dlc1():
         chapter_list.append(ChapterIndex.CRUISE)
 
-    if world.is_dlc2() and final_chapter is not ChapterIndex.METRO:
+    if world.is_dlc2() and final_chapter != ChapterIndex.METRO:
         chapter_list.append(ChapterIndex.METRO)
 
     chapter_list.remove(starting_chapter)
     world.random.shuffle(chapter_list)
 
     # Make sure Alpine is unlocked before any DLC chapters are, as the Alpine door needs to be open to access them
-    if starting_chapter is not ChapterIndex.ALPINE and (world.is_dlc1() or world.is_dlc2()):
+    if starting_chapter != ChapterIndex.ALPINE and (world.is_dlc1() or world.is_dlc2()):
         index1 = 69
         index2 = 69
         pos: int
@@ -165,7 +164,7 @@ def set_rules(world: "HatInTimeWorld"):
         if world.is_dlc1():
             index1 = chapter_list.index(ChapterIndex.CRUISE)
 
-        if world.is_dlc2() and final_chapter is not ChapterIndex.METRO:
+        if world.is_dlc2() and final_chapter != ChapterIndex.METRO:
             index2 = chapter_list.index(ChapterIndex.METRO)
 
         lowest_index = min(index1, index2)
@@ -242,9 +241,6 @@ def set_rules(world: "HatInTimeWorld"):
         if not is_location_valid(world, key):
             continue
 
-        if key in contract_locations.keys():
-            continue
-
         loc = world.multiworld.get_location(key, world.player)
 
         for hat in data.required_hats:
@@ -256,7 +252,7 @@ def set_rules(world: "HatInTimeWorld"):
         if data.paintings > 0 and world.options.ShuffleSubconPaintings:
             add_rule(loc, lambda state, paintings=data.paintings: has_paintings(state, world, paintings))
 
-        if data.hit_type is not HitType.none and world.options.UmbrellaLogic:
+        if data.hit_type != HitType.none and world.options.UmbrellaLogic:
             if data.hit_type == HitType.umbrella:
                 add_rule(loc, lambda state: state.has("Umbrella", world.player))
 
@@ -385,8 +381,8 @@ def set_moderate_rules(world: "HatInTimeWorld"):
              lambda state: can_use_hat(state, world, HatType.ICE), "or")
 
     # Moderate: Clock Tower Chest + Ruined Tower with nothing
-    add_rule(world.multiworld.get_location("Mafia Town - Clock Tower Chest", world.player), lambda state: True)
-    add_rule(world.multiworld.get_location("Mafia Town - Top of Ruined Tower", world.player), lambda state: True)
+    set_rule(world.multiworld.get_location("Mafia Town - Clock Tower Chest", world.player), lambda state: True)
+    set_rule(world.multiworld.get_location("Mafia Town - Top of Ruined Tower", world.player), lambda state: True)
 
     # Moderate: enter and clear The Subcon Well without Hookshot and without hitting the bell
     for loc in world.multiworld.get_region("The Subcon Well", world.player).locations:
@@ -436,8 +432,8 @@ def set_moderate_rules(world: "HatInTimeWorld"):
 
     if world.is_dlc1():
         # Moderate: clear Rock the Boat without Ice Hat
-        add_rule(world.multiworld.get_location("Rock the Boat - Post Captain Rescue", world.player), lambda state: True)
-        add_rule(world.multiworld.get_location("Act Completion (Rock the Boat)", world.player), lambda state: True)
+        set_rule(world.multiworld.get_location("Rock the Boat - Post Captain Rescue", world.player), lambda state: True)
+        set_rule(world.multiworld.get_location("Act Completion (Rock the Boat)", world.player), lambda state: True)
 
         # Moderate: clear Deep Sea without Ice Hat
         set_rule(world.multiworld.get_location("Act Completion (Time Rift - Deep Sea)", world.player),
@@ -518,7 +514,7 @@ def set_hard_rules(world: "HatInTimeWorld"):
                  lambda state: can_use_hat(state, world, HatType.ICE))
 
         # Hard: clear Rush Hour with Brewing Hat only
-        if world.options.NoTicketSkips is not NoTicketSkips.option_true:
+        if world.options.NoTicketSkips != NoTicketSkips.option_true:
             set_rule(world.multiworld.get_location("Act Completion (Rush Hour)", world.player),
                      lambda state: can_use_hat(state, world, HatType.BREWING))
         else:
@@ -859,10 +855,15 @@ def set_rift_rules(world: "HatInTimeWorld", regions: Dict[str, Region]):
 
     for entrance in regions["Time Rift - Alpine Skyline"].entrances:
         add_rule(entrance, lambda state: has_relic_combo(state, world, "Crayon"))
+        if entrance.parent_region.name == "Alpine Free Roam":
+            add_rule(entrance,
+                     lambda state: can_use_hookshot(state, world) and can_hit(state, world, umbrella_only=True))
 
     if world.is_dlc1():
         for entrance in regions["Time Rift - Balcony"].entrances:
             add_rule(entrance, lambda state: can_clear_required_act(state, world, "The Arctic Cruise - Finale"))
+            reg_act_connection(world, world.multiworld.get_entrance("The Arctic Cruise - Finale",
+                                                                    world.player).connected_region, entrance)
 
         for entrance in regions["Time Rift - Deep Sea"].entrances:
             add_rule(entrance, lambda state: has_relic_combo(state, world, "Cake"))
@@ -935,10 +936,14 @@ def set_default_rift_rules(world: "HatInTimeWorld"):
 
     for entrance in world.multiworld.get_region("Time Rift - Alpine Skyline", world.player).entrances:
         add_rule(entrance, lambda state: has_relic_combo(state, world, "Crayon"))
+        if entrance.parent_region.name == "Alpine Free Roam":
+            add_rule(entrance,
+                     lambda state: can_use_hookshot(state, world) and can_hit(state, world, umbrella_only=True))
 
     if world.is_dlc1():
         for entrance in world.multiworld.get_region("Time Rift - Balcony", world.player).entrances:
             add_rule(entrance, lambda state: can_clear_required_act(state, world, "The Arctic Cruise - Finale"))
+            reg_act_connection(world, "Rock the Boat", entrance.name)
 
         for entrance in world.multiworld.get_region("Time Rift - Deep Sea", world.player).entrances:
             add_rule(entrance, lambda state: has_relic_combo(state, world, "Cake"))

worlds/ahit/__init__.py

@@ -1,15 +1,16 @@
 from BaseClasses import Item, ItemClassification, Tutorial, Location, MultiWorld
 from .Items import item_table, create_item, relic_groups, act_contracts, create_itempool, get_shop_trap_name, \
-    calculate_yarn_costs
+    calculate_yarn_costs, alps_hooks
 from .Regions import create_regions, randomize_act_entrances, chapter_act_info, create_events, get_shuffled_region
 from .Locations import location_table, contract_locations, is_location_valid, get_location_names, TASKSANITY_START_ID, \
     get_total_locations
-from .Rules import set_rules
+from .Rules import set_rules, has_paintings
 from .Options import AHITOptions, slot_data_options, adjust_options, RandomizeHatOrder, EndGoal, create_option_groups
-from .Types import HatType, ChapterIndex, HatInTimeItem, hat_type_to_item
+from .Types import HatType, ChapterIndex, HatInTimeItem, hat_type_to_item, Difficulty
 from .DeathWishLocations import create_dw_regions, dw_classes, death_wishes
 from .DeathWishRules import set_dw_rules, create_enemy_events, hit_list, bosses
 from worlds.AutoWorld import World, WebWorld, CollectionState
+from worlds.generic.Rules import add_rule
 from typing import List, Dict, TextIO
 from worlds.LauncherComponents import Component, components, icon_paths, launch_subprocess, Type
 from Utils import local_path
@@ -86,19 +87,27 @@ class HatInTimeWorld(World):
         if self.is_dw_only():
             return
 
-        # If our starting chapter is 4 and act rando isn't on, force hookshot into inventory
-        # If starting chapter is 3 and painting shuffle is enabled, and act rando isn't, give one free painting unlock
-        start_chapter: ChapterIndex = ChapterIndex(self.options.StartingChapter)
+        # Take care of some extremely restrictive starts in other chapters with act shuffle off
+        if not self.options.ActRandomizer:
+            start_chapter = self.options.StartingChapter
+            if start_chapter == ChapterIndex.ALPINE:
+                self.multiworld.push_precollected(self.create_item("Hookshot Badge"))
+                if self.options.UmbrellaLogic:
+                    self.multiworld.push_precollected(self.create_item("Umbrella"))
 
-        if start_chapter == ChapterIndex.ALPINE or start_chapter == ChapterIndex.SUBCON:
-            if not self.options.ActRandomizer:
-                if start_chapter == ChapterIndex.ALPINE:
-                    self.multiworld.push_precollected(self.create_item("Hookshot Badge"))
-                    if self.options.UmbrellaLogic:
-                        self.multiworld.push_precollected(self.create_item("Umbrella"))
-
-                if start_chapter == ChapterIndex.SUBCON and self.options.ShuffleSubconPaintings:
+                if self.options.ShuffleAlpineZiplines:
+                    ziplines = list(alps_hooks.keys())
+                    ziplines.remove("Zipline Unlock - The Twilight Bell Path")  # not enough checks from this one
+                    self.multiworld.push_precollected(self.create_item(self.random.choice(ziplines)))
+            elif start_chapter == ChapterIndex.SUBCON:
+                if self.options.ShuffleSubconPaintings:
                     self.multiworld.push_precollected(self.create_item("Progressive Painting Unlock"))
+            elif start_chapter == ChapterIndex.BIRDS:
+                if self.options.UmbrellaLogic:
+                    if self.options.LogicDifficulty < Difficulty.EXPERT:
+                        self.multiworld.push_precollected(self.create_item("Umbrella"))
+                elif self.options.LogicDifficulty < Difficulty.MODERATE:
+                    self.multiworld.push_precollected(self.create_item("Umbrella"))
 
     def create_regions(self):
         # noinspection PyClassVar
@@ -119,7 +128,10 @@ class HatInTimeWorld(World):
         # place vanilla contract locations if contract shuffle is off
         if not self.options.ShuffleActContracts:
             for name in contract_locations.keys():
-                self.multiworld.get_location(name, self.player).place_locked_item(create_item(self, name))
+                loc = self.get_location(name)
+                loc.place_locked_item(create_item(self, name))
+                if self.options.ShuffleSubconPaintings and loc.name != "Snatcher's Contract - The Subcon Well":
+                    add_rule(loc, lambda state: has_paintings(state, self, 1))
 
     def create_items(self):
         if self.has_yarn():
@@ -317,7 +329,7 @@ class HatInTimeWorld(World):
 
     def remove(self, state: "CollectionState", item: "Item") -> bool:
         old_count: int = state.count(item.name, self.player)
-        change = super().collect(state, item)
+        change = super().remove(state, item)
         if change and old_count == 1:
             if "Stamp" in item.name:
                 if "2 Stamp" in item.name:

worlds/ahit/docs/setup_en.md

@@ -12,41 +12,29 @@
 
 ## Instructions
 
-1. Have Steam running. Open the Steam console with this link: [steam://open/console](steam://open/console)   
-This may not work for some browsers. If that's the case, and you're on Windows, open the Run dialog using Win+R,
-paste the link into the box, and hit Enter.
+1. **BACK UP YOUR SAVE FILES IN YOUR MAIN INSTALL IF YOU CARE ABOUT THEM!!!**  
+   Go to `steamapps/common/HatinTime/HatinTimeGame/SaveData/` and copy everything inside that folder over to a safe place.
+   **This is important! Changing the game version CAN and WILL break your existing save files!!!**
 
 
-2. In the Steam console, enter the following command: 
-`download_depot 253230 253232 7770543545116491859`. ***Wait for the console to say the download is finished!***
-This can take a while to finish (30+ minutes) depending on your connection speed, so please be patient. Additionally,
-**try to prevent your connection from being interrupted or slowed while Steam is downloading the depot,**
-or else the download may potentially become corrupted (see first FAQ issue below).
+2. In your Steam library, right-click on **A Hat in Time** in the list of games and click on **Properties**.
 
 
-3. Once the download finishes, go to `steamapps/content/app_253230` in Steam's program folder.
+3. Click the **Betas** tab. In the **Beta Participation** dropdown, select `tcplink`.  
+   While it downloads, you can subscribe to the [Archipelago workshop mod.]((https://steamcommunity.com/sharedfiles/filedetails/?id=3026842601))
 
 
-4. There should be a folder named `depot_253232`. Rename it to HatinTime_AP and move it to your `steamapps/common` folder.
+4. Once the game finishes downloading, start it up.  
+   In Game Settings, make sure **Enable Developer Console** is checked.
 
 
-5. In the HatinTime_AP folder, navigate to `Binaries/Win64` and create a new file: `steam_appid.txt`. 
-In this new text file, input the number **253230** on the first line.
-
-
-6. Create a shortcut of `HatinTimeGame.exe` from that folder and move it to wherever you'd like. 
-You will use this shortcut to open the Archipelago-compatible version of A Hat in Time.
-
-
-7. Start up the game using your new shortcut. To confirm if you are on the correct version, 
-go to Settings -> Game Settings. If you don't see an option labelled ***Live Game Events*** you should be running 
-the correct version of the game. In Game Settings, make sure ***Enable Developer Console*** is checked.
+5. You should now be good to go. See below for more details on how to use the mod and connect to an Archipelago game.
 
 
 ## Connecting to the Archipelago server
 
-To connect to the multiworld server, simply run the **ArchipelagoAHITClient** 
-(or run it from the Launcher if you have the apworld installed) and connect it to the Archipelago server. 
+To connect to the multiworld server, simply run the **Archipelago AHIT Client** from the Launcher
+and connect it to the Archipelago server. 
 The game will connect to the client automatically when you create a new save file.
 
 
@@ -61,33 +49,8 @@ make sure ***Enable Developer Console*** is checked in Game Settings and press t
 
 
 ## FAQ/Common Issues
-### I followed the setup, but I receive an odd error message upon starting the game or creating a save file!
-If you receive an error message such as 
-**"Failed to find default engine .ini to retrieve My Documents subdirectory to use. Force quitting."** or
-**"Failed to load map "hub_spaceship"** after booting up the game or creating a save file respectively, then the depot
-download was likely corrupted. The only way to fix this is to start the entire download all over again.
-Unfortunately, this appears to be an underlying issue with Steam's depot downloader. The only way to really prevent this
-from happening is to ensure that your connection is not interrupted or slowed while downloading.
 
-### The game keeps crashing on startup after the splash screen!
-This issue is unfortunately very hard to fix, and the underlying cause is not known. If it does happen however,
-try the following:
-
-- Close Steam **entirely**.
-- Open the downpatched version of the game (with Steam closed) and allow it to load to the titlescreen.
-- Close the game, and then open Steam again. 
-- After launching the game, the issue should hopefully disappear. If not, repeat the above steps until it does.
-
-### I followed the setup, but "Live Game Events" still shows up in the options menu!
-The most common cause of this is the `steam_appid.txt` file. If you're on Windows 10, file extensions are hidden by 
-default (thanks Microsoft). You likely made the mistake of still naming the file `steam_appid.txt`, which, since file 
-extensions are hidden, would result in the file being named `steam_appid.txt.txt`, which is incorrect. 
-To show file extensions in Windows 10, open any folder, click the View tab at the top, and check
-"File name extensions". Then you can correct the name of the file. If the name of the file is correct, 
-and you're still running into the issue, re-read the setup guide again in case you missed a step. 
-If you still can't get it to work, ask for help in the Discord thread.
-
-### The game is running on the older version, but it's not connecting when starting a new save!
+### The game is not connecting when starting a new save!
 For unknown reasons, the mod will randomly disable itself in the mod menu. To fix this, go to the Mods menu 
 (rocket icon) in-game, and re-enable the mod.
 

worlds/alttp/Client.py

@@ -339,7 +339,7 @@ async def track_locations(ctx, roomid, roomdata) -> bool:
     def new_check(location_id):
         new_locations.append(location_id)
         ctx.locations_checked.add(location_id)
-        location = ctx.location_names.lookup_in_slot(location_id)
+        location = ctx.location_names.lookup_in_game(location_id)
         snes_logger.info(
             f'New Check: {location} ' +
             f'({len(ctx.checked_locations) + 1 if ctx.checked_locations else len(ctx.locations_checked)}/' +
@@ -552,7 +552,7 @@ class ALTTPSNIClient(SNIClient):
             item = ctx.items_received[recv_index]
             recv_index += 1
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names.lookup_in_slot(item.item), 'red', 'bold'),
+                color(ctx.item_names.lookup_in_game(item.item), 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
                 ctx.location_names.lookup_in_slot(item.location, item.player), recv_index, len(ctx.items_received)))
 
@@ -682,7 +682,7 @@ def get_alttp_settings(romfile: str):
 
         if 'yes' in choice:
             import LttPAdjuster
-            from worlds.alttp.Rom import get_base_rom_path
+            from .Rom import get_base_rom_path
             last_settings.rom = romfile
             last_settings.baserom = get_base_rom_path()
             last_settings.world = None

worlds/alttp/Dungeons.py

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

worlds/alttp/EntranceShuffle.py

@@ -1437,7 +1437,7 @@ def connect_mandatory_exits(world, entrances, caves, must_be_exits, player):
     invalid_cave_connections = defaultdict(set)
 
     if world.glitches_required[player] in ['overworld_glitches', 'hybrid_major_glitches', 'no_logic']:
-        from worlds.alttp import OverworldGlitchRules
+        from . import OverworldGlitchRules
         for entrance in OverworldGlitchRules.get_non_mandatory_exits(world.mode[player] == 'inverted'):
             invalid_connections[entrance] = set()
             if entrance in must_be_exits:

worlds/alttp/ItemPool.py

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

worlds/alttp/Options.py

@@ -1,8 +1,8 @@
 import typing
 
 from BaseClasses import MultiWorld
-from Options import Choice, Range, Option, Toggle, DefaultOnToggle, DeathLink, \
-    StartInventoryPool, PlandoBosses, PlandoConnections, PlandoTexts, FreeText, Removed
+from Options import Choice, Range, DeathLink, DefaultOnToggle, FreeText, ItemsAccessibility, Option, \
+    PlandoBosses, PlandoConnections, PlandoTexts, Removed, StartInventoryPool, Toggle
 from .EntranceShuffle import default_connections, default_dungeon_connections, \
     inverted_default_connections, inverted_default_dungeon_connections
 from .Text import TextTable
@@ -486,7 +486,7 @@ class LTTPBosses(PlandoBosses):
 
     @classmethod
     def can_place_boss(cls, boss: str, location: str) -> bool:
-        from worlds.alttp.Bosses import can_place_boss
+        from .Bosses import can_place_boss
         level = ''
         words = location.split(" ")
         if words[-1] in ("top", "middle", "bottom"):
@@ -743,6 +743,7 @@ class ALttPPlandoTexts(PlandoTexts):
 
 
 alttp_options: typing.Dict[str, type(Option)] = {
+    "accessibility": ItemsAccessibility,
     "plando_connections": ALttPPlandoConnections,
     "plando_texts": ALttPPlandoTexts,
     "start_inventory_from_pool": StartInventoryPool,

worlds/alttp/OverworldGlitchRules.py

@@ -220,26 +220,7 @@ def get_invalid_bunny_revival_dungeons():
     yield 'Sanctuary'
 
 
-def no_logic_rules(world, player):
-    """
-    Add OWG transitions to no logic player's world
-    """
-    create_no_logic_connections(player, world, get_boots_clip_exits_lw(world.mode[player] == 'inverted'))
-    create_no_logic_connections(player, world, get_boots_clip_exits_dw(world.mode[player] == 'inverted', player))
-
-    # Glitched speed drops.
-    create_no_logic_connections(player, world, get_glitched_speed_drops_dw(world.mode[player] == 'inverted'))
-
-    # Mirror clip spots.
-    if world.mode[player] != 'inverted':
-        create_no_logic_connections(player, world, get_mirror_clip_spots_dw())
-        create_no_logic_connections(player, world, get_mirror_offset_spots_dw())
-    else:
-        create_no_logic_connections(player, world, get_mirror_offset_spots_lw(player))
-
-
 def overworld_glitch_connections(world, player):
-
     # Boots-accessible locations.
     create_owg_connections(player, world, get_boots_clip_exits_lw(world.mode[player] == 'inverted'))
     create_owg_connections(player, world, get_boots_clip_exits_dw(world.mode[player] == 'inverted', player))

worlds/alttp/Regions.py

@@ -406,7 +406,7 @@ def create_dungeon_region(world: MultiWorld, player: int, name: str, hint: str,
 
 def _create_region(world: MultiWorld, player: int, name: str, type: LTTPRegionType, hint: str, locations=None,
                    exits=None):
-    from worlds.alttp.SubClasses import ALttPLocation
+    from .SubClasses import ALttPLocation
     ret = LTTPRegion(name, type, hint, player, world)
     if exits:
         for exit in exits:
@@ -760,7 +760,7 @@ location_table: typing.Dict[str,
      'Turtle Rock - Prize': (
          [0x120A7, 0x53F24, 0x53F25, 0x18005C, 0x180079, 0xC708], None, True, 'Turtle Rock')}
 
-from worlds.alttp.Shops import shop_table_by_location_id, shop_table_by_location
+from .Shops import shop_table_by_location_id, shop_table_by_location
 lookup_id_to_name = {data[0]: name for name, data in location_table.items() if type(data[0]) == int}
 lookup_id_to_name = {**lookup_id_to_name, **{data[1]: name for name, data in key_drop_data.items()}}
 lookup_id_to_name.update(shop_table_by_location_id)

worlds/alttp/Rules.py

@@ -2,6 +2,7 @@ import collections
 import logging
 from typing import Iterator, Set
 
+from Options import ItemsAccessibility
 from BaseClasses import Entrance, MultiWorld
 from worlds.generic.Rules import (add_item_rule, add_rule, forbid_item,
                                   item_name_in_location_names, location_item_name, set_rule, allow_self_locking_items)
@@ -10,7 +11,7 @@ from . import OverworldGlitchRules
 from .Bosses import GanonDefeatRule
 from .Items import item_factory, item_name_groups, item_table, progression_items
 from .Options import small_key_shuffle
-from .OverworldGlitchRules import no_logic_rules, overworld_glitches_rules
+from .OverworldGlitchRules import overworld_glitches_rules
 from .Regions import LTTPRegionType, location_table
 from .StateHelpers import (can_extend_magic, can_kill_most_things,
                            can_lift_heavy_rocks, can_lift_rocks,
@@ -33,14 +34,13 @@ def set_rules(world):
                 'WARNING! Seeds generated under this logic often require major glitches and may be impossible!')
 
         if world.players == 1:
-            no_logic_rules(world, player)
             for exit in world.get_region('Menu', player).exits:
                 exit.hide_path = True
             return
         else:
             # Set access rules according to max glitches for multiworld progression.
             # Set accessibility to none, and shuffle assuming the no logic players can always win
-            world.accessibility[player] = world.accessibility[player].from_text("minimal")
+            world.accessibility[player].value = ItemsAccessibility.option_minimal
             world.progression_balancing[player].value = 0
 
     else:
@@ -378,7 +378,7 @@ def global_rules(multiworld: MultiWorld, player: int):
                                 or state.has("Cane of Somaria", player)))
     set_rule(multiworld.get_location('Tower of Hera - Big Chest', player), lambda state: state.has('Big Key (Tower of Hera)', player))
     set_rule(multiworld.get_location('Tower of Hera - Big Key Chest', player), lambda state: has_fire_source(state, player))
-    if multiworld.accessibility[player] != 'locations':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Tower of Hera - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Tower of Hera)' and item.player == player)
 
     set_rule(multiworld.get_entrance('Swamp Palace Moat', player), lambda state: state.has('Flippers', player) and state.has('Open Floodgate', player))
@@ -394,7 +394,7 @@ def global_rules(multiworld: MultiWorld, player: int):
         if state.has('Hookshot', player)
         else state._lttp_has_key('Small Key (Swamp Palace)', player, 4))
     set_rule(multiworld.get_location('Swamp Palace - Big Chest', player), lambda state: state.has('Big Key (Swamp Palace)', player))
-    if multiworld.accessibility[player] != 'locations':
+    if multiworld.accessibility[player] != 'full':
         allow_self_locking_items(multiworld.get_location('Swamp Palace - Big Chest', player), 'Big Key (Swamp Palace)')
     set_rule(multiworld.get_entrance('Swamp Palace (North)', player), lambda state: state.has('Hookshot', player) and state._lttp_has_key('Small Key (Swamp Palace)', player, 5))
     if not multiworld.small_key_shuffle[player] and multiworld.glitches_required[player] not in ['hybrid_major_glitches', 'no_logic']:
@@ -406,16 +406,14 @@ def global_rules(multiworld: MultiWorld, player: int):
         set_rule(multiworld.get_location('Swamp Palace - Waterway Pot Key', player), lambda state: can_use_bombs(state, player))
 
     set_rule(multiworld.get_entrance('Thieves Town Big Key Door', player), lambda state: state.has('Big Key (Thieves Town)', player))
-
     if multiworld.worlds[player].dungeons["Thieves Town"].boss.enemizer_name == "Blind":
         set_rule(multiworld.get_entrance('Blind Fight', player), lambda state: state._lttp_has_key('Small Key (Thieves Town)', player, 3) and can_use_bombs(state, player))
-
     set_rule(multiworld.get_location('Thieves\' Town - Big Chest', player),
              lambda state: ((state._lttp_has_key('Small Key (Thieves Town)', player, 3)) or (location_item_name(state, 'Thieves\' Town - Big Chest', player) == ("Small Key (Thieves Town)", player)) and state._lttp_has_key('Small Key (Thieves Town)', player, 2)) and state.has('Hammer', player))
-
-    if multiworld.accessibility[player] != 'locations' and not multiworld.key_drop_shuffle[player]:
+    set_rule(multiworld.get_location('Thieves\' Town - Blind\'s Cell', player),
+             lambda state: state._lttp_has_key('Small Key (Thieves Town)', player))
+    if multiworld.accessibility[player] != 'full' and not multiworld.key_drop_shuffle[player]:
         set_always_allow(multiworld.get_location('Thieves\' Town - Big Chest', player), lambda state, item: item.name == 'Small Key (Thieves Town)' and item.player == player)
-
     set_rule(multiworld.get_location('Thieves\' Town - Attic', player), lambda state: state._lttp_has_key('Small Key (Thieves Town)', player, 3))
     set_rule(multiworld.get_location('Thieves\' Town - Spike Switch Pot Key', player),
              lambda state: state._lttp_has_key('Small Key (Thieves Town)', player))
@@ -426,7 +424,7 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_entrance('Skull Woods First Section West Door', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
     set_rule(multiworld.get_entrance('Skull Woods First Section (Left) Door to Exit', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
     set_rule(multiworld.get_location('Skull Woods - Big Chest', player), lambda state: state.has('Big Key (Skull Woods)', player) and can_use_bombs(state, player))
-    if multiworld.accessibility[player] != 'locations':
+    if multiworld.accessibility[player] != 'full':
         allow_self_locking_items(multiworld.get_location('Skull Woods - Big Chest', player), 'Big Key (Skull Woods)')
     set_rule(multiworld.get_entrance('Skull Woods Torch Room', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 4) and state.has('Fire Rod', player) and has_sword(state, player))  # sword required for curtain
     add_rule(multiworld.get_location('Skull Woods - Prize', player), lambda state: state._lttp_has_key('Small Key (Skull Woods)', player, 5))
@@ -491,7 +489,7 @@ def global_rules(multiworld: MultiWorld, player: int):
     set_rule(multiworld.get_location('Turtle Rock - Roller Room - Right', player), lambda state: state.has('Cane of Somaria', player) and state.has('Fire Rod', player))
     set_rule(multiworld.get_location('Turtle Rock - Big Chest', player), lambda state: state.has('Big Key (Turtle Rock)', player) and (state.has('Cane of Somaria', player) or state.has('Hookshot', player)))
     set_rule(multiworld.get_entrance('Turtle Rock (Big Chest) (North)', player), lambda state: state.has('Cane of Somaria', player) or state.has('Hookshot', player))
-    set_rule(multiworld.get_entrance('Turtle Rock Big Key Door', player), lambda state: state.has('Big Key (Turtle Rock)', player) and can_kill_most_things(state, player, 10))
+    set_rule(multiworld.get_entrance('Turtle Rock Big Key Door', player), lambda state: state.has('Big Key (Turtle Rock)', player) and can_kill_most_things(state, player, 10) and can_bomb_or_bonk(state, player))
     set_rule(multiworld.get_location('Turtle Rock - Chain Chomps', player), lambda state: can_use_bombs(state, player) or can_shoot_arrows(state, player)
                                                                                           or has_beam_sword(state, player) or state.has_any(["Blue Boomerang", "Red Boomerang", "Hookshot", "Cane of Somaria", "Fire Rod", "Ice Rod"], player))
     set_rule(multiworld.get_entrance('Turtle Rock (Dark Room) (North)', player), lambda state: state.has('Cane of Somaria', player))
@@ -525,12 +523,12 @@ def global_rules(multiworld: MultiWorld, player: int):
 
     set_rule(multiworld.get_entrance('Palace of Darkness Big Key Chest Staircase', player), lambda state: can_use_bombs(state, player) and (state._lttp_has_key('Small Key (Palace of Darkness)', player, 6) or (
             location_item_name(state, 'Palace of Darkness - Big Key Chest', player) in [('Small Key (Palace of Darkness)', player)] and state._lttp_has_key('Small Key (Palace of Darkness)', player, 3))))
-    if multiworld.accessibility[player] != 'locations':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Palace of Darkness - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Palace of Darkness)' and item.player == player and state._lttp_has_key('Small Key (Palace of Darkness)', player, 5))
 
     set_rule(multiworld.get_entrance('Palace of Darkness Spike Statue Room Door', player), lambda state: state._lttp_has_key('Small Key (Palace of Darkness)', player, 6) or (
             location_item_name(state, 'Palace of Darkness - Harmless Hellway', player) in [('Small Key (Palace of Darkness)', player)] and state._lttp_has_key('Small Key (Palace of Darkness)', player, 4)))
-    if multiworld.accessibility[player] != 'locations':
+    if multiworld.accessibility[player] != 'full':
         set_always_allow(multiworld.get_location('Palace of Darkness - Harmless Hellway', player), lambda state, item: item.name == 'Small Key (Palace of Darkness)' and item.player == player and state._lttp_has_key('Small Key (Palace of Darkness)', player, 5))
 
     set_rule(multiworld.get_entrance('Palace of Darkness Maze Door', player), lambda state: state._lttp_has_key('Small Key (Palace of Darkness)', player, 6))
@@ -549,7 +547,7 @@ def global_rules(multiworld: MultiWorld, player: int):
                 location_item_name(state, 'Ganons Tower - Map Chest', player) in [('Big Key (Ganons Tower)', player)] and state._lttp_has_key('Small Key (Ganons Tower)', player, 6)))
 
     # this seemed to be causing generation failure, disable for now
-    # if world.accessibility[player] != 'locations':
+    # if world.accessibility[player] != 'full':
     #     set_always_allow(world.get_location('Ganons Tower - Map Chest', player), lambda state, item: item.name == 'Small Key (Ganons Tower)' and item.player == player and state._lttp_has_key('Small Key (Ganons Tower)', player, 7) and state.can_reach('Ganons Tower (Hookshot Room)', 'region', player))
 
     # It is possible to need more than 6 keys to get through this entrance if you spend keys elsewhere. We reflect this in the chest requirements.
@@ -1203,7 +1201,7 @@ def set_trock_key_rules(world, player):
                 # Must not go in the Chain Chomps chest - only 2 other chests available and 3+ keys required for all other chests
                 forbid_item(world.get_location('Turtle Rock - Chain Chomps', player), 'Big Key (Turtle Rock)', player)
                 forbid_item(world.get_location('Turtle Rock - Pokey 2 Key Drop', player), 'Big Key (Turtle Rock)', player)
-            if world.accessibility[player] == 'locations':
+            if world.accessibility[player] == 'full':
                 if world.big_key_shuffle[player] and can_reach_big_chest:
                     # Must not go in the dungeon - all 3 available chests (Chomps, Big Chest, Crystaroller) must be keys to access laser bridge, and the big key is required first
                     for location in ['Turtle Rock - Chain Chomps', 'Turtle Rock - Compass Chest',
@@ -1217,7 +1215,7 @@ def set_trock_key_rules(world, player):
                     location.place_locked_item(item)
                     toss_junk_item(world, player)
 
-    if world.accessibility[player] != 'locations':
+    if world.accessibility[player] != 'full':
         set_always_allow(world.get_location('Turtle Rock - Big Key Chest', player), lambda state, item: item.name == 'Small Key (Turtle Rock)' and item.player == player
                 and state.can_reach(state.multiworld.get_region('Turtle Rock (Second Section)', player)))
 

worlds/alttp/SubClasses.py

@@ -76,10 +76,6 @@ class ALttPItem(Item):
         if self.type in {"SmallKey", "BigKey", "Map", "Compass"}:
             return self.type
 
-    @property
-    def locked_dungeon_item(self):
-        return self.location.locked and self.dungeon_item
-
 
 class LTTPRegionType(IntEnum):
     LightWorld = 1

worlds/alttp/__init__.py

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

worlds/alttp/docs/plando_en.md

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

worlds/alttp/test/dungeons/TestDungeon.py

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